1 / 33

Classes

Classes. CMPS 2143. Overview. Terms Class vs instance Class definitions in various languags Access modifiers Methods Constants Separating definition and implementation Properties Class data Inner classes. Terms. Instance – representative or example of a class

morag
Download Presentation

Classes

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

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

More Related