Classes

CMPS 2143

2

Overview (Chapter 4)•Terms•Class vs instance•Class definitions in various languages•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};int getRank () {return rankValue}

private:Suits suitValue;int rankValue;

};

6

Java SE6+ /C# (class declaration/definition)

public class PlayingCard { public enum Suits {Spade, Diamond, Club, Heart};

public Suits getSuit () {return suitValue}; public int getRank () {return rankValue}

private Suits suitValue; private int rankValue;}

8

Superficial differencesC++ 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

12

C++ (Revise PlayingCard)•Add a constructor (Ch 3)

•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};int getRank () {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;int rankValue;

bool faceUp;};

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++ const int 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. getColor would 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

1. Too long and the method body obscures other features in class definition, so we do it for readability

▫ Eye of the beholder2. 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

29

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

30

C++ Forward Definitionclass Horse; //forward def

class Buggy { : Horse * myHorse;};

class Horse { : Buggy * myBuggy;};

31

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::

32

C++ example – Linked list with Nodesclass List { class Node { int value; Node * nextNode; //uses default constructor }

public: // put List Methods here :

private: Node * head; Node * cursor; int count;}

33

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

34

C++, Java, C# similar•Use static modifier

class Student { public: Student () { count++; studentID = count; } :

private: static int count = 20200000; int studentID;}

36

Package Example on Y:/drive

•Visual Studio 2013 C++ Package class• Java Package class•Eclipse Project Package

•All in Y:/drive folder in lab