INF 523QINF 523Q

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

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

See See Coin.java Coin.java (page 180) (page 180) See See CountFlipsCountFlips.java .java (page 179)(page 179)

Coin.javaCoin.java //****************************************************************** // Coin.java Author: Lewis and Loftus // Represents a coin with two sides that can be flipped. //****************************************************************** public class Coin { public final int HEADS = 0; public final int TAILS = 1; private int face; // Sets up the coin by flipping it initially. public Coin () { flip(); } // Flips the coin by randomly choosing a face. public void flip () { face = (int) (Math.random() * 2); }

Coin.java (cont.)Coin.java (cont.) // Returns the current face of the coin as an integer. public int getFace () { return face; } // Returns the current face of the coin as a string. public String toString() { String faceName; if (face == HEADS) faceName = "Heads"; else faceName = "Tails"; return faceName; } }

CountFlips.javaCountFlips.java //****************************************************************** // CountFlips.java Author: Lewis and Loftus // Demonstrates the use of a programmer-defined class. //****************************************************************** import Coin; public class CountFlips { // Flips a coin multiple times and counts the number of heads and tails that result. public static void main (String[] args) { final int NUM_FLIPS = 1000; int heads = 0, tails = 0; Coin myCoin = new Coin(); // instantiate the Coin object for (int count=1; count <= NUM_FLIPS; count++)

CountFlips.java (cont.)CountFlips.java (cont.) { myCoin.flip(); if (myCoin.getFace() == myCoin.HEADS) heads++; else tails++; } System.out.println ("The number flips: " + NUM_FLIPS); System.out.println ("The number of heads: " + heads); 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 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 See FlipRaceFlipRace.java .java (page 182)(page 182)

face 0

coin1

int face;

class Coin

face 1

coin2

FlipRace.javaFlipRace.java //******************************************************************** // FlipRace.java Author: Lewis and Loftus // Demonstrates the existence of separate data space in multiple // instantiations of a programmer-defined class. //******************************************************************** import Coin; public class FlipRace { // Flips two coins until one of them comes up heads a set number of times in a

row. public static void main (String[] args) { final int GOAL = 3; int count1 = 0, count2 = 0; // Create two separate coin objects Coin coin1 = new Coin(); Coin coin2 = new Coin(); while (count1 < GOAL && count2 < GOAL) { coin1.flip(); coin2.flip();

FlipRace.java (cont.)FlipRace.java (cont.) // Print the flip results (uses Coin's toString method) System.out.print ("Coin 1: " + coin1); System.out.println (" Coin 2: " + coin2);

// Increment or reset the counters count1 = (coin1.getFace() == coin1.HEADS) ? count1+1 : 0; count2 = (coin2.getFace() == coin2.HEADS) ? count2+1 : 0; }

// Determine the winner if (count1 < GOAL) System.out.println ("Coin 2 Wins!"); else if (count2 < GOAL) System.out.println ("Coin 1 Wins!"); else System.out.println ("It's a TIE!"); } }

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

22

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

23

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

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

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

26

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

29

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

31

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 See Account.java Account.java (page 189)(page 189) See See BankAccountsBankAccounts.java .java (page 188)(page 188)

Account.javaAccount.java //******************************************************************** // Account.java Author: Lewis and Loftus // Represents a bank account with basic services such as deposit and withdraw. //******************************************************************** import java.text.NumberFormat; public class Account { private NumberFormat fmt = NumberFormat.getCurrencyInstance(); private final double RATE = 0.045; // interest rate of 4.5% private long acctNumber; private double balance; private String name; // Sets up the account by defining its owner, account number, // and initial balance. public Account (String owner, long account, double initial) { name = owner; acctNumber = account; balance = initial; }

Account.java (cont.)Account.java (cont.) // Validates the transaction, then deposits the specified amount // into the account. Returns the new balance. public double deposit (double amount) { if (amount < 0) // deposit value is negative { System.out.println (); System.out.println ("Error: Deposit amount is invalid."); System.out.println (acctNumber + " " + fmt.format(amount)); } else balance = balance + amount; return balance; } // Validates the transaction, then withdraws the specified amount // from the account. Returns the new balance. public double withdraw (double amount, double fee) { amount += fee;

Account.java (cont.)Account.java (cont.) if (amount < 0) // withdraw value is negative { System.out.println (); System.out.println ("Error: Withdraw amount is invalid."); System.out.println ("Account: " + acctNumber); System.out.println ("Requested: " + fmt.format(amount)); } else if (amount > balance) // withdraw value exceeds balance { System.out.println (); System.out.println ("Error: Insufficient funds."); System.out.println ("Account: " + acctNumber); System.out.println ("Requested: " + fmt.format(amount)); System.out.println ("Available: " + fmt.format(balance)); } else balance = balance - amount; return balance; }

Account.java (cont.)Account.java (cont.) // Adds interest to the account and returns the new balance. public double addInterest () { balance += (balance * RATE); return balance; } // Returns the current balance of the account. public double getBalance () { return balance; } // Returns the account number. public long getAccountNumber () { return acctNumber; } // Returns a one-line description of the account as a string. public String toString () { return (acctNumber + "\t" + name + "\t" + fmt.format(balance)); } }

BankAccounts.javaBankAccounts.java //******************************************************************** // BankAccounts.java Author: Lewis and Loftus // Driver to exercise the use of multiple Account objects. //******************************************************************** import Account; public class BankAccounts { // Creates some bank accounts and requests various services.

public static void main (String[] args) { Account acct1 = new Account ("Ted Murphy", 72354, 102.56); Account acct2 = new Account ("Jane Smith", 69713, 40.00); Account acct3 = new Account ("Edward Demsey", 93757, 759.32);

acct1.deposit (25.85);

double smithBalance = acct2.deposit (500.00); System.out.println ("Smith balance after deposit: " + smithBalance);

BankAccounts.java (cont.)BankAccounts.java (cont.) System.out.println ("Smith balance after withdrawal: " + acct2.withdraw (430.75, 1.50));

acct3.withdraw (800.00, 0.0); // exceeds balance

acct1.addInterest(); acct2.addInterest(); acct3.addInterest();

System.out.println (); System.out.println (acct1); System.out.println (acct2); System.out.println (acct3); } }

Writing ClassesWriting Classes 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 See Rational.java Rational.java (page 197)(page 197) See See RationalNumbersRationalNumbers.java .java (page 196)(page 196)

Rational.javaRational.java //******************************************************************** // Rational.java Author: Lewis and Loftus // Represents one rational number with a numerator and denominator. //******************************************************************** public class Rational { private int numerator, denominator; // Sets up the rational number by ensuring a nonzero denominator // and making only the numerator signed. public Rational (int numer, int denom) { if (denom == 0) denom = 1; // Make the numerator "store" the sign if (denom < 0) { numer = numer * -1; denom = denom * -1; } numerator = numer; denominator = denom; reduce(); }

Rational.java (cont.)Rational.java (cont.) // Adds this rational number to the one passed as a parameter. // A common denominator is found by multiplying the individual // denominators. public Rational add (Rational op2) { int commonDenominator = denominator * op2.getDenominator(); int numerator1 = numerator * op2.getDenominator(); int numerator2 = op2.getNumerator() * denominator; int sum = numerator1 + numerator2; return new Rational (sum, commonDenominator); } // Subtracts the rational number passed as a parameter from this // rational number. public Rational subtract (Rational op2) { int commonDenominator = denominator * op2.getDenominator(); int numerator1 = numerator * op2.getDenominator(); int numerator2 = op2.getNumerator() * denominator; int difference = numerator1 - numerator2;

return new Rational (difference, commonDenominator); }

Rational.java (cont.)Rational.java (cont.) // Multiplies this rational number by the one passed as a parameter. public Rational multiply (Rational op2) { int numer = numerator * op2.getNumerator(); int denom = denominator * op2.getDenominator();

return new Rational (numer, denom); } // Divides this rational number by the one passed as a parameter // by multiplying by the reciprocal of the second rational. public Rational divide (Rational op2) { return multiply (op2.reciprocal()); } // Returns the reciprocal of this rational number. public Rational reciprocal () { return new Rational (denominator, numerator); } // Returns the numerator of this rational number. public int getNumerator () { return numerator; }

Rational.java (cont.)Rational.java (cont.) // Returns the denominator of this rational number. public int getDenominator () { return denominator; } // Determines if this rational number is equal to the one passed // as a parameter. Assumes they are both reduced. public boolean equals (Rational op2) { return ( numerator == op2.getNumerator() && denominator == op2.getDenominator() ); } // Returns this rational number as a string. public String toString () { String result; if (numerator == 0) result = "0"; else if (denominator == 1) result = numerator + ""; else result = numerator + "/" + denominator; return result; }

Rational.java (cont.)Rational.java (cont.) // Reduces this rational number by dividing both the numerator // and the denominator by their greatest common divisor. private void reduce () { if (numerator != 0) { int common = gcd (Math.abs(numerator), denominator); numerator = numerator / common; denominator = denominator / common; } } // Computes and returns the greatest common divisor of the two // positive parameters. Uses Euclid's algorithm. private int gcd (int num1, int num2) { while (num1 != num2) if (num1 > num2) num1 = num1 - num2; else num2 = num2 - num1; return num1; } }

RationalNumbers.javaRationalNumbers.java //******************************************************************** // RationalNumbers.java Author: Lewis and Loftus // Driver to exercise the use of multiple Rational objects. //******************************************************************** import Rational; public class RationalNumbers { // Creates some rational number objects and performs various // operations on them. public static void main (String[] args) { Rational r1 = new Rational (6, 8); Rational r2 = new Rational (1, 3);

System.out.println ("First rational number: " + r1); System.out.println ("Second rational number: " + r2);

RationalNumbers.java (cont.)RationalNumbers.java (cont.) if (r1.equals(r2)) System.out.println ("r1 and r2 are equal."); else System.out.println ("r1 and r2 are NOT equal.");

Rational r3 = r1.add(r2); Rational r4 = r1.subtract(r2); Rational r5 = r1.multiply(r2); Rational r6 = r1.divide(r2);

System.out.println ("r1 + r2: " + r3); System.out.println ("r1 - r2: " + r4); System.out.println ("r1 * r2: " + r5); System.out.println ("r1 / r2: " + r6); } }

48

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

50

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

51

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 See Die.java Die.java (page 204) (page 204) See See SnakeEyesSnakeEyes.java .java (page 203)(page 203)

Die.javaDie.java //******************************************************************** // Die.java Author: Lewis and Loftus // Represents one die (singular of dice) with faces showing values // between 1 and the number of faces on the die. //******************************************************************** public class Die { private final int MIN_FACES = 4; private int numFaces; // number of sides on the die private int faceValue; // current value showing on the die // Defaults to a six-sided die, initially showing 1. public Die () { numFaces = 6; faceValue = 1; }

Die.java (cont.)Die.java (cont.) // Explicitly sets the size of the die. Defaults to a size of // six if the parameter is invalid. Initial face is 1. public Die (int faces) { if (faces < MIN_FACES) numFaces = 6; else numFaces = faces; faceValue = 1; } // Rolls the die and returns the result. public int roll () { faceValue = (int) (Math.random() * numFaces) + 1; return faceValue; } // Returns the current die value. public int getFaceValue () { return faceValue; } }

SnakeEyes.javaSnakeEyes.java //******************************************************************** // SnakeEyes.java Author: Lewis and Loftus // Demonstrates the use of a class with overloaded constructors. //******************************************************************** import Die; public class SnakeEyes { // Creates two die objects, then rolls both dice a set number of // times, counting the number of snake eyes that occur. public static void main (String[] args) { final int ROLLS = 500; int snakeEyes = 0, num1, num2; Die die1 = new Die(); // creates a six-sided die Die die2 = new Die(20); // creates a twenty-sided die for (int roll = 1; roll <= ROLLS; roll++) { num1 = die1.roll(); num2 = die2.roll(); if (num1 == 1 && num2 == 1) // check for snake eyes snakeEyes++; } System.out.println ("Number of rolls: " + ROLLS); System.out.println ("Number of snake eyes: " + snakeEyes); 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 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 See PigLatinTranslatorPigLatinTranslator.java .java (page 208)(page 208) See See PigLatinPigLatin.java .java (page 207)(page 207)

PigLatinTranslator.javaPigLatinTranslator.java //******************************************************************** // PigLatinTranslator.java Author: Lewis and Loftus // Represents a translation system from English to Pig Latin. // Demonstrates method decomposition and the use of StringTokenizer. //******************************************************************** import java.util.StringTokenizer; public class PigLatinTranslator { // Translates a sentence of words into Pig Latin. public String translate (String sentence) { String result = ""; sentence = sentence.toLowerCase(); StringTokenizer tokenizer = new StringTokenizer (sentence); while (tokenizer.hasMoreTokens()) { result += translateWord (tokenizer.nextToken()); result += " "; } return result; }

PigLatinTranslator.java (cont.)PigLatinTranslator.java (cont.) // Translates one word into Pig Latin. If the word begins with a vowel, the suffix "yay“ // is appended to the word. Otherwise, the first letter or two are moved to the end of // the word, and "ay" is appended. private String translateWord (String word) { String result = ""; if (beginsWithVowel(word)) result = word + "yay"; else if (beginsWithPrefix(word)) result = word.substring(2) + word.substring(0,2) + "ay"; else result = word.substring(1) + word.charAt(0) + "ay"; return result; } // Determines if the specified word begins with a vowel. private boolean beginsWithVowel (String word) { String vowels = "aeiouAEIOU"; char letter = word.charAt(0); return (vowels.indexOf(letter) != -1); }

PigLatinTranslator.java (cont.)PigLatinTranslator.java (cont.) // Determines if the specified word begins with a particular two-character prefix. private boolean beginsWithPrefix (String str) { return ( str.startsWith ("bl") || str.startsWith ("pl") || str.startsWith ("br") || str.startsWith ("pr") || str.startsWith ("ch") || str.startsWith ("sh") || str.startsWith ("cl") || str.startsWith ("sl") || str.startsWith ("cr") || str.startsWith ("sp") || str.startsWith ("dr") || str.startsWith ("sr") || str.startsWith ("fl") || str.startsWith ("st") || str.startsWith ("fr") || str.startsWith ("th") || str.startsWith ("gl") || str.startsWith ("tr") || str.startsWith ("gr") || str.startsWith ("wh") || str.startsWith ("kl") || str.startsWith ("wr") || str.startsWith ("ph") ); } }

PigLatin.javaPigLatin.java //****************************************************************** // PigLatin.java Author: Lewis and Loftus // Driver to exercise the PigLatinTranslator class. //****************************************************************** import PigLatinTranslator; import cs1.Keyboard; public class PigLatin { // Reads sentences and translates them into Pig Latin. public static void main (String[] args) { String sentence, result, another; PigLatinTranslator translator = new PigLatinTranslator();

PigLatin.java (cont.)PigLatin.java (cont.) do { System.out.println (); System.out.println ("Enter a sentence (no punctuation):"); sentence = Keyboard.readString();

System.out.println (); result = translator.translate (sentence); System.out.println ("That sentence in Pig Latin is:"); System.out.println (result);

System.out.println (); System.out.print ("Translate another sentence (y/n)? "); another = Keyboard.readString(); } while (another.equalsIgnoreCase("y")); } }