Chapter 4:Chapter 4:

Writing ClassesWriting Classes

2

Writing ClassesWriting Classes We've been using predefined classes. Now we will learn to We've been using predefined classes. Now we will learn to

write our own classes to define new objectswrite our own classes to define new objects

Chapter 4 focuses on:Chapter 4 focuses on:• class declarationsclass declarations• method declarationsmethod declarations• instance variablesinstance variables• encapsulationencapsulation• method overloadingmethod overloading• graphics-based objectsgraphics-based objects

3

ObjectsObjects An object has:An object has:

• statestate - descriptive characteristics - descriptive characteristics• behaviorsbehaviors - what it can do (or be done to it) - what it can do (or be done to it)

For example, consider a coin that can be flipped so that it's For example, consider a coin that can be flipped so that it's face shows either "heads" or "tails"face shows either "heads" or "tails"

The state of the coin is its current face (heads or tails)The state of the coin is its current face (heads or tails) The behavior of the coin is that it can be flippedThe behavior of the coin is that it can be flipped Note that the behavior of the coin might change its stateNote that the behavior of the coin might change its state

4

ClassesClasses A A classclass is a blueprint of an object is a blueprint of an object

It is the model or pattern from which objects are createdIt is the model or pattern from which objects are created

For example, the For example, the StringString class is used to define class is used to define StringString objectsobjects

Each Each StringString object contains specific characters (its state) object contains specific characters (its state)

Each Each StringString object can perform services (behaviors) such object can perform services (behaviors) such as as toUpperCasetoUpperCase

ClassesClasses The The StringString class was provided for us by the Java class was provided for us by the Java

standard class librarystandard class library

But we can also write our own classes that define specific But we can also write our own classes that define specific objects that we needobjects that we need

For example, suppose we wanted to write a program that For example, suppose we wanted to write a program that simulates the flipping of a coinsimulates the flipping of a coin

We could write a We could write a CoinCoin class to represent a coin object class to represent a coin object

ClassesClasses A class contains data declarations and method declarationsA class contains data declarations and method declarations

int x, y;char ch;

Data declarationsData declarations

Method declarationsMethod declarations

Data ScopeData Scope The The scopescope of data is the area in a program in which that of data is the area in a program in which that

data can be used (referenced)data can be used (referenced)

Data declared at the class level can be used by all methods Data declared at the class level can be used by all methods in that classin that class

Data declared within a method can only be used in that Data declared within a method can only be used in that methodmethod

Data declared within a method is called Data declared within a method is called local datalocal data

Writing MethodsWriting Methods A A method declarationmethod declaration specifies the code that will be specifies the code that will be

executed when the method is invoked (or called)executed when the method is invoked (or called)

When a method is invoked, the flow of control jumps to the When a method is invoked, the flow of control jumps to the method and executes its codemethod and executes its code

When complete, the flow returns to the place where the When complete, the flow returns to the place where the method was called and continuesmethod was called and continues

The invocation may or may not return a value, depending The invocation may or may not return a value, depending on how the method was definedon how the method was defined

myMethod();

myMethodcompute

Method Control FlowMethod Control Flow The called method could be within the same class, in which The called method could be within the same class, in which

case only the method name is neededcase only the method name is needed

doIt

helpMe

helpMe();

obj.doIt();

main

Method Control FlowMethod Control Flow The called method could be part of another class or objectThe called method could be part of another class or object

The Coin ClassThe Coin Class In our In our CoinCoin class we could define the following data: class we could define the following data:

• faceface, an integer that represents the current face, an integer that represents the current face• HEADSHEADS and and TAILSTAILS, integer constants that represent the two , integer constants that represent the two

possible statespossible states

We might also define the following methods:We might also define the following methods:• a a CoinCoin constructor, to set up the object constructor, to set up the object• a a flipflip method, to flip the coin method, to flip the coin• a a getFacegetFace method, to return the current face method, to return the current face• a a toStringtoString method, to return a string description for printing method, to return a string description for printing

The Coin ClassThe Coin Class See See CountFlipsCountFlips.java .java (page 179)(page 179) See Coin.java (page 180)See Coin.java (page 180)

Once the Once the CoinCoin class has been defined, we can use it again class has been defined, we can use it again in other programs as neededin other programs as needed

Note that the Note that the CountFlipsCountFlips program did not use the program did not use the toStringtoString method method

A program will not necessarily use every service provided A program will not necessarily use every service provided by an objectby an object

Example- - Coin Program 1 of Example- - Coin Program 1 of 44////

****************************************************************************************************************************************

// Coin.java Author: Lewis and Loftus// Coin.java Author: Lewis and Loftus////// Represents a coin with two sides that can be flipped.// Represents a coin with two sides that can be flipped.////

****************************************************************************************************************************************

public class Coinpublic class Coin{{ public final int HEADS = 0;public final int HEADS = 0; public final int TAILS = 1;public final int TAILS = 1;

2 of 42 of 4private int face;private int face;

//-----------------------------------------------------------------//----------------------------------------------------------------- // Sets up the coin by flipping it initially.// Sets up the coin by flipping it initially. //-----------------------------------------------------------------//----------------------------------------------------------------- public Coin ()public Coin () {{ flip();flip(); }}

//-----------------------------------------------------------------//----------------------------------------------------------------- // Flips the coin by randomly choosing a face.// Flips the coin by randomly choosing a face. //-----------------------------------------------------------------//-----------------------------------------------------------------

`̀ 3 of 3 of 44public void flip ()public void flip () {{ face = (int) (Math.random() * 2);face = (int) (Math.random() * 2); }}

//-----------------------------------------------------------------//----------------------------------------------------------------- // Returns the current face of the coin as an integer.// Returns the current face of the coin as an integer. //-----------------------------------------------------------------//----------------------------------------------------------------- public int getFace ()public int getFace () {{ return face;return face; }}

4 of 4 of 44//-----------------------------------------------------------------//----------------------------------------------------------------- // Returns the current face of the coin as a string.// Returns the current face of the coin as a string. //-----------------------------------------------------------------//----------------------------------------------------------------- public String toString()public String toString() {{ String faceName;String faceName;

if (face == HEADS)if (face == HEADS) faceName = "Heads";faceName = "Heads"; elseelse faceName = "Tails";faceName = "Tails";

return faceName;return faceName; }}}}

Instance DataInstance Data The The faceface variable in the variable in the CoinCoin class is called class is called instance datainstance data

because each instance (object) of the because each instance (object) of the CoinCoin class has its own class has its own

A class declares the type of the data, but it does not reserve A class declares the type of the data, but it does not reserve any memory space for itany memory space for it

Every time a Every time a CoinCoin object is created, a new object is created, a new faceface variable is variable is created as wellcreated as well

The objects of a class share the method definitions, but they The objects of a class share the method definitions, but they have unique data spacehave unique data space

That's the only way two objects can have different statesThat's the only way two objects can have different states

Instance DataInstance Data See FlipRace.java (page 182)See FlipRace.java (page 182)

face 0

coin1

int face;

class Coin

face 1

coin2

19

EncapsulationEncapsulation You can take one of two views of an object:You can take one of two views of an object:

• internal - the structure of its data, the algorithms used by its methodsinternal - the structure of its data, the algorithms used by its methods

• external - the interaction of the object with other objects in the external - the interaction of the object with other objects in the programprogram

From the external view, an object is an From the external view, an object is an encapsulatedencapsulated entity, entity, providing a set of specific servicesproviding a set of specific services

These services define the These services define the interfaceinterface to the object to the object

Recall from Chapter 2 that an object is an Recall from Chapter 2 that an object is an abstractionabstraction, hiding , hiding details from the rest of the systemdetails from the rest of the system

20

EncapsulationEncapsulation An object should be An object should be self-governingself-governing

Any changes to the object's state (its variables) should be Any changes to the object's state (its variables) should be accomplished by that object's methodsaccomplished by that object's methods

We should make it difficult, if not impossible, for one We should make it difficult, if not impossible, for one object to "reach in" and alter another object's stateobject to "reach in" and alter another object's state

The user, or The user, or clientclient, of an object can request its services, but , of an object can request its services, but it should not have to be aware of how those services are it should not have to be aware of how those services are accomplishedaccomplished

21

EncapsulationEncapsulation An encapsulated object can be thought of as a An encapsulated object can be thought of as a black boxblack box Its inner workings are hidden to the client, which only Its inner workings are hidden to the client, which only

invokes the interface methodsinvokes the interface methods

ClientClient Methods

Data

22

Visibility ModifiersVisibility Modifiers In Java, we accomplish encapsulation through the In Java, we accomplish encapsulation through the

appropriate use of appropriate use of visibility modifiersvisibility modifiers

A A modifiermodifier is a Java reserved word that specifies particular is a Java reserved word that specifies particular characteristics of a method or data valuecharacteristics of a method or data value

We've used the modifier We've used the modifier finalfinal to define a constant to define a constant

Java has three visibility modifiers: Java has three visibility modifiers: publicpublic, , privateprivate, , and and protectedprotected

We will discuss the We will discuss the protectedprotected modifier later modifier later

23

Visibility ModifiersVisibility Modifiers Members of a class that are declared with Members of a class that are declared with public visibilitypublic visibility

can be accessed from anywherecan be accessed from anywhere

Members of a class that are declared with Members of a class that are declared with private visibilityprivate visibility can only be accessed from inside the classcan only be accessed from inside the class

Members declared without a visibility modifier have Members declared without a visibility modifier have default default visibilityvisibility and can be accessed by any class in the same and can be accessed by any class in the same packagepackage

Java modifiers are discussed in detail in Appendix FJava modifiers are discussed in detail in Appendix F

24

Visibility ModifiersVisibility Modifiers As a general rule, no object's data should be declared with As a general rule, no object's data should be declared with

public visibilitypublic visibility

Methods that provide the object's services are usually Methods that provide the object's services are usually declared with public visibility so that they can be invoked declared with public visibility so that they can be invoked by clientsby clients

Public methods are also called Public methods are also called service methodsservice methods

A method created simply to assist a service method is called A method created simply to assist a service method is called a a support methodsupport method

Since a support method is not intended to be called by a Since a support method is not intended to be called by a client, it should not be declared with public visibilityclient, it should not be declared with public visibility

Method Declarations RevisitedMethod Declarations Revisited A method declaration begins with a A method declaration begins with a method headermethod header

char calc (int num1, int num2, String message)

methodmethodnamename

returnreturntypetype

parameter listparameter list

The parameter list specifies the typeThe parameter list specifies the typeand name of each parameterand name of each parameter

The name of a parameter in the methodThe name of a parameter in the methoddeclaration is called a declaration is called a formal argumentformal argument

Method DeclarationsMethod Declarations The method header is followed by the The method header is followed by the method bodymethod body

char calc (int num1, int num2, String message){ int sum = num1 + num2; char result = message.charAt (sum);

return result;}

The return expression must beThe return expression must beconsistent with the return typeconsistent with the return type

sumsum and and resultresultare are local datalocal data

They are created each They are created each time the method is called, time the method is called, and are destroyed when and are destroyed when it finishes executingit finishes executing

27

The return StatementThe return Statement The The return typereturn type of a method indicates the type of value that of a method indicates the type of value that

the method sends back to the calling locationthe method sends back to the calling location

A method that does not return a value has aA method that does not return a value has a void void return return typetype

The The return statementreturn statement specifies the value that will be specifies the value that will be returnedreturned

Its expression must conform to the return typeIts expression must conform to the return type

ParametersParameters Each time a method is called, the Each time a method is called, the actual argumentsactual arguments in the invocation are copied in the invocation are copied

into the formal argumentsinto the formal arguments

char calc (int num1, int num2, String message){ int sum = num1 + num2; char result = message.charAt (sum);

return result;}

ch = obj.calc (25, count, "Hello");

29

Constructors RevisitedConstructors Revisited Recall that a constructor is a special method that is used to Recall that a constructor is a special method that is used to

set up a newly created objectset up a newly created object

When writing a constructor, remember that:When writing a constructor, remember that:• it has the same name as the classit has the same name as the class• it does not return a valueit does not return a value• it has no return type, not evenit has no return type, not even void void• it often sets the initial values of instance variables it often sets the initial values of instance variables

The programmer does not have to define a constructor for The programmer does not have to define a constructor for a classa class

Writing ClassesWriting Classes See BankAccounts.java (page 188)See BankAccounts.java (page 188) See Account.java (page 189)See Account.java (page 189)

An An aggregate objectaggregate object is an object that contains references to is an object that contains references to other objectsother objects

An An AccountAccount object is an aggregate object because it object is an aggregate object because it contains a reference to a contains a reference to a StringString object (that holds the object (that holds the owner's name)owner's name)

An aggregate object represents a An aggregate object represents a has-a relationshiphas-a relationship A bank account A bank account has ahas a name name

Writing ClassesWriting Classes Sometimes an object has to interact with other objects of Sometimes an object has to interact with other objects of

the same typethe same type For example, we might add two For example, we might add two RationalRational number objects number objects

together as follows:together as follows:

r3 = r1.add(r2);

One object (One object (r1r1) is executing the method and another () is executing the method and another (r2r2) ) is passed as a parameteris passed as a parameter

See RationalNumbers.java (page 196)See RationalNumbers.java (page 196) See Rational.java (page 197)See Rational.java (page 197)

32

Overloading MethodsOverloading Methods Method overloadingMethod overloading is the process of using the same method is the process of using the same method

name for multiple methodsname for multiple methods

The The signaturesignature of each overloaded method must be unique of each overloaded method must be unique

The signature includes the number, type, and order of the The signature includes the number, type, and order of the parametersparameters

The compiler must be able to determine which version of The compiler must be able to determine which version of the method is being invoked by analyzing the parametersthe method is being invoked by analyzing the parameters

The return type of the method is The return type of the method is notnot part of the signature part of the signature

Overloading MethodsOverloading Methods

float tryMe (int x){ return x + .375;}

Version 1Version 1

float tryMe (int x, float y){ return x*y;}

Version 2Version 2

result = tryMe (25, 4.32)

InvocationInvocation

34

Overloaded MethodsOverloaded Methods TheThe println println method is overloaded:method is overloaded:

println (String s)println (String s) println (int i)println (int i) println (double d)println (double d)

etc.etc.

The following lines invoke different versions of theThe following lines invoke different versions of the println println method:method:

System.out.println ("The total is:");System.out.println ("The total is:"); System.out.println (total);System.out.println (total);

35

Overloading MethodsOverloading Methods Constructors can be overloadedConstructors can be overloaded An overloaded constructor provides multiple ways to set up An overloaded constructor provides multiple ways to set up

a new objecta new object

See SnakeEyes.java (page 203)See SnakeEyes.java (page 203) See Die.java (page 204)See Die.java (page 204)

The StringTokenizer ClassThe StringTokenizer Class The next example makes use of the The next example makes use of the StringTokenizerStringTokenizer

class, which is defined in the class, which is defined in the java.utiljava.util package package

A A StringTokenizerStringTokenizer object separates a string into smaller object separates a string into smaller substrings (tokens)substrings (tokens)

By default, the tokenizer separates the string at white spaceBy default, the tokenizer separates the string at white space

The The StringTokenizerStringTokenizer constructor takes the original constructor takes the original string to be separated as a parameterstring to be separated as a parameter

Each call to the Each call to the nextTokennextToken method returns the next token method returns the next token in the string in the string

Method DecompositionMethod Decomposition A method should be relatively small, so that it can be A method should be relatively small, so that it can be

readily understood as a single entityreadily understood as a single entity

A potentially large method should be decomposed into A potentially large method should be decomposed into several smaller methods as needed for clarityseveral smaller methods as needed for clarity

Therefore, a service method of an object may call one or Therefore, a service method of an object may call one or more support methods to accomplish its goalmore support methods to accomplish its goal

See PigLatin.java (page 207)See PigLatin.java (page 207) See PigLatinTranslator.java (page 208)See PigLatinTranslator.java (page 208)

Applet MethodsApplet Methods In previous examples we've used the In previous examples we've used the paintpaint method of the method of the AppletApplet class to draw on an applet class to draw on an applet

The The AppletApplet class has several methods that are invoked class has several methods that are invoked automatically at certain points in an applet's lifeautomatically at certain points in an applet's life

The The initinit method, for instance, is executed only once when method, for instance, is executed only once when the applet is initially loadedthe applet is initially loaded

The The AppletApplet class also contains other methods that class also contains other methods that generally assist in applet processinggenerally assist in applet processing

Graphical ObjectsGraphical Objects Any object we define by writing a class can have graphical Any object we define by writing a class can have graphical

elementselements The object must simply obtain a graphics context (a The object must simply obtain a graphics context (a GraphicsGraphics object) in which to draw object) in which to draw

An applet can pass its graphics context to another object An applet can pass its graphics context to another object just as it can any other parameterjust as it can any other parameter

See LineUp.java (page 212)See LineUp.java (page 212) See StickFigure.java (page 215)See StickFigure.java (page 215)