Foundations of Program Design Writing Classes. 2 Objects b An object has: state - descriptive...

Foundations of Program DesignFoundations of Program Design

Writing ClassesWriting Classes

2

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

3

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

Flipping a coinFlipping a coin

public class Coin {public class Coin {

public final int HEADS = 0;public final int HEADS = 0;

public final int TAILS = 1;public final int TAILS = 1;

private int face;private int face;

public Coin () {public Coin () {

flip();flip();

}}

public void flip () {public void flip () {

face = (int) (Math.random() * 2);face = (int) (Math.random() * 2);

}}

Flipping a coinFlipping a coin

public int getFace () {public int getFace () {

return face;return face;

}}

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;

}}

}}

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

Counting the flipsCounting the flipsimport Coin;import Coin;

public class CountFlips {public class CountFlips {

public static void main (String[] args) {public static void main (String[] args) {

final int NUM_FLIPS = 1000;final int NUM_FLIPS = 1000;

int heads = 0, tails = 0;int heads = 0, tails = 0;

Coin myCoin = new Coin(); // instantiate the Coin objectCoin myCoin = new Coin(); // instantiate the Coin object

for (int count=1; count <= NUM_FLIPS; count++) {for (int count=1; count <= NUM_FLIPS; count++) {

myCoin.flip();myCoin.flip();

if (myCoin.getFace() == myCoin.HEADS) if (myCoin.getFace() == myCoin.HEADS)

heads++;heads++;

elseelse

tails++;tails++;

}}

Counting the flipsCounting the flips

System.out.println ("The number flips: " + NUM_FLIPS);System.out.println ("The number flips: " + NUM_FLIPS);

System.out.println ("The number of heads: " + heads);System.out.println ("The number of heads: " + heads);

System.out.println ("The number of tails: " + tails);System.out.println ("The number of tails: " + tails);

}}

}}

The Coin ClassThe Coin Class

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

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 variable is created as wellis created 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

face 0

coin1

int face;

class Coin

face 1

coin2

The die - more than one The die - more than one constructorconstructor

public class Die {public class Die {

private final int MIN_FACES = 4;private final int MIN_FACES = 4;

private int numFaces; // number of sides on the dieprivate int numFaces; // number of sides on the die

private int faceValue; // current value showing on the dieprivate int faceValue; // current value showing on the die

public Die () {public Die () {

numFaces = 6;numFaces = 6;

faceValue = 1;faceValue = 1;

}}


public Die (int faces) {public Die (int faces) {

if (faces < MIN_FACES)if (faces < MIN_FACES)

numFaces = 6;numFaces = 6;

elseelse

numFaces = faces;numFaces = faces;

faceValue = 1;faceValue = 1;

}}

public int roll () {public int roll () {

faceValue = (int) (Math.random() * numFaces) + 1;faceValue = (int) (Math.random() * numFaces) + 1;

return faceValue;return faceValue;

}}


public int getFaceValue () {public int getFaceValue () {

return faceValue;return faceValue;

}}

}}

21

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 internal - the structure of its data, the algorithms used by its

methodsmethods

• 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 that an object is an Recall that an object is an abstractionabstraction, hiding details from , hiding details from the rest of the systemthe rest of the system

22


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

23


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

24

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

25


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

26


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

The car factoryThe car factory

public class CarFactory {public class CarFactory {

private int numberOfBuiltCars;private int numberOfBuiltCars;

public CarFactory() {public CarFactory() {

numberOfBuiltCars = 100;numberOfBuiltCars = 100;

}}

public void buildCar() {}public void buildCar() {}

private void buildFrame() {}private void buildFrame() {}

private void installEngine() {}private void installEngine() {}

private int getNumberOfBuildCars() {}private int getNumberOfBuildCars() {}

}}

Building a carBuilding a car

public class CarBuilder {public class CarBuilder {

CarFactory factory = new CarFactory();CarFactory factory = new CarFactory();

factory.buildCar();factory.buildCar();

factory.buildFrame();factory.buildFrame();

factory. installEngine();factory. installEngine();

factory. numberOfBuiltCars = 4;factory. numberOfBuiltCars = 4;

int cars = factory. getNumberOfBuildCars();int cars = factory. getNumberOfBuildCars();

}}

ERROR!

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


{ 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

31

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 in the invocation are copied into the formal argumentscopied into the formal arguments


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

return result;}

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

33

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


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

An aggregate object represents a An aggregate object represents a has-a relationshiphas-a relationship


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

36

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


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

38

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);

39


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

SnakeEyesSnakeEyes

public class SnakeEyes {public class SnakeEyes {


final int ROLLS = 500;final int ROLLS = 500;

int snakeEyes = 0, num1, num2;int snakeEyes = 0, num1, num2;

Die die1 = new Die(); // creates a six-sided dieDie die1 = new Die(); // creates a six-sided die

Die die2 = new Die(20); // creates a twenty-sided dieDie die2 = new Die(20); // creates a twenty-sided die

for (int roll = 1; roll <= ROLLS; roll++) {for (int roll = 1; roll <= ROLLS; roll++) {

num1 = die1.roll();num1 = die1.roll();

num2 = die2.roll();num2 = die2.roll();

if (num1 == 1 && num2 == 1) // check for snake eyesif (num1 == 1 && num2 == 1) // check for snake eyes

snakeEyes++;snakeEyes++;

}}

SnakeEyesSnakeEyes

System.out.println ("Number of rolls: " + ROLLS);System.out.println ("Number of rolls: " + ROLLS);

System.out.println ("Number of snake eyes: " + snakeEyes);System.out.println ("Number of snake eyes: " + snakeEyes);

System.out.println ("Ratio: " + (float)snakeEyes/ROLLS);System.out.println ("Ratio: " + (float)snakeEyes/ROLLS);

}}

}}

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 object separates a string into smaller substrings (tokens)smaller 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

Pig Latin TranslatorPig Latin Translatorimport java.util.StringTokenizer;import java.util.StringTokenizer;

public class PigLatinTranslator {public class PigLatinTranslator {

public String translate (String sentence) {public String translate (String sentence) {

String result = "";String result = "";

sentence = sentence.toLowerCase();sentence = sentence.toLowerCase();

StringTokenizer tokenizer = new StringTokenizer (sentence);StringTokenizer tokenizer = new StringTokenizer (sentence);

while (tokenizer.hasMoreTokens()) {while (tokenizer.hasMoreTokens()) {

result += translateWord (tokenizer.nextToken());result += translateWord (tokenizer.nextToken());

result += " ";result += " ";

}}

return result;return result;

}}

Pig Latin TranslatorPig Latin Translator

private String translateWord (String word) {private String translateWord (String word) {

String result = "";String result = "";

if (beginsWithVowel(word))if (beginsWithVowel(word))

result = word + "yay";result = word + "yay";

elseelse

if (beginsWithPrefix(word))if (beginsWithPrefix(word))

result = word.substring(2) + word.substring(0,2) + "ay";result = word.substring(2) + word.substring(0,2) + "ay";

elseelse

result = word.substring(1) + word.charAt(0) + "ay";result = word.substring(1) + word.charAt(0) + "ay";

return result;return result;

}}


private boolean beginsWithVowel (String word) {private boolean beginsWithVowel (String word) {

String vowels = "aeiouAEIOU";String vowels = "aeiouAEIOU";

char letter = word.charAt(0);char letter = word.charAt(0);

return (vowels.indexOf(letter) != -1);return (vowels.indexOf(letter) != -1);

}}


private boolean beginsWithPrefix (String str) {private boolean beginsWithPrefix (String str) {

return ( str.startsWith ("bl") || str.startsWith ("pl") ||return ( str.startsWith ("bl") || str.startsWith ("pl") ||

str.startsWith ("br") || str.startsWith ("pr") ||str.startsWith ("br") || str.startsWith ("pr") ||

str.startsWith ("ch") || str.startsWith ("sh") ||str.startsWith ("ch") || str.startsWith ("sh") ||

str.startsWith ("cl") || str.startsWith ("sl") ||str.startsWith ("cl") || str.startsWith ("sl") ||

str.startsWith ("cr") || str.startsWith ("sp") ||str.startsWith ("cr") || str.startsWith ("sp") ||

str.startsWith ("dr") || str.startsWith ("sr") ||str.startsWith ("dr") || str.startsWith ("sr") ||

str.startsWith ("fl") || str.startsWith ("st") ||str.startsWith ("fl") || str.startsWith ("st") ||

str.startsWith ("fr") || str.startsWith ("th") ||str.startsWith ("fr") || str.startsWith ("th") ||

str.startsWith ("gl") || str.startsWith ("tr") ||str.startsWith ("gl") || str.startsWith ("tr") ||

str.startsWith ("gr") || str.startsWith ("wh") ||str.startsWith ("gr") || str.startsWith ("wh") ||

str.startsWith ("kl") || str.startsWith ("wr") ||str.startsWith ("kl") || str.startsWith ("wr") ||

str.startsWith ("ph") );str.startsWith ("ph") );

}}

}}

Pig LatinPig Latinpublic class PigLatin {public class PigLatin {


String sentence, result, another;String sentence, result, another;

PigLatinTranslator translator = new PigLatinTranslator();PigLatinTranslator translator = new PigLatinTranslator();

do {do {

System.out.println ();System.out.println ();

System.out.println ("Enter a sentence (no punctuation):");System.out.println ("Enter a sentence (no punctuation):");

sentence = Keyboard.readString();sentence = Keyboard.readString();


result = translator.translate (sentence);result = translator.translate (sentence);

System.out.println ("That sentence in Pig Latin is:");System.out.println ("That sentence in Pig Latin is:");

System.out.println (result);System.out.println (result);


System.out.print ("Translate another sentence (y/n)? ");System.out.print ("Translate another sentence (y/n)? ");

another = Keyboard.readString();another = Keyboard.readString();

}}

while (another.equalsIgnoreCase("y"));while (another.equalsIgnoreCase("y"));

}}

}}

Foundations of Program Design Writing Classes. 2 Objects b An object has: state - descriptive...

Documents

Transcript of Foundations of Program Design Writing Classes. 2 Objects b An object has: state - descriptive...