CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

2EPRESENTING "EHAVIORS VIA -ETHODS

*AVA LETS YOU REPRESENT BEHAVIORS VIA methods WHICH ARE NAMED BLOCKS OF CODE DECLARED WITHIN A CLASSS
BODY %NTITY BEHAVIORS ARE DESCRIBED VIA instance methods "ECAUSE *AVA ALSO SUPPORTS BEHAVIORS THAT ARE
ASSOCIATED WITH A CLASS AND NOT WITH AN OBJECT *AVA PROVIDES class methods TO DESCRIBE THESE CLASS
BEHAVIORS
9OU FIRST LEARN HOW TO DECLARE AND INVOKE INSTANCE METHODS AND THEN LEARN HOW TO CREATE INSTANCE
METHOD CALL CHAINS .EXT YOU DISCOVER HOW TO DECLARE AND INVOKE CLASS METHODS ENCOUNTER ADDITIONAL
DETAILS ABOUT PASSING ARGUMENTS TO METHODS AND EXPLORE *AVAS RETURN STATEMENT !FTER LEARNING HOW TO
INVOKE METHODS RECURSIVELY AS AN ALTERNATIVE TO ITERATION AND HOW TO OVERLOAD METHODS YOU REVIEW THE
RULES FOR INVOKING METHODS FROM DIFFERENT CONTEXTS

Declaring and Invoking Instance Methods

9OU CAN DECLARE AN INSTANCE METHOD BY MINIMALLY SPECIFYING A RETURN TYPE NAME FOLLOWED BY AN
IDENTIFIER THAT NAMES THE METHOD FOLLOWED BY A PARAMETER LIST FOLLOWED BY A BRACE DELIMITED BODY
,ISTING   PRESENTS A Car CLASS WITH A printDetails() INSTANCE METHOD

Listing 2-9. Declaring a printDetails() instance method in the Car class

class Car
{
String make;
String model;
int numDoors;
Car(String make, String model)
{
this(make, model, 4);
}
Car(String make, String model, int numDoors)
{
this.make = make;
this.model = model;
this.numDoors = numDoors;
}
void printDetails()
{
System.out.println("Make = "+make);
System.out.println("Model = "+model);
System.out.println("Number of doors = "+numDoors);
System.out.println();
}
public static void main(String[] args)
{
Car myCar = new Car("Toyota", "Camry");
myCar.printDetails();
Car yourCar = new Car("Mazda", "RX-8", 2);
yourCar.printDetails();
}
}


CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

,ISTING   DECLARES AN INSTANCE METHOD NAMED printDetails() "Y CONVENTION A METHODS NAME
BEGINS WITH A LOWERCASE LETTER AND THE FIRST LETTER OF EACH SUBSEQUENT WORD IN A MULTIWORD METHOD NAME
IS CAPITALIZED
-ETHODS ARE LIKE CONSTRUCTORS IN THAT THEY HAVE PARAMETER LISTS 9OU PASS ARGUMENTS TO THESE
PARAMETERS WHEN YOU CALL THE METHOD "ECAUSE printDetails() DOES NOT TAKE ARGUMENTS ITS PARAMETER
LIST IS EMPTY

■ Note A method’s name and the number, types, and order of its parameters are known as its signature.

7HEN A METHOD IS INVOKED THE CODE WITHIN ITS BODY IS EXECUTED )N THE CASE OF printDetails() THIS
METHODS BODY EXECUTES A SEQUENCE OF System.out.println() METHOD CALLS TO OUTPUT THE VALUES OF ITS
make model AND numDoors INSTANCE FIELDS
5NLIKE CONSTRUCTORS METHODS ARE DECLARED TO HAVE RETURN TYPES ! RETURN TYPE IDENTIFIES THE KIND OF
VALUES RETURNED BY THE METHOD EG int count() RETURNS  BIT INTEGERS  )F A METHOD DOES NOT RETURN A
VALUE AND printDetails() DOES NOT ITS RETURN TYPE IS REPLACED WITH KEYWORD void AS IN void
printDetails()

■ Note Constructors don’t have return types because they cannot return values. If a constructor could return an
arbitrary value, how would that value be returned? After all, the new operator returns a reference to an object, and
how could new also return a constructor value?

! METHOD IS INVOKED BY USING THE MEMBER ACCESS OPERATOR THE LEFT OPERAND SPECIFIES THE OBJECTS
REFERENCE AND THE RIGHT OPERAND SPECIFIES THE METHOD TO BE CALLED &OR EXAMPLE THE
myCar.printDetails() AND yourCar.printDetails() EXPRESSIONS INVOKE THE printDetails() INSTANCE
METHOD ON THE myCar AND yourCar OBJECTS
#OMPILE ,ISTING   javac Car.java AND RUN THIS APPLICATION java Car  9OU SHOULD OBSERVE THE
FOLLOWING OUTPUT WHOSE DIFFERENT INSTANCE FIELD VALUES PROVE THAT printDetails() ASSOCIATES WITH AN
OBJECT
Make = Toyota
Model = Camry
Number of doors = 4

Make = Mazda
Model = RX-8
Number of doors = 2
7HEN AN INSTANCE METHOD IS INVOKED *AVA PASSES A HIDDEN ARGUMENT TO THE METHOD AS THE LEFTMOST
ARGUMENT IN A LIST OF ARGUMENTS  4HIS ARGUMENT IS THE REFERENCE TO THE OBJECT ON WHICH THE METHOD IS
INVOKED AND IS REPRESENTED AT THE SOURCE CODE LEVEL VIA RESERVED WORD this 9OU DONT NEED TO PREFIX AN
INSTANCE FIELD NAME WITH hthis.v FROM WITHIN THE METHOD WHENEVER YOU ATTEMPT TO ACCESS AN INSTANCE
FIELD NAME THAT ISNT ALSO THE NAME OF A PARAMETER BECAUSE hthis.v IS ASSUMED IN THIS SITUATION


 CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

METHOD-CALL STACK

Method invocations require a method-call stack (also known as a method-invocation stack) to keep track
of the statements to which execution must return. Think of the method-call stack as a simulation of a pile
of clean trays in a cafeteria—you pop (remove) the clean tray from the top of the pile and the dishwasher
will push (insert) the next clean tray onto the top of the pile.
When a method is invoked, the JVM pushes its arguments and the address of the first statement to
execute following the invoked method onto the method-call stack. The JVM also allocates stack space for
the method’s local variables. When the method returns, the JVM removes local variable space, pops the
address and arguments off the stack, and transfers execution to the statement at this address.

Chaining Together Instance Method Calls

4WO OR MORE INSTANCE METHOD CALLS CAN BE CHAINED TOGETHER VIA THE MEMBER ACCESS OPERATOR WHICH
RESULTS IN MORE COMPACT CODE 4O ACCOMPLISH INSTANCE METHOD CALL CHAINING YOU NEED TO RE ARCHITECT
YOUR INSTANCE METHODS SOMEWHAT DIFFERENTLY AS ,ISTING   REVEALS

Listing 2-10. Implementing instance methods so that calls to these methods can be chained together

class SavingsAccount
{
int balance;
SavingsAccount deposit(int amount)
{
balance += amount;
return this;
}
SavingsAccount printBalance()
{
System.out.println(balance);
return this;
}
public static void main(String[] args)
{
new SavingsAccount().deposit(1000).printBalance();
}
}
,ISTING   SHOWS THAT YOU MUST SPECIFY THE CLASSS NAME AS THE INSTANCE METHODS RETURN TYPE
%ACH OF deposit() AND printBalance() MUST SPECIFY SavingsAccount AS THE RETURN TYPE !LSO YOU MUST
SPECIFY return this; RETURN CURRENT OBJECTS REFERENCE AS THE LAST STATEMENTˆ) DISCUSS THE RETURN
STATEMENT LATER
&OR EXAMPLE new SavingsAccount().deposit(1000).printBalance(); CREATES A SavingsAccount
OBJECT USES THE RETURNED SavingsAccount REFERENCE TO INVOKE SavingsAccountS deposit() INSTANCE
METHOD TO ADD ONE THOUSAND DOLLARS TO THE SAVINGS ACCOUNT )M IGNORING CENTS FOR CONVENIENCE AND
FINALLY USES deposit()S RETURNED SavingsAccount REFERENCE WHICH IS THE SAME SavingsAccount INSTANCE
TO INVOKE SavingsAccountS printBalance() INSTANCE METHOD TO OUTPUT THE ACCOUNT BALANCE


CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

Declaring and Invoking Class Methods

)N MANY SITUATIONS INSTANCE METHODS ARE ALL THAT YOU NEED (OWEVER YOU MIGHT ENCOUNTER A SITUATION
WHERE YOU NEED TO DESCRIBE A BEHAVIOR THAT IS INDEPENDENT OF ANY OBJECT
&OR EXAMPLE SUPPOSE YOU WOULD LIKE TO INTRODUCE A utility class A CLASS CONSISTING OF static ;CLASS=
METHODS WHOSE METHODS PERFORM VARIOUS KINDS OF CONVERSIONS SUCH AS CONVERTING FROM DEGREES
#ELSIUS TO DEGREES &AHRENHEIT  9OU DONT WANT TO CREATE AN OBJECT FROM THIS CLASS IN ORDER TO PERFORM A
CONVERSION )NSTEAD YOU SIMPLY WANT TO CALL A METHOD AND OBTAIN ITS RESULT ,ISTING   ADDRESSES THIS
REQUIREMENT BY PRESENTING A Conversions CLASS WITH A PAIR OF CLASS METHODS 4HESE METHODS CAN BE
CALLED WITHOUT HAVING TO CREATE A Conversions OBJECT

Listing 2-11. A Conversions utility class with a pair of class methods

class Conversions
{
static double c2f(double degrees)
{
return degrees*9.0/5.0+32;
}
static double f2c(double degrees)
{
return (degrees-32)*5.0/9.0;
}
}
,ISTING  S Conversions CLASS DECLARES c2f() AND f2c() METHODS FOR CONVERTING FROM DEGREES
#ELSIUS TO DEGREES &AHRENHEIT AND VICE VERSA AND RETURNING THE RESULTS OF THESE CONVERSIONS %ACH
method header METHOD SIGNATURE AND OTHER INFORMATION IS PREFIXED WITH KEYWORD static TO TURN THE
METHOD INTO A CLASS METHOD
4O EXECUTE A CLASS METHOD YOU TYPICALLY PREFIX ITS NAME WITH THE CLASS NAME &OR EXAMPLE YOU CAN
EXECUTE Conversions.c2f(100.0); TO FIND OUT THE &AHRENHEIT EQUIVALENT OF  DEGREES #ELSIUS AND
Conversions.f2c(98.6); TO DISCOVER THE #ELSIUS EQUIVALENT OF THE NORMAL BODY TEMPERATURE 9OU DONT
NEED TO INSTANTIATE Conversions AND THEN CALL THESE METHODS VIA THAT INSTANCE ALTHOUGH YOU COULD DO SO
BUT THAT ISNT GOOD FORM 

■ Note Every application has at least one class method. Specifically, an application must specify public static
void main(String[] args) to serve as the application’s entry point. The static reserved word makes this
method a class method. (I will explain reserved word public later in this chapter.)

"ECAUSE CLASS METHODS ARE NOT CALLED WITH A HIDDEN ARGUMENT THAT REFERS TO THE CURRENT OBJECT
c2f() f2c() AND main() CANNOT ACCESS AN OBJECTS INSTANCE FIELDS OR CALL ITS INSTANCE METHODS 4HESE
CLASS METHODS CAN ONLY ACCESS CLASS FIELDS AND CALL CLASS METHODS


 CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

Passing Arguments to Methods

! METHOD CALL INCLUDES A LIST OF ZERO OR MORE ARGUMENTS BEING PASSED TO THE METHOD *AVA PASSES
ARGUMENTS TO METHODS VIA A STYLE OF ARGUMENT PASSING CALLED pass-by-value WHICH THE FOLLOWING EXAMPLE
DEMONSTRATES
Employee emp = new Employee("John ");
int recommendedAnnualSalaryIncrease = 1000;
printReport(emp, recommendAnnualSalaryIncrease);
printReport(new Employee("Cuifen"), 1500);
0ASS BY VALUE PASSES THE VALUE OF A VARIABLE THE REFERENCE VALUE STORED IN emp OR THE  VALUE
STORED IN recommendedAnnualSalaryIncrease FOR EXAMPLE OR THE VALUE OF SOME OTHER EXPRESSION SUCH AS
new Employee("Cuifen") OR 1500 TO THE METHOD
"ECAUSE OF PASS BY VALUE YOU CANNOT ASSIGN A DIFFERENT Employee OBJECTS REFERENCE TO emp FROM
INSIDE printReport() VIA THE printReport() PARAMETER FOR THIS ARGUMENT !FTER ALL YOU HAVE ONLY PASSED
A COPY OF empS VALUE TO THE METHOD
-ANY METHODS AND CONSTRUCTORS REQUIRE YOU TO PASS A FIXED NUMBER OF ARGUMENTS WHEN THEY ARE
CALLED (OWEVER *AVA ALSO CAN PASS A VARIABLE NUMBER OF ARGUMENTSˆSUCH METHODSCONSTRUCTORS ARE
OFTEN REFERRED TO AS varargs methods/constructors 4O DECLARE A METHOD OR CONSTRUCTOR THAT TAKES A
VARIABLE NUMBER OF ARGUMENTS SPECIFY THREE CONSECUTIVE PERIODS AFTER THE TYPE NAME OF THE
METHODSCONSTRUCTORS RIGHTMOST PARAMETER 4HE FOLLOWING EXAMPLE PRESENTS A sum() METHOD THAT
ACCEPTS A VARIABLE NUMBER OF ARGUMENTS
double sum(double... values)
{
int total = 0;
for (int i = 0; i < values.length; i++)
total += values[i];
return total;
}
sum()S IMPLEMENTATION TOTALS THE NUMBER OF ARGUMENTS PASSED TO THIS METHOD FOR EXAMPLE
sum(10.0, 20.0) OR sum(30.0, 40.0, 50.0) "EHIND THE SCENES THESE ARGUMENTS ARE STORED IN A ONE
DIMENSIONAL ARRAY AS EVIDENCED BY values.length AND values[i] !FTER THESE VALUES HAVE BEEN TOTALED
THIS TOTAL IS RETURNED VIA THE RETURN STATEMENT

Returning from a Method via the Return Statement

4HE EXECUTION OF STATEMENTS WITHIN A METHOD THAT DOES NOT RETURN A VALUE ITS RETURN TYPE IS SET TO void
FLOWS FROM THE FIRST STATEMENT TO THE LAST STATEMENT (OWEVER *AVAS RETURN STATEMENT LETS A METHOD OR A
CONSTRUCTOR EXIT BEFORE REACHING THE LAST STATEMENT !S ,ISTING   SHOWS THIS FORM OF THE RETURN
STATEMENT CONSISTS OF RESERVED WORD return FOLLOWED BY A SEMICOLON


CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

Listing 2-12. Using the return statement to return prematurely from a method

class Employee
{
String name;
Employee(String name)
{
setName(name);
}
void setName(String name)
{
if (name == null)
{
System.out.println("name cannot be null");
return;
}
else
this.name = name;
}
public static void main(String[] args)
{
Employee john = new Employee(null);
}
}
,ISTING  S Employee(String name) CONSTRUCTOR INVOKES THE setName() INSTANCE METHOD TO
INITIALIZE THE name INSTANCE FIELD 0ROVIDING A SEPARATE METHOD FOR THIS PURPOSE IS A GOOD IDEA BECAUSE IT
LETS YOU INITIALIZE THE INSTANCE FIELD AT CONSTRUCTION TIME AND ALSO AT A LATER TIME 0ERHAPS THE EMPLOYEE
CHANGES HIS OR HER NAME

■ Note When you invoke a class’s instance or class method from a constructor or method within the same class,
you specify only the method’s name. You don’t prefix the method invocation with the member access operator and
an object reference or class name.

setName() USES AN IF STATEMENT TO DETECT AN ATTEMPT TO ASSIGN A NULL REFERENCE TO THE name FIELD 7HEN
SUCH AN ATTEMPT IS DETECTED IT OUTPUTS THE hname cannot be nullv ERROR MESSAGE AND RETURNS
PREMATURELY FROM THE METHOD SO THAT THE NULL VALUE CANNOT BE ASSIGNED AND REPLACE A PREVIOUSLY
ASSIGNED NAME 

■ Caution When using the return statement, you might run into a situation where the compiler reports an
“unreachable code” error message. It does so when it detects code that will never be executed and occupies
memory unnecessarily. One area where you might encounter this problem is the switch statement. For example,


 CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

suppose you specify case "-v": printUsageInstructions(); return; break; as part of this statement. The
compiler reports an error when it detects the break statement following the return statement because the break
statement is unreachable; it never can be executed.

4HE PREVIOUS FORM OF THE RETURN STATEMENT IS NOT LEGAL IN A METHOD THAT RETURNS A VALUE &OR SUCH
METHODS *AVA PROVIDES AN ALTERNATE VERSION OF RETURN THAT LETS THE METHOD RETURN A VALUE WHOSE TYPE
MUST MATCH THE METHODS RETURN TYPE  4HE FOLLOWING EXAMPLE DEMONSTRATES THIS VERSION
double divide(double dividend, double divisor)
{
if (divisor == 0.0)
{
System.out.println("cannot divide by zero");
return 0.0;
}
return dividend/divisor;
}
divide() USES AN IF STATEMENT TO DETECT AN ATTEMPT TO DIVIDE ITS FIRST ARGUMENT BY  AND OUTPUTS AN
ERROR MESSAGE WHEN THIS ATTEMPT IS DETECTED &URTHERMORE IT RETURNS 0.0 TO SIGNIFY THIS ATTEMPT )F THERE
IS NO PROBLEM THE DIVISION IS PERFORMED AND THE RESULT IS RETURNED

■ Caution You cannot use this form of the return statement in a constructor because constructors do not have
return types.

Invoking Methods Recursively

! METHOD NORMALLY EXECUTES STATEMENTS THAT MAY INCLUDE CALLS TO OTHER METHODS SUCH AS
printDetails() INVOKING System.out.println() (OWEVER IT IS OCCASIONALLY CONVENIENT TO HAVE A
METHOD CALL ITSELF 4HIS SCENARIO IS KNOWN AS recursion
&OR EXAMPLE SUPPOSE YOU NEED TO WRITE A METHOD THAT RETURNS A factorial THE PRODUCT OF ALL THE
POSITIVE INTEGERS UP TO AND INCLUDING A SPECIFIC INTEGER  &OR EXAMPLE 
THE
IS THE MATHEMATICAL
SYMBOL FOR FACTORIAL EQUALS ×× OR 
9OUR FIRST APPROACH TO WRITING THIS METHOD MIGHT CONSIST OF THE CODE PRESENTED IN THE FOLLOWING
EXAMPLE
int factorial(int n)
{
int product = 1;
for (int i = 2; i <= n; i++)
product *= i;
return product;
}


CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

!LTHOUGH THIS CODE ACCOMPLISHES ITS TASK VIA ITERATION factorial() COULD ALSO BE WRITTEN ACCORDING
TO THE FOLLOWING EXAMPLES RECURSIVE STYLE
int factorial(int n)
{
if (n == 1)
return 1; // base problem
else
return n*factorial(n-1);
}
4HE RECURSIVE APPROACH TAKES ADVANTAGE OF BEING ABLE TO EXPRESS A PROBLEM IN SIMPLER TERMS OF ITSELF
!CCORDING TO THIS EXAMPLE THE SIMPLEST PROBLEM WHICH IS ALSO KNOWN AS THE base problem IS 
 
7HEN AN ARGUMENT GREATER THAN  IS PASSED TO factorial() THIS METHOD BREAKS THE PROBLEM INTO A
SIMPLER PROBLEM BY CALLING ITSELF WITH THE NEXT SMALLER ARGUMENT VALUE %VENTUALLY THE BASE PROBLEM WILL
BE REACHED
&OR EXAMPLE CALLING factorial(4) RESULTS IN THE FOLLOWING STACK OF EXPRESSIONS
4*factorial(3)
3*factorial(2)
2*factorial(1)
4HIS LAST EXPRESSION IS AT THE TOP OF THE STACK 7HEN factorial(1) RETURNS  THESE EXPRESSIONS ARE
EVALUATED AS THE STACK BEGINS TO UNWIND
• 2*factorial(1) NOW BECOMES   
• 3*factorial(2) NOW BECOMES   
• 4*factorial(3) NOW BECOMES   
2ECURSION PROVIDES AN ELEGANT WAY TO EXPRESS MANY PROBLEMS !DDITIONAL EXAMPLES INCLUDE
SEARCHING TREE BASED DATA STRUCTURES FOR SPECIFIC VALUES AND IN A HIERARCHICAL FILE SYSTEM FINDING AND
OUTPUTTING THE NAMES OF ALL FILES THAT CONTAIN SPECIFIC TEXT

■ Caution Recursion consumes stack space, so make sure that your recursion eventually ends in a base problem;
otherwise, you will run out of stack space and your application will be forced to terminate.

Overloading Methods
*AVA LETS YOU INTRODUCE METHODS WITH THE SAME NAME BUT DIFFERENT PARAMETER LISTS INTO THE SAME CLASS
4HIS FEATURE IS KNOWN AS method overloading 7HEN THE COMPILER ENCOUNTERS A METHOD INVOCATION
EXPRESSION IT COMPARES THE CALLED METHODS ARGUMENTS LIST WITH EACH OVERLOADED METHODS PARAMETER
LIST AS IT LOOKS FOR THE CORRECT METHOD TO INVOKE
4WO SAME NAMED METHODS ARE OVERLOADED WHEN THEIR PARAMETER LISTS DIFFER IN NUMBER OR ORDER OF
PARAMETERS &OR EXAMPLE *AVAS String CLASS PROVIDES OVERLOADED public int indexOf(int ch) AND
public int indexOf(int ch, int fromIndex) METHODS 4HESE METHODS DIFFER IN PARAMETER COUNTS )
EXPLORE String IN #HAPTER 


 CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

4WO SAME NAMED METHODS ARE OVERLOADED WHEN AT LEAST ONE PARAMETER DIFFERS IN TYPE &OR EXAMPLE
*AVAS java.lang.Math CLASS PROVIDES OVERLOADED public static double abs(double a) AND public
static int abs(int a) METHODS /NE METHODS PARAMETER IS A double THE OTHER METHODS PARAMETER IS
AN int ) EXPLORE Math IN #HAPTER 
9OU CANNOT OVERLOAD A METHOD BY CHANGING ONLY THE RETURN TYPE &OR EXAMPLE double
sum(double... values) AND int sum(double... values) ARE NOT OVERLOADED 4HESE METHODS ARE NOT
OVERLOADED BECAUSE THE COMPILER DOES NOT HAVE ENOUGH INFORMATION TO CHOOSE WHICH METHOD TO CALL
WHEN IT ENCOUNTERS sum(1.0, 2.0) IN SOURCE CODE

Reviewing Method-Invocation Rules

4HE PREVIOUS EXAMPLES OF METHOD INVOCATION MAY SEEM CONFUSING BECAUSE YOU CAN SOMETIMES SPECIFY
THE METHODS NAME DIRECTLY WHEREAS YOU NEED TO PREFIX A METHOD NAME WITH AN OBJECT REFERENCE OR A
CLASS NAME AND THE MEMBER ACCESS OPERATOR AT OTHER TIMES 4HE FOLLOWING RULES DISPEL THIS CONFUSION BY
GIVING YOU GUIDANCE ON HOW TO INVOKE METHODS FROM THE VARIOUS CONTEXTS
• 3PECIFY THE NAME OF A CLASS METHOD AS IS FROM ANYWHERE WITHIN THE SAME CLASS AS
THE CLASS METHOD %XAMPLE c2f(37.0);
• 3PECIFY THE NAME OF THE CLASS METHODS CLASS FOLLOWED BY THE MEMBER ACCESS
OPERATOR FOLLOWED BY THE NAME OF THE CLASS METHOD FROM OUTSIDE THE CLASS
%XAMPLE Conversions.c2f(37.0); 9OU CAN ALSO INVOKE A CLASS METHOD VIA AN
OBJECT INSTANCE BUT THAT IS CONSIDERED BAD FORM BECAUSE IT HIDES FROM CASUAL
OBSERVATION THE FACT THAT A CLASS METHOD IS BEING INVOKED
• 3PECIFY THE NAME OF AN INSTANCE METHOD AS IS FROM ANY INSTANCE METHOD
CONSTRUCTOR OR INSTANCE INITIALIZER IN THE SAME CLASS AS THE INSTANCE METHOD
%XAMPLE setName(name);
• 3PECIFY AN OBJECT REFERENCE FOLLOWED BY THE MEMBER ACCESS OPERATOR FOLLOWED BY
THE NAME OF THE INSTANCE METHOD FROM ANY CLASS METHOD OR CLASS INITIALIZER WITHIN
THE SAME CLASS AS THE INSTANCE METHOD OR FROM OUTSIDE THE CLASS %XAMPLE Car car
= new Car("Toyota", "Camry"); car.printDetails();
!LTHOUGH THE LATTER RULE MIGHT SEEM TO IMPLY THAT YOU CAN CALL AN INSTANCE METHOD FROM A CLASS
CONTEXT THIS IS NOT THE CASE )NSTEAD YOU CALL THE METHOD FROM AN OBJECT CONTEXT
!LSO DONT FORGET TO MAKE SURE THAT THE NUMBER OF ARGUMENTS PASSED TO A METHOD ALONG WITH THE
ORDER IN WHICH THESE ARGUMENTS ARE PASSED AND THE TYPES OF THESE ARGUMENTS AGREE WITH THEIR PARAMETER
COUNTERPARTS IN THE METHOD BEING INVOKED

■ Note Field access and method call rules are combined in expression System.out.println();, where the
leftmost member access operator accesses the out class field (of type java.io.PrintStream) in the
java.lang.System class, and where the rightmost member access operator calls this field’s println() method.
You’ll learn about PrintStream in Chapter 8 and System in Chapter 4.


CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

(IDING )NFORMATION
%VERY CLASS X EXPOSES AN interface A PROTOCOL CONSISTING OF CONSTRUCTORS METHODS AND ;POSSIBLY= FIELDS
THAT ARE MADE AVAILABLE TO OBJECTS CREATED FROM OTHER CLASSES FOR USE IN CREATING AND COMMUNICATING WITH
XS OBJECTS 
!N INTERFACE SERVES AS A ONE WAY CONTRACT BETWEEN A CLASS AND ITS clients WHICH ARE THE EXTERNAL
CONSTRUCTORS METHODS AND OTHER INITIALIZATION ORIENTED CLASS ENTITIES DISCUSSED LATER IN THIS CHAPTER
THAT COMMUNICATE WITH THE CLASSS INSTANCES BY CALLING CONSTRUCTORS AND METHODS AND BY ACCESSING
FIELDS TYPICALLY public static final FIELDS OR CONSTANTS  4HE CONTRACT IS SUCH THAT THE CLASS PROMISES TO
NOT CHANGE ITS INTERFACE WHICH WOULD BREAK CLIENTS THAT DEPEND UPON THE INTERFACE
X ALSO PROVIDES AN implementation THE CODE WITHIN EXPOSED METHODS ALONG WITH OPTIONAL HELPER
METHODS AND OPTIONAL SUPPORTING FIELDS THAT SHOULD NOT BE EXPOSED THAT CODIFIES THE INTERFACE Helper
methods ARE METHODS THAT ASSIST EXPOSED METHODS AND SHOULD NOT BE EXPOSED
7HEN DESIGNING A CLASS YOUR GOAL IS TO EXPOSE A USEFUL INTERFACE WHILE HIDING DETAILS OF THAT
INTERFACES IMPLEMENTATION 9OU HIDE THE IMPLEMENTATION TO PREVENT DEVELOPERS FROM ACCIDENTALLY
ACCESSING PARTS OF YOUR CLASS THAT DO NOT BELONG TO THE CLASSS INTERFACE SO THAT YOU ARE FREE TO CHANGE THE
IMPLEMENTATION WITHOUT BREAKING CLIENT CODE (IDING THE IMPLEMENTATION IS OFTEN REFERRED TO AS
information hiding &URTHERMORE MANY DEVELOPERS CONSIDER IMPLEMENTATION HIDING TO BE PART OF
ENCAPSULATION
*AVA SUPPORTS IMPLEMENTATION HIDING BY PROVIDING FOUR LEVELS OF ACCESS CONTROL WHERE THREE OF THESE
LEVELS ARE INDICATED VIA A RESERVED WORD 9OU CAN USE THE FOLLOWING ACCESS CONTROL LEVELS TO CONTROL ACCESS
TO FIELDS METHODS AND CONSTRUCTORS AND TWO OF THESE LEVELS TO CONTROL ACCESS TO CLASSES
• Public ! FIELD METHOD OR CONSTRUCTOR THAT IS DECLARED public IS ACCESSIBLE FROM
ANYWHERE #LASSES CAN BE DECLARED public AS WELL
• Protected ! FIELD METHOD OR CONSTRUCTOR THAT IS DECLARED protected IS ACCESSIBLE
FROM ALL CLASSES IN THE SAME PACKAGE AS THE MEMBERS CLASS AS WELL AS SUBCLASSES OF
THAT CLASS REGARDLESS OF PACKAGE ) WILL DISCUSS PACKAGES IN #HAPTER 
• Private ! FIELD METHOD OR CONSTRUCTOR THAT IS DECLARED private CANNOT BE
ACCESSED FROM BEYOND THE CLASS IN WHICH IT IS DECLARED
• Package-private )N THE ABSENCE OF AN ACCESS CONTROL RESERVED WORD A FIELD
METHOD OR CONSTRUCTOR IS ONLY ACCESSIBLE TO CLASSES WITHIN THE SAME PACKAGE AS
THE MEMBERS CLASS 4HE SAME IS TRUE FOR NON public CLASSES 4HE ABSENCE OF
public protected OR private IMPLIES PACKAGE PRIVATE

■ Note A class that is declared public must be stored in a file with the same name. For example, a public Image
class must be stored in Image.java. A source file can declare one public class only.

9OU WILL OFTEN DECLARE YOUR CLASSS INSTANCE FIELDS TO BE private AND PROVIDE SPECIAL public INSTANCE
METHODS FOR SETTING AND GETTING THEIR VALUES "Y CONVENTION METHODS THAT SET FIELD VALUES HAVE NAMES
STARTING WITH set AND ARE KNOWN AS setters 3IMILARLY METHODS THAT GET FIELD VALUES HAVE NAMES WITH get
OR is FOR "OOLEAN FIELDS PREFIXES AND ARE KNOWN AS getters ,ISTING   DEMONSTRATES THIS PATTERN IN THE
CONTEXT OF AN Employee CLASS DECLARATION


 CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

Listing 2-13. Separation of interface from implementation

public class Employee

{
private String name;
public Employee(String name)
{
setName(name);
}
public void setName(String empName)
{
name = empName; // Assign the empName argument to the name field.
}
public String getName()
{
return name;
}
}
,ISTING   PRESENTS AN INTERFACE CONSISTING OF THE public Employee CLASS ITS public CONSTRUCTOR AND
ITS public SETTERGETTER METHODS 4HIS CLASS AND THESE MEMBERS CAN BE ACCESSED FROM ANYWHERE 4HE
IMPLEMENTATION CONSISTS OF THE private name FIELD AND CONSTRUCTORMETHOD CODE WHICH IS ONLY
ACCESSIBLE WITHIN THE Employee CLASS
)T MIGHT SEEM POINTLESS TO GO TO ALL THIS BOTHER WHEN YOU COULD SIMPLY OMIT private AND ACCESS THE
name FIELD DIRECTLY (OWEVER SUPPOSE YOU ARE TOLD TO INTRODUCE A NEW CONSTRUCTOR THAT TAKES SEPARATE FIRST
AND LAST NAME ARGUMENTS AND NEW METHODS THAT SETGET THE EMPLOYEES FIRST AND LAST NAMES INTO THIS
CLASS &URTHERMORE SUPPOSE THAT IT HAS BEEN DETERMINED THAT THE FIRST AND LAST NAMES WILL BE ACCESSED
MORE OFTEN THAN THE ENTIRE NAME ,ISTING   REVEALS THESE CHANGES

Listing 2-14. Revising implementation without affecting existing interface

public class Employee

{
private String firstName;
private String lastName;
public Employee(String name)
{
setName(name);
}
public Employee(String firstName, String lastName)
{
setName(firstName+" "+lastName);
}
public void setName(String name)
{
// Assume that the first and last names are separated by a
// single space character. indexOf() locates a character in a
// string; substring() returns a portion of a string.
setFirstName(name.substring(0, name.indexOf(' ')));
setLastName(name.substring(name.indexOf(' ')+1));
}
public String getName()


CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

{
return getFirstName()+" "+getLastName();
}
public void setFirstName(String empFirstName)
{
firstName = empFirstName;
}
public String getFirstName()
{
return firstName;
}
public void setLastName(String empLastName)
{
lastName = empLastName;
}
public String getLastName()
{
return lastName;
}
}
,ISTING   REVEALS THAT THE name FIELD HAS BEEN REMOVED IN FAVOR OF NEW firstName AND lastName
FIELDS WHICH WERE ADDED TO IMPROVE PERFORMANCE "ECAUSE setFirstName() AND setLastName() WILL BE
CALLED MORE FREQUENTLY THAN setName() AND BECAUSE getFirstName() AND getLastName() WILL BE CALLED
MORE FREQUENTLY THAN getName() IT IS MORE PERFORMANT IN EACH CASE TO HAVE THE FIRST TWO METHODS
SETGET firstNameS AND lastNameS VALUES RATHER THAN MERGING EITHER VALUE INTOEXTRACTING THIS VALUE
FROM nameS VALUE
,ISTING   ALSO REVEALS setName() CALLING setFirstName() AND setLastName() AND getName() CALLING
getFirstName() AND getLastName() RATHER THAN DIRECTLY ACCESSING THE firstName AND lastName FIELDS
!LTHOUGH AVOIDING DIRECT ACCESS TO THESE FIELDS IS NOT NECESSARY IN THIS EXAMPLE IMAGINE ANOTHER
IMPLEMENTATION CHANGE THAT ADDS MORE CODE TO setFirstName() setLastName() getFirstName() AND
getLastName() NOT CALLING THESE METHODS WILL RESULT IN THE NEW CODE NOT EXECUTING
Client code CODE THAT INSTANTIATES AND USES A CLASS SUCH AS Employee WILL NOT BREAK WHEN EmployeeS
IMPLEMENTATION CHANGES FROM THAT SHOWN IN ,ISTING   TO THAT SHOWN IN ,ISTING   BECAUSE THE
ORIGINAL INTERFACE REMAINS INTACT ALTHOUGH THE INTERFACE HAS BEEN EXTENDED 4HIS LACK OF BREAKAGE RESULTS
FROM HIDING ,ISTING  S IMPLEMENTATION ESPECIALLY THE name FIELD

■ Note setName() invokes the String class’s indexOf() and substring() methods. You’ll learn about these
and other String methods in Chapter 4.

*AVA PROVIDES A LITTLE KNOWN INFORMATION HIDING RELATED LANGUAGE FEATURE THAT LETS ONE OBJECT OR
CLASS METHODINITIALIZER ACCESS ANOTHER OBJECTS private FIELDS OR INVOKE ITS private METHODS ,ISTING 
 PROVIDES A DEMONSTRATION


 CHAPTER 2 DISCOVERING CLASSES AND OBJECTS

Listing 2-15. One object accessing another object’s private field

class PrivateAccess
{
private int x;
PrivateAccess(int x)
{
this.x = x;
}
boolean equalTo(PrivateAccess pa)
{
return pa.x == x;
}
public static void main(String[] args)
{
PrivateAccess pa1 = new PrivateAccess(10);
PrivateAccess pa2 = new PrivateAccess(20);
PrivateAccess pa3 = new PrivateAccess(10);
System.out.println("pa1 equal to pa2: "+pa1.equalTo(pa2));
System.out.println("pa2 equal to pa3: "+pa2.equalTo(pa3));
System.out.println("pa1 equal to pa3: "+pa1.equalTo(pa3));
System.out.println(pa2.x);
}
}
,ISTING  S PrivateAccess CLASS DECLARES A private int FIELD NAMED x )T ALSO DECLARES AN equalTo()
METHOD THAT TAKES A PrivateAccess ARGUMENT 4HE IDEA IS TO COMPARE THE ARGUMENT OBJECT WITH THE
CURRENT OBJECT TO DETERMINE IF THEY ARE EQUAL
4HE EQUALITY DETERMINATION IS MADE BY USING THE == OPERATOR TO COMPARE THE VALUE OF THE ARGUMENT
OBJECTS x INSTANCE FIELD WITH THE VALUE OF THE CURRENT OBJECTS x INSTANCE FIELD RETURNING "OOLEAN TRUE
WHEN THEY ARE THE SAME 7HAT MAY SEEM BAFFLING IS THAT *AVA LETS YOU SPECIFY pa.x TO ACCESS THE ARGUMENT
OBJECTS private INSTANCE FIELD !LSO main() IS ABLE TO DIRECTLY ACCESS x VIA THE pa2 OBJECT
) PREVIOUSLY PRESENTED *AVAS FOUR ACCESS CONTROL LEVELS AND PRESENTED THE FOLLOWING STATEMENT
REGARDING THE PRIVATE ACCESS CONTROL LEVEL h! FIELD METHOD OR CONSTRUCTOR THAT IS DECLARED private
CANNOT BE ACCESSED FROM BEYOND THE CLASS IN WHICH IT IS DECLAREDv 7HEN YOU CAREFULLY CONSIDER THIS
STATEMENT AND EXAMINE ,ISTING   YOU WILL REALIZE THAT x IS NOT BEING ACCESSED FROM BEYOND THE
PrivateAccess CLASS IN WHICH IT IS DECLARED 4HEREFORE THE PRIVATE ACCESS CONTROL LEVEL IS NOT BEING
VIOLATED
4HE ONLY CODE THAT CAN ACCESS THIS private INSTANCE FIELD IS CODE LOCATED WITHIN THE PrivateAccess
CLASS )F YOU ATTEMPTED TO ACCESS x VIA A PrivateAccess OBJECT THAT WAS CREATED IN THE CONTEXT OF ANOTHER
CLASS THE COMPILER WOULD REPORT AN ERROR
"EING ABLE TO DIRECTLY ACCESS x FROM WITHIN PrivateAccess IS A PERFORMANCE ENHANCEMENT IT IS FASTER
TO DIRECTLY ACCESS THIS IMPLEMENTATION DETAIL THAN TO CALL A METHOD THAT RETURNS ITS VALUE
#OMPILE PrivateAccess.java javac PrivateAccess.java AND RUN THE APPLICATION java
PrivateAccess  9OU SHOULD OBSERVE THE FOLLOWING OUTPUT
pa1 equal to pa2: false
pa2 equal to pa3: false
pa1 equal to pa3: true
20