classes n.
Skip this Video
Loading SlideShow in 5 Seconds..
Classes PowerPoint Presentation


156 Views Download Presentation
Download Presentation


- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Classes CMPS 2143

  2. Overview • Terms • Class vs instance • Class definitions in various languags • Access modifiers • Methods • Constants • Separating definition and implementation • Properties • Class data • Inner classes

  3. Terms • Instance – representative or example of a class • Instance variable – internal variable owned by a class • Aka data field or data member • State – described by the instance variables and their values • Behavior – characterized by methods Glossary at the end of the book

  4. Class Definitions • We’ll start with the playing card abstraction – • Container for two data values • Rank: Ace – King represented by 1-13 • Suit: enum type • We’ll see this in several different languages

  5. C++ (class declaration/definition) class PlayingCard { public: enum Suits {Spade, Diamond, Club, Heart}; Suits getSuit () {return suitValue}; intgetRank () {return rankValue} private: Suits suitValue; intrankValue; };

  6. Java SE6+ /C# (class declaration/definition) public class PlayingCard { public enum Suits {Spade, Diamond, Club, Heart}; public Suits getSuit () {return suitValue}; public intgetRank () {return rankValue} private Suits suitValue; private intrankValue; }

  7. C# (class declaration/definition) public class PlayingCard { public enum Suits {Spade, Diamond, Club, Heart}; public Suits getSuit () {return suitValue}; public intgetRank () {return rankValue} private Suits suitValue; private intrankValue; }

  8. Superficial differences C++ Java / C# • Semicolon • Visibility modifiers mark an entire block aCard.suit() = PlayingCard::Heart; • enum • No semicolon • Modifiers placed on EVERY declaration aCard.suit() = PlayingCard.Suits.Heart; • enums in Java 6+ and C# • In earlier Java, declare final static variables • final means they are constant • static means they are shared by all instances of class • Note: Ask for a drawing on board

  9. Apple Object Pascal and Delphi Pascal • Based on Pascal, but extended • Both have enumerated types • Object Pascal uses keyword object to declare a class (object types) and Delphi Pascal uses class • Delphi Pascal requires EVERY class to inherit from some existing class, hence it has a Tobject • Delphi, all classes start with T by convention • Delphi uses visibility modifiers, Object Pascal des not • Delphi requires a constructor

  10. Smalltalk • Doesn’t have a textual representation of a class • Classes are described using an interactive interface (like a IDE) • Using this, programmer defines a new class • Uses a message sent to parent class Object • Like Delphi, requires class to name a specific parent class • Do not have visibility modifiers - all data fields are private by default

  11. Other languages • Clos (Lisp-like) (defclassPlayingCard () (rank suit)) • Eiffel – see book • Objective-C – see book • Python – uses indentation, not beginning/ending tokens class PlayingCard: “A playing card class” def __init__ (self, s, r); self.suit = s self.rank = r

  12. C++ (Revise PlayingCard) • Add a constructor • Add a method to return the face color of the card (red or black) • Add a data field to maintain whether the card is faceup or facedown, and methods to test the state of this value and to flip the card. • Add a second enumerated type to represent the colors

  13. class PlayingCard { public: enum Suits {Spade, Diamond, Club, Heart}; enum Colors {Red, Black}; PlayingCard (Suits s, int r) { suitValue = s; rankValue = r;} Suits getSuit () {return suitValue}; intgetRank () {return rankValue}; void setFaceUp (bool up) {faceUp = up;} void flip () {setFaceUp (!faceUp);}

  14. Colors getColor () { if ((suit() == Suits.Diamond) || (suit () == Suits.Heart)) return Color.Red; else return Color.Black; } private: Suits suitValue; intrankValue; boolfaceUp; };

  15. Comments on C++ revised PlayingCard • Most OOP guidelines indicate member data always private or protected • Constructor is a special method with same name as class • Methods that return values are termed accessors and often use get in the method name (getRank) • Methods that return boolean values are special accessors known as predicates (isFaceUp) • Why not make the member data public? • Methods that set values are termed mutators or setters (setFaceUp)

  16. Comments on C++ revised PlayingCard • Method flip? Not an accessor, text says not a mutator just a method • Method getColor? Not getting and returning a value of a data member  just a method • But I – me, personally • think flip is a mutator as it changes state • getColor is accessing a data field to return a value based on it

  17. Order of methods in class declaration • Style guidelines say • Important features listed earlier • Constructors are most important, so appear near top • Methods grouped – alphabetically or by purpose • Private data fields and private methods are for the developer and should be near the end of the class

  18. Constants or immutable data fields • A data field that once sets, cannot subsequently be changed • As this restriction protects the data field, no need to make it private • C++ constint MAXSIZE = 100; • Java public final int MAXSIZE = 100; • If not set to a value, MUST be set in constructor(s)

  19. Separating definition and implementation • Java and C# place body of method directly in class declaration • Many languages separate these two aspects • C++ you have a choice • Small methods can be defined in the class • Larger methods defined outside (e.g. getColorwould be a good choice)

  20. class PlayingCard { //in header file public: : Colors color (); : } Colors PlayingCard::getColor( ) //in .cpp file { if ((suit() == Suits.Diamond) || (suit () == Suits.Heart)) return Color.Red; else return Color.Black; }

  21. Two reasons to put method body outside class definition • Too long and the method body obscures other features in class definition, so we do it for readability • Eye of the beholder • When methods bodies are in-line, the C++ compiler is permitted to expand invocations of the method directly in the client code without creating a function call • Executed much faster as a result

  22. Other languages • Objective-C separates class definition from class imlementation • Object Pascal and Delphi separate them into an interface section and an implementation section, but keep them in same file • In C++, you can separate them and keep them in same file also

  23. Other languages: CLOS (defclassPlayingCard () ((rank :accessorgetRank) (suit :accessorgetSuit) ) )

  24. Other languages: Python class PlayingCard: “A playing card class” def __inti__ (self, s, r): self.suit =s self.rank = r def rank (self) return self.rank def color (self) if self.suit== 1 or self.suit == 2 return 1 return 0

  25. Properties • Smalltalk, Delphi, Visual Basic, C# and others have properties • A property is manipulated syntactically like a data field, but really operates like a method • Delphi uses keyword property • Smalltalk – has accessor methods with same name as data field • C# has special methods with same name as data field …the convention is to capitalize their name

  26. C# Properties public class PlayingCard { public int RankValue { get {return rankValue;} //MUST return a value set {rankValue = value;} //value is a pseudo-var } : private int rankValue; : } • Property without a get is a write-only property • Property without a set is a read-only property

  27. Forward Definitions • Two or more classes may need access to one another (RARE) • Mutual recursion • Example: Horse and Buggy • Java easy – it is a multi-pass compiler • C++ - must use a forward definition

  28. C++ Forward Definition class Horse; //forward def class Buggy { : Horse * myHorse; }; class Horse { : Buggy * myBuggy; };

  29. Inner or Nested Classes • Java and C++ allow nested classes • Java – inner class C++ - nested class • Similar in appearance, but different semantically • Java • inner class is linked to a specific instance and has access to data fields and methods in the object • Can have an inner class with no name, too • C++ - simply a naming device (restricts visibility with the inner class. • If you need the nested class outside the class • List::Link:: similar to the enum type Package::Shipping::

  30. C++ example – Linked list with Nodes class List { class Node { int value; Node * nextNode; //uses default constructor } public: // put List Methods here : private: Node * head; Node * cursor; int count; }

  31. Class Data Fields • A common data field that is shared by all instances of a class create a paradox – who initializes it? • Every instance (reinitializes over and over) X • No instances do (leaves it uninitialized) X • Move outside the simple class/method/instance paradigm • Another mechanism needed • Memory manager initializes it to a default value • Every instance can test for this and see if they are first and then initialize it to value desired

  32. C++, Java, C# similar • Use static modifier class Student { public: Student () { count++; studentID = count; } : private: static int count = 20200000; int studentID; }

  33. Package Example • Visual Studio 2010 C++ Package class • Java Package class • Eclipse Project Package • All in Y:/drive folder in lab