• A static method cannot refer to an instance variable  of the class, and it cannot invoke a nonstatic method  of the class

24  Download (0)

Full text


Chapter 5

Defining Classes II

Static Methods Static Methods

A i h d i h b d i h lli

A static method is one that can be used without a calling  object

• A static method still belongs to a class and its definition isA static method still belongs to a class, and its definition is  given inside the class definition

• When a static method is defined,  the keyword staticis  placed in the method header

public static returnedType myMethod(parameters) { . . . }

{ . . . }

• Static methods are invoked using the class name in place of a  calling object

returnedValue = MyClass.myMethod(arguments);

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐2

Pitfall:  Invoking a Nonstatic Method Within a  Static Method

• A static method cannot refer to an instance variable  of the class, and it cannot invoke a nonstatic method  of the class

– A static method has no this, so it cannot use an instance  variable or method that has an implicit or explicit thisfor  a calling object

A t ti th d i k th t ti th d

– A static method can invoke another static method,  however

Tip: You Can Put a main in any Class Tip:  You Can Put a main in any Class

Al h h h i h d i f b i lf i l

• Although the main method is often by itself in a class  separate from the other classes of a program, it can  also be contained within a regular class definition also be contained within a regular class definition

– In this way the class in which it is contained can be used to  create objects in other classes, or it can be run as a

create objects in other classes, or it can be run as a  program

– A main method so included in a regular class definition is  especially useful when it contains diagnostic code for the  class


Another Class with a main Added  (Part 1 of 4)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐5

Another Class with a main Added  (Part 2 of 4)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐6

Another Class with a main Added  (Part 3 of 4)

Another Class with a main Added 

(Part 4 of 4)


Static Variables Static Variables

A t ti i bl i i bl th t b l t th l

A static variable is a variable that belongs to the class as a  whole, and not just to one object

There is only one copy of a static variable per class, unlike instance 

i bl h h bj t h it

variables where each object has its own copy

• All objects of the class can read and change a static variable

• Although a static method cannot access an instance variable,Although a static method cannot access an instance variable,  a static method can access a static variable

• A static variable is declared like an instance variable, with the  addition of the modifierstatic

addition of the modifier static

private static int myStaticVariable;

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐9

Static Variables Static Variables

S i i bl b d l d d i i i li d h

• Static variables can be declared and initialized at the same  time

private static int myStaticVariable = 0;

p y ;

• If not explicitly initialized, a static variable will be  automatically initialized to a default value

– booleanstatic variables are initialized to false

Other primitive types static variables are initialized to the zero of their  typeyp

Class type static variables are initialized to null

• It is always preferable to explicitly initialize static variables  th th l th d f lt i iti li ti

rather than rely on the default initialization

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐10

Static Variables Static Variables

• A static variable should always be defined private, unless  it is also a defined constant

The value of a static defined constant cannot be altered The value of a static defined constant cannot be altered, 

therefore it is safe to make it public

In addition to static, the declaration for a static defined  constant must include the modifierfinal which indicates constant must include the modifier final, which indicates  that its value cannot be changed

public static final int BIRTH_YEAR = 1954;

• When referring to such a defined constant outside its  class, use the name of its class in place of a calling object

int year = MyClass BIRTH YEAR;

int year = MyClass.BIRTH_YEAR;

The Math Class The Math Class

Th M th l id b f t d d

• The  Math class provides a number of standard  mathematical methods

– It is found in theIt is found in the java.langjava langpackage so it does notpackage, so it does not  require an importstatement

– All of its methods and data are static, therefore they are  invoked with the class nameM thinstead of a calling invoked with the class name Mathinstead of a calling  object

– The Mathclass has two predefined constants, E(e, the  base of the natural logarithm system) and PI(, 3.1415 . .  .)

area = Math.PI * radius * radius;;


Some Methods in the Class Math (Part 1 of 5)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐13

Some Methods in the Class Math (Part 2 of 5)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐14

Some Methods in the Class Math (Part 3 of 5)

Some Methods in the Class Math

(Part 4 of 5)


Some Methods in the Class Math (Part 5 of 5)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐17

Random Numbers Random Numbers

The Math class also provides a facility to  p y generate pseudo‐random numbers

public static double random()

– A pseudo‐random number appears random but is  reall enerated b a deterministi f n tion

public static double random()

really generated by a deterministic function

There is also a more flexible class named Random

• Sample use:

• Returns a pseudo‐random number greater

double num = Math.random();

Returns a pseudo random number greater  than or equal to 0.0 and less than 1.0

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐18

Wrapper Classes Wrapper Classes

W l id l t di

Wrapper classes provide a class type corresponding  to each of the primitive types

– This makes it possible to have class types that behaveThis  makes it possible to have class types that behave  somewhat like primitive types

– The wrapper classes for the primitive types byte, short,  l fl t d bl and h are (in order)B t long,float,double, and charare (in order) Byte, Short,Long,Float,Double, and Character

• Wrapper classes also contain a number of useful  pp predefined constants and static methods

Wrapper Classes Wrapper Classes

B i th f i f l f

Boxing:  the process of going from a value of a  primitive type to an object of its wrapper class

– To convert a primitive value to an "equivalent" class typeTo convert a primitive value to an  equivalent  class type  value, create an object of the corresponding wrapper class  using the primitive value as an argument

The ne object ill contain an instance ariable that – The new object will contain an instance variable that 

stores a copy of the primitive value

– Unlike most other classes, a wrapper class does not have a  no‐argument constructor

Integer integerObject = new Integer(42);


Wrapper Classes Wrapper Classes

Unboxing:  the process of going from an object  of a wrapper class to the corresponding value of  a primitive type

a primitive type

– The methods for converting an object from the  wrapper classes Byte,Short, Integer,Long, 

d h i

Float,Double, and Characterto their  corresponding primitive type are (in order)  byteValue,shortValue,intValue,

longValue,floatValue,doubleValue, and  charValue

– None of these methods take an argumentNone of these methods take an argument

int i = integerObject.intValue();

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐21

Automatic Boxing and Unboxing Automatic Boxing and Unboxing

St ti ith i 5 0 J t ti ll d b i

• Starting with version 5.0, Java can automatically do boxing  and unboxing

• Instead of creating a wrapper class object using the newg pp j g operation (as shown before), it can be done as an automatic  type cast:

Integer integerObject = 42;g g j ;

• Instead of having to invoke the appropriate method (such as  intValue, doubleValue, charValue, etc.) in order to  convert from an object of a wrapper class to a value of its convert from an object of a wrapper class to a value of its  associated primitive type, the primitive value can be  recovered automatically

i t i i t Obj t int i = integerObject;

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐22

Constants and Static Methods in Wrapper  Classes

W l i l d f l t t th t

• Wrapper classes include useful constants that 

provide the largest and smallest values for any of the  primitive number types

primitive number types

– For example, Integer.MAX_VALUE,

Integer.MIN_VALUE,Double.MAX_VALUE,  Double MIN VALUE etc

Double.MIN_VALUE, etc.

• The Boolean class has names for two constants of  type Boolean

type  Boolean

– Boolean.TRUEand Boolean.FALSEare the Boolean  objects that correspond to the values trueand falseof  the primitive typeboolean

the primitive type boolean

Constants and Static Methods in Wrapper  Classes

• Wrapper classes have static methods that convert a  correctly formed string representation of a number to  the number of a given typeg yp

The methods Integer.parseInt,Long.parseLong,  Float.parseFloat, and Double.parseDoubledo this  for the primitive types (in order) int,long,float, and  d bl


• Wrapper classes also have static methods that convert  from a numeric value to a string representation of the  value

For example, the expression

Double.toString(123.99);g( );

returns the string value "123.99"

• The Characterclass contains a number of static  methods that are useful for string processing methods that are useful for string processing


Some Methods in the Class Character (Part 1  of 3)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐25

Some Methods in the Class Character (Part 2  of 3)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐26

Some Methods in the Class Character (Part 3 

of 3) Variables and Memory Variables and Memory

• A computer has two forms of memory

Secondary memory is used to hold files for Secondary memory is used to hold files for 

"permanent" storage

M i i d b h i

Main memory is used by a computer when it  is running a program

– Values stored in a program's variables are kept in 

main memoryy


Variables and Memory Variables and Memory

• Main memory consists of a long list of numbered  locations called bytes

Each byte contains eight bits:  eight 0 or 1 digits

The number that identifies a byte is called its address

– A data item can be stored in one (or more) of these bytes – The address of the byte is used to find the data item when y


Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐29

Variables and Memory Variables and Memory

V l f t d t t i th

• Values of most data types require more than one  byte of storage

– Several adjacent bytes are then used to hold the data itemSeveral adjacent bytes are then used to hold the data item – The entire chunk of memory that holds the data is called 

its memory location

– The address of the first byte of this memory location is  used as the address for the data item

• A computer's main memory can be thought of as a A computer s main memory can be thought of as a  long list of memory locations of varying sizes

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐30

Variables in Memory

Variables in Memory References References

• Every variable is implemented as a location in  computer memory

• When the variable is a primitive type, the value of  the variable is stored in the memory location  assigned to the variable

– Each primitive type always require the same amount of  memory to store its values


References References

Wh h i bl i l l h dd

• When the variable is a class type, only the memory address  (or reference) where its object is located is stored in the  memory location assigned to the variabley g

The object named by the variable is stored in some other location in  memory

Like primitives the value of a class variable is a fixed size Like primitives, the value of a class variable is a fixed size

Unlike primitives, the value of a class variable is a memory address or  reference  

h b h dd d h bl b f

The object, whose address is stored in the variable, can be of any size

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐33

References References

T f i bl i h

• Two reference variables can contain  the same  reference, and therefore name the same object

Th i t t t th f (

– The assignment operator sets the reference (memory  address) of one class type variable equal to that of another – Any change to the object named by one of theses variablesAny change to the object named by one of theses variables 

will produce a change to the object named by the other  variable, since they are the same object

variable2 = variable1;

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐34

Class Type Variables Store a Reference (Part 1 of  2)

Class Type Variables Store a Reference (Part 2 of 



Assignment Operator with Class Type Variables (Part  1 f 3)

1 of 3)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐37

Assignment Operator with Class Type Variables (Part  2 f 3)

2 of 3)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐38

Assignment Operator with Class Type Variables (Part  3 f 3)

3 of 3) Class Parameters Class Parameters

All parameters in Java are call‐by‐value parameters

A parameter is a local variable that is set equal to theA parameter is a local variable that is set equal to the 

value of its argument

– Therefore, any change to the value of the parameter  cannot change the value of its argument

• Class type parameters appear to behave  differently from primitive type parameters differently from primitive type parameters

– They appear to behave in a way similar to parameters  in languages that have the call‐by‐reference

parameter passing mechanism


Class Parameters Class Parameters

• The value plugged into a class type parameter is  a reference (memory address)

Therefore the parameter becomes another name for – Therefore, the parameter becomes another name for 

the argument

– Any change made to the object named by the  parameter (i.e., changes made to the values of its  instance variables) will be made to the object named  by the argument, because they are the same objecty g y j – Note that, because it still is a call‐by‐value parameter, 

any change made to the class type parameter itself  (i e its address) will not change its argument (the (i.e., its address) will not change its argument (the  reference or memory address)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐41

Parameters of a Class Type Parameters of a Class Type

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐42

Memory Picture for Display 5.14  (Part 1 of 3)

Memory Picture for Display 5.14 

(Part 2 of 3)


Memory Picture for Display 5.14  (Part 3 of 3)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐45

Differences Between Primitive and Class‐Type  Parameters

• A method cannot change the value of a  variable of a primitive type that is an  p yp argument to the method

• In contrast a method can change the values of

• In contrast, a method can change the values of  the instance variables of a class type that is an 

h h

argument to the method

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐46

Comparing Parameters of a Class Type and a  Primitive Type (Part 1 of 2)

Comparing Parameters of a Class Type and a 

Primitive Type (Part 2 of 2)


A Toy Class to Use in Display 5.16  (Part 1 of 2)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐49

A Toy Class to Use in Display 5.16  (Part 2 of 2)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐50

Pitfall:  Use of = and == with Variables of a Class  Type

• Used with variables of a class type, the assignment  operator (=) produces two variables that name the same  objectj

This is very different from how it behaves with primitive type  variables

• The test for equality (==) also behaves differently forThe test for equality ( ) also behaves differently for  class type variables

The ==operator only checks that two class type variables have  the same memory address

the same memory address

Unlike the equalsmethod, it does not check that their  instance variables have the same values

Two objects in two different locations whose instance variablesTwo objects in two different locations whose instance variables  have exactly the same values would still test as being "not 

The Constant null The Constant null

lli i l t t th t b i d t i bl

• nullis a special constant that may be assigned to a variable  of any class type

YourClass yourObject = null;

• It is used to indicate that the variable has no "real value"

It is often used in constructors to initialize class type instance variables  when there is no obvious object to usej

• nullis not an object:  It is, rather, a kind of "placeholder" for  a reference that does not name any memory location

Because it is like a memory address use==or!=(instead ofequals) Because it is like a memory address, use ==or !=(instead of equals) 

to test if a class variable contains null

if (yourObject == null) . . .


Pitfall: Null Pointer Exception Pitfall:  Null Pointer Exception

E th h l i bl b i iti li d t ll thi

• Even though a class variable can be initialized to null, this  does not mean that nullis an object

– nullu is only a placeholder for an objects o y a p ace o de o a object

• A method cannot be invoked using a variable that is initialized  to null

The calling object that must invoke a method does not exist

• Any attempt to do this will result in a "Null Pointer Exception" 

error message error message

For example, if the class variable has not been initialized at all (and is  not assigned to null), the results will be the same

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐53

The new Operator and Anonymous Objects The new Operator and Anonymous Objects

Th t i k t t hi h i iti li

• The newoperator invokes a constructor which initializes an  object, and returns a reference to the location in memory of  the object createdj

This reference can be assigned to a variable of the object's class type

• Sometimes the object created is used as an argument to a 

h d d d i

method, and never used again

In this case, the object need not be assigned to a variable, i.e., given a  name

• An object whose reference is not assigned to a variable is  called an anonymous object

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐54

Another Approach to Keyboard Input Using 

D bl D bl (P t 1 f 3)

Double.parseDouble (Part 1 of 3)

Another Approach to Keyboard Input Using 

D bl D bl (P t 2 f 3)

Double.parseDouble (Part 2 of 3)


Another Approach to Keyboard Input Using 

D bl D bl (P t 3 f 3)

Double.parseDouble (Part 3 of 3)

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐57

Using and Misusing References Using and Misusing References

Wh iti it i i t t t

• When writing a program, it is very important to  insure that private instance variables remain truly  private


• For a primitive type instance variable, just adding the  private modifier to its declaration should insure  that there will be no privacy leaks

• For a class type instance variable, however, adding 

th i t difi l i t ffi i t

the private modifier alone is not sufficient

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐58

Designing A Person Class: Instance Variables Designing A Person Class:  Instance Variables

• A simple Personclass could contain instance variables  representing a person's name, the date on which they  were born, and the date on which they diedy

• These instance variables would all be class types:  name  of type String, and two dates of type Date

• As a first line of defense for privacy each of the instance

• As a first line of defense for privacy, each of the instance  variables would be declared private

public class Person {


private String name;

private Date born;

private Date died; //null is still alive private Date died; //null is still alive

. . .

Designing a Person Class: Constructor Designing a Person Class:  Constructor

• In order to exist, a person must have (at least) a name  and a birth date

Therefore it would make no sense to have a no argument Therefore, it would make no sense to have a no‐argument 

Personclass constructor

• A person who is still alive does not yet have a date of  death

Therefore, the Personclass constructor will need to be able to  deal with a nullvalue for date of death

• A person who has died must have had a birth date that  preceded his or her date of death

Therefore, when both dates are provided, they will need to be 


A Person Class Constructor A Person Class Constructor

public Person(String initialName, Date birthDate, Date deathDate) {

if ( i t t(bi thD t d thD t )) if (consistent(birthDate, deathDate)) { name = initialName;

born = new Date(birthDate);

if (deathDate null) if (deathDate == null)

died = null;


died = new Date(deathDate);

died = new Date(deathDate);

} else

{ System out println("Inconsistent dates ");

{ System.out.println( Inconsistent dates. );


} } }

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐61

Designing a Person Class: the Class Invariant Designing a Person Class:  the Class Invariant

A t t t th t i l t f bj t f th l i

• A statement that is always true for every object of the class is  called a class invariant

A class invariant can help to define a class in a consistent and  i d

organized way

• For the Personclass, the following should always be true:

An object of the class Personj has a date of birth (which is not null), ( ) and if the object has a date of death, then the date of death is equal to  or later than the date of birth

• Checking the Personclass confirms that this is true of every  object created by a constructor, and all the other methods  (e.g., the private method consistent) preserve the truth  of this statement

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐62

Designing a Person Class: the Class Invariant Designing a Person Class:  the Class Invariant

/** Class invariant: A Person always has a date of birth, and if the Person has a date of death, then the date of death is equal to or later than the date of birth.

To be consistent, birthDate must not be null If there To be consistent, birthDate must not be null. If there is no date of death (deathDate == null), that is consistent with any birthDate. Otherwise, the birthDate must come before or be equal to the deathDate.



private static boolean consistent(Date birthDate, Date deathDate) {


if (birthDate == null) return false;

else if (deathDate == null) return true;

else return (birthDate.precedes(deathDate ||



Designing a Person Class:  the equals and  datesMatch Methods

Th d fi iti f l f th l P

• The definition of  equals for the class  Person includes an invocation of equals for the class  String , and an invocation of the method equals String , and an invocation of the method  equals for the class Date

• Java determines which  equals method is being  invoked from the type of its calling object

• Also note that the died instance variables are 

d i th d t M t h th d i t d

compared using the  datesMatch method instead 

of the equals method, since their values may be 

null u


Designing a Person Class:  the equals Method

public boolean equals(Person otherPerson) public boolean equals(Person otherPerson) {

if (otherPerson == null) return false;


return (name.equals(otherPerson.name) &&

born.equals(otherPerson.born) &&

datesMatch(died, otherPerson.died));

} }

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐65

Designing a Person Class:  the matchDate Method

/** To match date1 and date2 must either be the same date or both be null.


private static boolean datesMatch(Date date1, Date date2) {


if (date1 == null)

return (date2 == null);

else if (date2 == null) //&& date1 != null else if (date2 == null) //&& date1 != null

return false;

else // both dates are not null.

return(date1 equals(date2));



Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐66

Designing a Person Class:  the toString Method

• Like the equalsmethod, note that the Personclass  toStringmethod includes invocations of the Date class toStringgmethod

public String toString( ) {


String diedString;

if (died == null)

diedString = ""; //Empty stringg ; // p y g else

diedString = died.toString( );

return (name + ", " + born + "-" + diedString);

Copy Constructors Copy Constructors

A t t i t t ith i l

A copy constructor is a constructor with a single  argument of the same type as the class

• The copy constructor should create an object that is

• The copy constructor should create an object that is  a separate, independent object, but with the 

instance variables set so that it is an exact copy of  the argument object

• Note how, in the Date copy constructor, the values 

f ll f th i iti t i t i t i bl

of all of the primitive type private instance variables 

are merely copied


Copy Constructor for a Class with Primitive Type  Instance Variables

public Date(Date aDate) public Date(Date aDate) {

if (aDate == null) //Not a real date.


System.out.println("Fatal Error.");



month = aDate.month;; day = aDate.day;

year = aDate.year;

} }

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐69

Copy Constructor for a Class with Class Type  Instance Variables

U lik th D t l th P l t i

• Unlike the Date class, the Person class contains  three class type instance variables

• If the born and died class type instance variables

• If the  born and  died class type instance variables  for the new Person object were merely copied,  then they would simply rename the  born and  died variables from the original Person object

born = original.born //dangerous died = original died //dangerous died = original.died //dangerous

– This would not create an independent copy of the original  object

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐70

Copy Constructor for a Class with Class Type  Instance Variables

Th t l t t f th P l i " f "

• The actual copy constructor for the Personclass is a "safe" 

version that creates completely new and independent copies  of bornand died, and therefore, a completely new and , , p y independent copy of the original Personobject

For example:  

b D t ( i i l b )

born = new Date(original.born);

• Note that in order to define a correct copy constructor for a  class that has class type instance variables, copy constructors  c ass t at as c ass type sta ce a ab es, copy co st ucto s must already be defined for the instance variables' classes 

Copy Constructor for a Class with Class Type  Instance Variables

public Person(Person original) public Person(Person original) {

if (original == null) {


System.out.println("Fatal error.");


} }

name = original.name;

born = new Date(original.born);

if (original.died == null)( g ) died = null;


died = new Date(original.died);g }


Pitfall: Privacy Leaks Pitfall:  Privacy Leaks

• The previously illustrated examples from the Person class show how an incorrect definition of a constructor  can result in a privacy leakp y

• A similar problem can occur with incorrectly defined  mutator or accessor methods

For example:

For example:

public Date getBirthDate() {

return born; //dangerous return born; //dangerous }

Instead of:

public Date getBirthDate() public Date getBirthDate() {

return new Date(born); //correct }


Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐73

Mutable and Immutable Classes Mutable and Immutable Classes

Th th d tN f th P l

• The accessor method getNamefrom the Personclass  appears to contradict the rules for avoiding privacy leaks:

public String getName()

p g g ()


return name; //Isn't this dangerous?

} }

• Although it appears the same as some of the previous  examples, it is not: The classStringcontains no mutator examples, it is not:  The class Stringcontains no mutator  methods that can change any of the data in a Stringobject

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐74

Mutable and Immutable Classes Mutable and Immutable Classes

A l h i h d ( h h

• A class that contains no methods (other than  constructors) that change any of the data in an  object of the class is called an immutable class object of the class is called an immutable class

Objects of such a class are called immutable objects It is perfectly safe to return a reference to an immutable – It is perfectly safe to return a reference to an immutable 

object because the object cannot be changed in any way – The Stringgclass is an immutable class

Mutable and Immutable Classes Mutable and Immutable Classes

A l h i bli h d

• A class that contains public mutator methods or  other public methods that can change the data in its  objects is called a mutable class and its objects are objects is called a mutable class, and its objects are  called mutable objects

– Never write a method that returns a mutable object – Never write a method that returns a mutable object – Instead, use a copy constructor to return a reference to a 

completely independent copy of the mutable objectp y p py j


Deep Copy Versus Shallow Copy Deep Copy Versus Shallow Copy

A deep copy of an object is a copy that, with one  exception, has no references in common with the  original

– Exception:  References to immutable objects are allowed  to be shared 

Any copy that is not a deep copy is called a shallow  copy

– This type of copy can cause dangerous privacy leaks  in a  program

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐77

Packages and Import  Statements

Java uses packages to form libraries of classes

• A package is a group of classes that have been 

l d i di t f ld d th t b

placed in a directory or folder, and that can be  used in any program that includes an import  statement that names the package

statement that names the package

– The import statement must be located at the  beginning of the program file:  Only blank lines,  comments and package statements may precede it comments, and package statements may precede it – The program can be in a different directory from the 


Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐78

Import Statements Import Statements

• We have already used import statements to  include some predefined packages in Java, such 

S f th j til k

as  Scanner from the  java.util package

import java.util.Scanner;

I i ibl k ll h l i k

• It is possible to make all the classes in a package  available instead of just one class:

i t j til *

import java.util.*;

– Note that there is no additional overhead for  importing the entire package

importing the entire package

The package Statement The package Statement

• To make a package, group all the classes 

together into a single directory (folder), and add  the following package statement to the

the following package statement to the  beginning of each class file:

package package name;

p g p g _

– Only the .classfiles must be in the directory or  folder, the .javafiles are optional

Only blank lines and comments may precede the – Only blank lines and comments may precede the 

package statement

– If there are both import and package statements, the  package statement must precede any import 



The Package java lang The Package java.lang

• The package  java.lang contains the classes  that are fundamental to Java programming p g g

– It is imported automatically, so no import  statement is needed

statement is needed

– Classes made available by  java.lang include  Math String and the wrapper classes

Math, String, and the wrapper classes

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐81

Package Names and Directories Package Names and Directories

A k i th th f th di t

• A package name is the path name for the directory or  subdirectories that contain the package classes

• Java needs two things to find the directory for a package:  the g y p g name of the package and the value of the CLASSPATH variable

The CLASSPATHenvironment variable is similar to the PATH variable, and is set in the same way for a given operating system The CLASSPATHvariable is set equal to the list of directories 

(including the current directory, ".") in which Java will look for  packages on a particular computer

Java searches this list of directories in order, and uses the first  directory on the list in which the package is found

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐82

A Package Name

A Package Name Pitfall:  Subdirectories Are Not Automatically  Imported

When a package is stored in a subdirectory of the directory containing

When a package is stored in a subdirectory of the directory containing  another package, importing the enclosing package does not import the  subdirectory package

The import statement:The import statement:

import utilities.numericstuff.*;

imports the utilities.numericstuffpackage only

The import statements:

The import statements:

import utilities.numericstuff.*;

import utilities.numericstuff.statistical.*;

import both theutilities numericstuffand import both the utilities.numericstuffand utilities.numericstuff.statisticalpackages


The Default Package The Default Package

• All the classes in the current directory belong  to an unnamed package called the default  p g f package

• As long as the current directory ( ) is part of

• As long as the current directory ( . ) is part of  the  CLASSPATH variable, all the classes in 

h f l k ll

the default package are automatically  available to a program

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐85

Pitfall:  Not Including the Current Directory in  Your Class Path

• If the  CLASSPATH variable is set, the current 

directory must be included as one of the alternatives

– Otherwise, Java may not even be able to find the .class files for the program itself

• If the CLASSPATH variable is not set, then all the  class files for a program must be put in the current  directory

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐86

Specifying a Class Path When You Compile Specifying a Class Path When You Compile

• The class path can be manually specified when  a class is compiled p

– Just add  –classpath followed by the desired  class path

class path

– This will compile the class, overriding any previous  CLASSPATH setting


• You should use the  –classpath option  again when the class is run

Name Clashes Name Clashes

I dditi t k i l lib i i d k

• In addition to keeping class libraries organized, packages  provide a way to deal with name clashes:  a situation in which  two classes have the same name

Different programmers writing different packages may use the same  name for one or more of their classes

This ambiguity can be resolved by using the fully qualified name (i.e., 

d th l b it k ) t di ti i h b t

precede the class name by its package name) to distinguish between  each class


If th f ll lifi d i d it i l t i t

If the fully qualified name is used, it is no longer necessary to import  the class (because it includes the package name already)


Introduction to javadoc Introduction to javadoc

U lik l h C++ J l b th th i t f

• Unlike a language such as C++, Java places both the interface  and the implementation of a class in the same file

• However, Java has a program called javadocp g j that 

automatically extracts the interface from a class definition and  produces documentation

This information is presented in HTML format, and can be viewed with p , a Web browser

If a class is correctly commented, a programmer need only refer to this  API (Application Programming Interface) documentation in order to  use the class

– javadoccan obtain documentation for anything from a single class  to an entire package

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐89

Commenting Classes for javadoc Commenting Classes for javadoc

• The javadocprogram extracts class headings, the  headings for some comments, and headings for all  public methods instance variables and static variables public methods, instance variables, and static variables

In the normal default mode, no method bodies or private  items are extracted

• To extract a comment, the following must be true:

1. The comment must immediately precede a public class or  method definition, or some other public item, p

2. The comment must be a block comment, and the opening /*

must contain an extra *( /** . . . */)

Note: Extra options would have to be set in order to extract Note:  Extra options would have to be set in order to extract 

line comments ( //) and private items

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐90

Commenting Classes for javadoc Commenting Classes for javadoc

• In addition to any general information, the comment  preceding a public method definition should include  descriptions of parameters, any value returned, and p p y any exceptions that might be thrown

This type of information is preceded by the @symbol and is  called an @ tag

@ tags come after any general comment, and each one is on a  line by itself


General Comments about the method . . .

@param aParameter Description of aParameter

@return What is returned

@return What is returned . . .

@ Tags

@ Tags

@ tags should be placed in the order found below

If there are multiple parameters, each should have its own @param on a separate line, and each should be listed according to its left‐to‐p , g right order on the parameter list

If there are multiple authors, each should have its own @author on a separate linep

@param Parameter_Name Parameter_Description

@return Description_Of_Value_Returned

@th E ti T E l ti

@throws Exception_Type Explanation


@see Package Name.Class Nameg _ _

@author Author


Running javadoc Running javadoc

• To run javadocon a package, give the following  command:

javadoc –d Documentation Directory Package Name javadoc –d Documentation_Directory Package_Name

The HTML documents produced will be placed in the  Documentation_Directory

f h d i d

If the –dand Documentation_Directoryare omitted,  javadocwill create suitable directories for the 


• To run javadocon a single class, give the following  command from the directory containing the class file:  

javadoc ClassName.java ja adoc C ass a e.ja a

• To run javadoc on all the classes in a directory, give the  following command instead:  javadoc *.java

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐93

Options for javadoc Options for javadoc

Copyright © 2012 Pearson Addison‐Wesley. All rights reserved. 5‐94




Related subjects :