Java execise

1. Consider the following interface:
public interface StringIterator {
boolean hasNext();
String next();
}
An object from a class implementing StringIterator produces a sequence of strings, one in each
call to next(). The client may only call next() if hasNext() returns true.
Your task is to implement a class called StringToWords that implements this interface. Its
constructor should take a string as argument, and next() should return the sequence of spaceseparated words in the string. For example, this program:
public class StringToWordsTester {
public static void main(String args[]) {
StringIterator stw = new StringToWords(" This is 6.005. ");
while (stw.hasNext())
System.out.println("<"+stw.next()+">");
}
}
should print
<This>
<is>
<6.005.>
2. Explain why the line
StringIterator stw = new StringToWords(" This is 6.005. ");
in the previous program can assign a reference to an object of one type to a variable of another
type (one or two sentences).
3. Java has two right-shift operators, >> and >>>. Show a case where the two operators return
the same result and another case where they return a different result.
4. Rewrite the expression
i = (x < 0) ? -x : x;
as a conditional statement (if/then/else).
topMIT COPYRIGHT INFORMATION | MIT PUBLIC DOMAIN & FAIR USE GUIDELINES

Question two
Consider the following classes:
public class House {
private static java.util.ArrayList<House> houses = new java.util.ArrayList<House>();
private String address;
private String owner;
public House(String address, String owner) {
houses.add(this);
this.address = address;
this.owner = owner;
}
public String address() {
return address;
}
public String owner() {
return owner;
}
public String occupant() {
return owner();
}
public String toString() {
return address()+", "+owner()+", "+occupant();
}
public static java.util.ArrayList<House> houses() {
return houses;
}
}
public class HouseTest {
new House("30 Main Street", "Bob");
new House("32 Vassar Street", "Alice");
new RentedHouse("77 Mass ave", "Hector", "Sylvia");
for (House h : House.houses())
System.out.println(h);

}
}
1. Extend "House" to a class "RentedHouse"; it's constructor should have three arguments: the
address, owner, and renter. The loop in "main()" above should print all the houses, including the
rented ones (do not change "main()"). The output of the program should, therefore, be:
30 Main Street, Bob, Bob
32 Vassar Street, Alice, Alice
77 Mass ave, Hector, Sylvia
--------------------------------Questions 2-5 refer to the following two classes:
public class InheritanceSuper {
static String staticField = "static field in super";
String
field
= "instance field in super";
static void staticMethod() { System.out.println("static method in super"); }
void
method()
{ System.out.println("instance method in super"); }
}
ublic class InheritanceSub extends InheritanceSuper {
public static String staticField = "static field in sub";
public String
field
= "instance field in sub";
static void staticMethod() { System.out.println("static method in sub"); }
void
method()
{ System.out.println("instance method in sub"); }
void tester () {
// missing implementation, see questions below
}
InheritanceSub sub1 = new InheritanceSub();
InheritanceSuper sup1 = sub;
InheritanceSuper sup2 = new InheritanceSub();
InheritanceSub sub2 = sup2;
sub1.tester();
// the rest si missing, see questions below.
}
}

2. Does the program (these two classes) compile? If not, explain how to fix it so that it compiles.
3. Can we add a call to "sup1.tester()" in main? Explain.
4. Extend main so that it calls the methods "method()" and "staticMethod()" of the two classes,
and prints their fields, or explain why it is impossible to do so (explain each case you believe is
not possible). Use only the variables and objects already defined and created in main; do not
create more objects and variables.
5. Extend tester() so that it calls the four methods and prints the four fields (that is, two methods
in two classes and two fields in two classes) or explain why it is not possible to do so. Do not
create any new objects and do not define any variables in tester().
topMIT COPYRIGHT INFORMATION | MIT PUBLIC DOMAIN & FAIR USE GUIDELINES

QUESTION THREE
1. Write a program that creates two identical threads and runs them. One thread should print "Thread
A" one thousand times and the other should print "Thread B" one thousand times. The main program
should wait for the two threads to end before it ends itself. Don't run the program yet.
2. Do you think that the printouts of the two threads would get interleaved? That is, will each line in the
output show either "Thread A" or "Thread B", or is it possible that a line would show something like
"ThreThread B"? Now run the program and test your hypothesis. If you see all the "Thread A" lines
followed by all the "Thread B" lines, then your threads are not running concurrently; the two threads
should run concurrently.
3. Implement a class IntBuffer with two methods, "void put(int x)" and "int get()". The class represents a
buffer of one integer. If the buffer is empty, get() waits until another thread puts a value in the buffer. If
the buffer is not empty, get() succeeds and returns the buffered value immediately, but invoking put()
causes the thread to wait until some other thread gets the currently-buffered value.
Write a program that creates two threads, one that calls put() one thousand times with arguments 0, 1,
2, etc., and another that calls get() one thousand times, printing each value that is returned.
Use synchronize or BlockedQueue to implement the synchronization in these programs.

Defining Methods
Here is an example of a typical method declaration:
public double calculateAnswer(double wingSpan, int numberOfEngines,
double length, double grossTons) {
//do the calculation here
}

The only required elements of a method declaration are the method's return type, name, a pair of
parentheses, (), and a body between braces, {}.
More generally, method declarations have six components, in order:
1. Modifiers—such as public, private, and others you will learn about later.
2. The return type—the data type of the value returned by the method, or void if the method
does not return a value.
3. The method name—the rules for field names apply to method names as well, but the
convention is a little different.
4. The parameter list in parenthesis—a comma-delimited list of input parameters, preceded
by their data types, enclosed by parentheses, (). If there are no parameters, you must use
empty parentheses.

5. An exception list—to be discussed later.
6. The method body, enclosed between braces—the method's code, including the
declaration of local variables, goes here.
Modifiers, return types, and parameters will be discussed later in this lesson. Exceptions are
discussed in a later lesson.

Definition: Two of the components of a method declaration comprise the method signature—the
method's name and the parameter types.

The signature of the method declared above is:
calculateAnswer(double, int, double, double)

Naming a Method
Although a method name can be any legal identifier, code conventions restrict method names. By
convention, method names should be a verb in lowercase or a multi-word name that begins with
a verb in lowercase, followed by adjectives, nouns, etc. In multi-word names, the first letter of
each of the second and following words should be capitalized. Here are some examples:
run
runFast
getBackground
getFinalData
compareTo
setX
isEmpty

Typically, a method has a unique name within its class. However, a method might have the same
name as other methods due to method overloading.

Overloading Methods
The Java programming language supports overloading methods, and Java can distinguish
between methods with different method signatures. This means that methods within a class can
have the same name if they have different parameter lists (there are some qualifications to this
that will be discussed in the lesson titled "Interfaces and Inheritance").
Suppose that you have a class that can use calligraphy to draw various types of data (strings,
integers, and so on) and that contains a method for drawing each data type. It is cumbersome to
use a new name for each method—for example, drawString, drawInteger, drawFloat, and so
on. In the Java programming language, you can use the same name for all the drawing methods
but pass a different argument list to each method. Thus, the data drawing class might declare four
methods named draw, each of which has a different parameter list.

public class DataArtist {
...
public void draw(String
...
}
public void draw(int i)
...
}
public void draw(double
...
}
public void draw(int i,
...
}
}

s) {
{
f) {
double f) {

Overloaded methods are differentiated by the number and the type of the arguments passed into
the method. In the code sample, draw(String s) and draw(int i) are distinct and unique
methods because they require different argument types.
You cannot declare more than one method with the same name and the same number and type of
arguments, because the compiler cannot tell them apart.
The compiler does not consider return type when differentiating methods, so you cannot declare
two methods with the same signature even if they have a different return type.

Note: Overloaded methods should be used sparingly, as they can make code much less readable.

Passing Information to a Method or a
Constructor

The declaration for a method or a constructor declares the number and the type of the arguments
for that method or constructor. For example, the following is a method that computes the
monthly payments for a home loan, based on the amount of the loan, the interest rate, the length
of the loan (the number of periods), and the future value of the loan:
public double computePayment(
double loanAmt,
double rate,
double futureValue,
int numPeriods) {
double interest = rate / 100.0;
double partial1 = Math.pow((1 + interest),
- numPeriods);
double denominator = (1 - partial1) / interest;
double answer = (-loanAmt / denominator)
- ((futureValue * partial1) / denominator);
return answer;
}

This method has four parameters: the loan amount, the interest rate, the future value and the
number of periods. The first three are double-precision floating point numbers, and the fourth is
an integer. The parameters are used in the method body and at runtime will take on the values of
the arguments that are passed in.

Note: Parameters refers to the list of variables in a method declaration. Arguments are the actual
values that are passed in when the method is invoked. When you invoke a method, the arguments
used must match the declaration's parameters in type and order.

Parameter Types
You can use any data type for a parameter of a method or a constructor. This includes primitive
data types, such as doubles, floats, and integers, as you saw in the computePayment method, and
reference data types, such as objects and arrays.
Here's an example of a method that accepts an array as an argument. In this example, the method
creates a new Polygon object and initializes it from an array of Point objects (assume that
Point is a class that represents an x, y coordinate):
public Polygon polygonFrom(Point[] corners) {
// method body goes here
}

Note: The Java programming language doesn't let you pass methods into methods. But you can
pass an object into a method and then invoke the object's methods.

Arbitrary Number of Arguments
You can use a construct called varargs to pass an arbitrary number of values to a method. You
use varargs when you don't know how many of a particular type of argument will be passed to
the method. It's a shortcut to creating an array manually (the previous method could have used
varargs rather than an array).
To use varargs, you follow the type of the last parameter by an ellipsis (three dots, ...), then a
space, and the parameter name. The method can then be called with any number of that
parameter, including none.
public Polygon polygonFrom(Point... corners) {
int numberOfSides = corners.length;
double squareOfSide1, lengthOfSide1;
squareOfSide1 = (corners[1].x - corners[0].x)
* (corners[1].x - corners[0].x)
+ (corners[1].y - corners[0].y)
* (corners[1].y - corners[0].y);
lengthOfSide1 = Math.sqrt(squareOfSide1);
// more method body code follows that creates and returns a
// polygon connecting the Points
}

You can see that, inside the method, corners is treated like an array. The method can be called
either with an array or with a sequence of arguments. The code in the method body will treat the
parameter as an array in either case.
You will most commonly see varargs with the printing methods; for example, this printf
method:
public PrintStream printf(String format, Object... args)

allows you to print an arbitrary number of objects. It can be called like this:
System.out.printf("%s: %d, %s%n", name, idnum, address);

or like this
System.out.printf("%s: %d, %s, %s, %s%n", name, idnum, address, phone,
email);

or with yet a different number of arguments.

Parameter Names
When you declare a parameter to a method or a constructor, you provide a name for that
parameter. This name is used within the method body to refer to the passed-in argument.

The name of a parameter must be unique in its scope. It cannot be the same as the name of
another parameter for the same method or constructor, and it cannot be the name of a local
variable within the method or constructor.
A parameter can have the same name as one of the class's fields. If this is the case, the parameter
is said to shadow the field. Shadowing fields can make your code difficult to read and is
conventionally used only within constructors and methods that set a particular field. For
example, consider the following Circle class and its setOrigin method:
public class Circle {
private int x, y, radius;
public void setOrigin(int x, int y) {
...
}
}

The Circle class has three fields: x, y, and radius. The setOrigin method has two parameters,
each of which has the same name as one of the fields. Each method parameter shadows the field
that shares its name. So using the simple names x or y within the body of the method refers to the
parameter, not to the field. To access the field, you must use a qualified name. This will be
discussed later in this lesson in the section titled "Using the this Keyword."

Passing Primitive Data Type Arguments
Primitive arguments, such as an int or a double, are passed into methods by value. This means
that any changes to the values of the parameters exist only within the scope of the method. When
the method returns, the parameters are gone and any changes to them are lost. Here is an
example:
public class PassPrimitiveByValue {
public static void main(String[] args) {
int x = 3;
// invoke passMethod() with
// x as argument
passMethod(x);
// print x to see if its
// value has changed
System.out.println("After invoking passMethod, x = " + x);
}
// change parameter in passMethod()
public static void passMethod(int p) {
p = 10;
}
}

When you run this program, the output is:
After invoking passMethod, x = 3

Passing Reference Data Type Arguments
Reference data type parameters, such as objects, are also passed into methods by value. This
means that when the method returns, the passed-in reference still references the same object as
before. However, the values of the object's fields can be changed in the method, if they have the
proper access level.
For example, consider a method in an arbitrary class that moves Circle objects:
public void moveCircle(Circle
// code to move origin of
circle.setX(circle.getX()
circle.setY(circle.getY()

circle, int deltaX, int deltaY) {
circle to x+deltaX, y+deltaY
+ deltaX);
+ deltaY);

// code to assign a new reference to circle
circle = new Circle(0, 0);
}

Let the method be invoked with these arguments:
moveCircle(myCircle, 23, 56)

Inside the method, circle initially refers to myCircle. The method changes the x and y
coordinates of the object that circle references (i.e., myCircle) by 23 and 56, respectively.
These changes will persist when the method returns. Then circle is assigned a reference to a
new Circle object with x = y = 0. This reassignment has no permanence, however, because
the reference was passed in by value and cannot change. Within the method, the object pointed to
by circle has changed, but, when the method returns, myCircle still references the same
Circle object as before the method was called.

Creating Objects

As you know, a class provides the blueprint for objects; you create an object from a class. Each
of the following statements taken from the CreateObjectDemo program creates an object and
assigns it to a variable:
Point originOne = new Point(23, 94);
Rectangle rectOne = new Rectangle(originOne, 100, 200);
Rectangle rectTwo = new Rectangle(50, 100);

The first line creates an object of the Point class, and the second and third lines each create an
object of the Rectangle class.
Each of these statements has three parts (discussed in detail below):
1. Declaration: The code set in bold are all variable declarations that associate a variable
name with an object type.
2. Instantiation: The new keyword is a Java operator that creates the object.
3. Initialization: The new operator is followed by a call to a constructor, which initializes
the new object.

Declaring a Variable to Refer to an Object
Previously, you learned that to declare a variable, you write:
type name;

This notifies the compiler that you will use name to refer to data whose type is type. With a
primitive variable, this declaration also reserves the proper amount of memory for the variable.
You can also declare a reference variable on its own line. For example:
Point originOne;

If you declare originOne like this, its value will be undetermined until an object is actually
created and assigned to it. Simply declaring a reference variable does not create an object. For
that, you need to use the new operator, as described in the next section. You must assign an
object to originOne before you use it in your code. Otherwise, you will get a compiler error.
A variable in this state, which currently references no object, can be illustrated as follows (the
variable name, originOne, plus a reference pointing to nothing):

Instantiating a Class
The new operator instantiates a class by allocating memory for a new object and returning a
reference to that memory. The new operator also invokes the object constructor.

Note: The phrase "instantiating a class" means the same thing as "creating an object." When you
create an object, you are creating an "instance" of a class, therefore "instantiating" a class.

The new operator requires a single, postfix argument: a call to a constructor. The name of the
constructor provides the name of the class to instantiate.
The new operator returns a reference to the object it created. This reference is usually assigned to
a variable of the appropriate type, like:

The reference returned by the new operator does not have to be assigned to a variable. It can also
be used directly in an expression. For example:
int height = new Rectangle().height;

This statement will be discussed in the next section.

Initializing an Object
Here's the code for the Point class:
public class Point {
public int x = 0;
public int y = 0;
//constructor
public Point(int a, int b) {
x = a;
y = b;
}
}

This class contains a single constructor. You can recognize a constructor because its declaration
uses the same name as the class and it has no return type. The constructor in the Point class
takes two integer arguments, as declared by the code (int a, int b). The following statement
provides 23 and 94 as values for those arguments:

The result of executing this statement can be illustrated in the next figure:

Here's the code for the Rectangle class, which contains four constructors:
public class Rectangle {
public int width = 0;
public int height = 0;
public Point origin;
// four constructors
public Rectangle() {
origin = new Point(0, 0);
}
public Rectangle(Point p) {
origin = p;
}
public Rectangle(int w, int h) {
width = w;
height = h;
}
public Rectangle(Point p, int w, int h) {
origin = p;
width = w;
height = h;
}
// a method for moving the rectangle
public void move(int x, int y) {
origin.x = x;
origin.y = y;
}
// a method for computing the area of the rectangle
public int getArea() {
return width * height;
}
}

Each constructor lets you provide initial values for the rectangle's size and width, using both
primitive and reference types. If a class has multiple constructors, they must have different
signatures. The Java compiler differentiates the constructors based on the number and the type of
the arguments. When the Java compiler encounters the following code, it knows to call the

constructor in the Rectangle class that requires a Point argument followed by two integer
arguments:
Rectangle rectOne = new Rectangle(originOne, 100, 200);

This calls one of Rectangle's constructors that initializes origin to originOne. Also, the
constructor sets width to 100 and height to 200. Now there are two references to the same
Point object—an object can have multiple references to it, as shown in the next figure:

The following line of code calls the Rectangle constructor that requires two integer arguments,
which provide the initial values for width and height. If you inspect the code within the
constructor, you will see that it creates a new Point object whose x and y values are initialized
to 0:
Rectangle rectTwo = new Rectangle(50, 100);

The Rectangle constructor used in the following statement doesn't take any arguments, so it's
called a no-argument constructor:
Rectangle rect = new Rectangle();

All classes have at least one constructor. If a class does not explicitly declare any, the Java
compiler automatically provides a no-argument constructor, called the default constructor. This
default constructor calls the class parent's no-argument constructor, or the Object constructor if
the class has no other parent. If the parent has no constructor (Object does have one), the
compiler will reject the program.

Using Objects
Once you've created an object, you probably want to use it for something. You may need to use
the value of one of its fields, change one of its fields, or call one of its methods to perform an
action.

Referencing an Object's Fields
Object fields are accessed by their name. You must use a name that is unambiguous.
You may use a simple name for a field within its own class. For example, we can add a statement
within the Rectangle class that prints the width and height:
System.out.println("Width and height are: " + width + ", " + height);

In this case, width and height are simple names.
Code that is outside the object's class must use an object reference or expression, followed by the
dot (.) operator, followed by a simple field name, as in:
objectReference.fieldName

For example, the code in the CreateObjectDemo class is outside the code for the Rectangle
class. So to refer to the origin, width, and height fields within the Rectangle object named
rectOne, the CreateObjectDemo class must use the names rectOne.origin, rectOne.width,
and rectOne.height, respectively. The program uses two of these names to display the width
and the height of rectOne:
System.out.println("Width of rectOne: " + rectOne.width);
System.out.println("Height of rectOne: " + rectOne.height);

Attempting to use the simple names width and height from the code in the CreateObjectDemo
class doesn't make sense — those fields exist only within an object — and results in a compiler
error.
Later, the program uses similar code to display information about rectTwo. Objects of the same
type have their own copy of the same instance fields. Thus, each Rectangle object has fields
named origin, width, and height. When you access an instance field through an object
reference, you reference that particular object's field. The two objects rectOne and rectTwo in
the CreateObjectDemo program have different origin, width, and height fields.
To access a field, you can use a named reference to an object, as in the previous examples, or
you can use any expression that returns an object reference. Recall that the new operator returns a

reference to an object. So you could use the value returned from new to access a new object's
fields:
int height = new Rectangle().height;

This statement creates a new Rectangle object and immediately gets its height. In essence, the
statement calculates the default height of a Rectangle. Note that after this statement has been
executed, the program no longer has a reference to the created Rectangle, because the program
never stored the reference anywhere. The object is unreferenced, and its resources are free to be
recycled by the Java Virtual Machine.

Calling an Object's Methods
You also use an object reference to invoke an object's method. You append the method's simple
name to the object reference, with an intervening dot operator (.). Also, you provide, within
enclosing parentheses, any arguments to the method. If the method does not require any
arguments, use empty parentheses.
objectReference.methodName(argumentList);

or:
objectReference.methodName();

The Rectangle class has two methods: getArea() to compute the rectangle's area and move()
to change the rectangle's origin. Here's the CreateObjectDemo code that invokes these two
methods:
System.out.println("Area of rectOne: " + rectOne.getArea());
...
rectTwo.move(40, 72);

The first statement invokes rectOne's getArea() method and displays the results. The second
line moves rectTwo because the move() method assigns new values to the object's origin.x
and origin.y.
As with instance fields, objectReference must be a reference to an object. You can use a variable
name, but you also can use any expression that returns an object reference. The new operator
returns an object reference, so you can use the value returned from new to invoke a new object's
methods:
new Rectangle(100, 50).getArea()

The expression new Rectangle(100, 50) returns an object reference that refers to a Rectangle
object. As shown, you can use the dot notation to invoke the new Rectangle's getArea()
method to compute the area of the new rectangle.

Some methods, such as getArea(), return a value. For methods that return a value, you can use
the method invocation in expressions. You can assign the return value to a variable, use it to
make decisions, or control a loop. This code assigns the value returned by getArea() to the
variable areaOfRectangle:
int areaOfRectangle = new Rectangle(100, 50).getArea();

Remember, invoking a method on a particular object is the same as sending a message to that
object. In this case, the object that getArea() is invoked on is the rectangle returned by the
constructor.

The Garbage Collector
Some object-oriented languages require that you keep track of all the objects you create and that
you explicitly destroy them when they are no longer needed. Managing memory explicitly is
tedious and error-prone. The Java platform allows you to create as many objects as you want
(limited, of course, by what your system can handle), and you don't have to worry about
destroying them. The Java runtime environment deletes objects when it determines that they are
no longer being used. This process is called garbage collection.
An object is eligible for garbage collection when there are no more references to that object.
References that are held in a variable are usually dropped when the variable goes out of scope.
Or, you can explicitly drop an object reference by setting the variable to the special value null.
Remember that a program can have multiple references to the same object; all references to an
object must be dropped before the object is eligible for garbage collection.
The Java runtime environment has a garbage collector that periodically frees the memory used
by objects that are no longer referenced. The garbage collector does its job automatically when it
determines that the time is right.

Returning a Value from a Method
A method returns to the code that invoked it when it
completes all the statements in the method,
reaches a return statement, or
throws an exception (covered later),
whichever occurs first.
You declare a method's return type in its method declaration. Within the body of the method, you
use the return statement to return the value.
Any method declared void doesn't return a value. It does not need to contain a return
statement, but it may do so. In such a case, a return statement can be used to branch out of a
control flow block and exit the method and is simply used like this:
return;

If you try to return a value from a method that is declared void, you will get a compiler error.
Any method that is not declared void must contain a return statement with a corresponding
return value, like this:
return returnValue;

The data type of the return value must match the method's declared return type; you can't return
an integer value from a method declared to return a boolean.
The getArea() method in the RectangleRectangle class that was discussed in the sections on
objects returns an integer:
// a method for computing the area of the rectangle
}

This method returns the integer that the expression width*height evaluates to.
The getArea method returns a primitive type. A method can also return a reference type. For
example, in a program to manipulate Bicycle objects, we might have a method like this:
public Bicycle seeWhosFastest(Bicycle myBike, Bicycle yourBike,
Environment env) {

Bicycle fastest;
// code to calculate which bike is
// faster, given each bike's gear
// and cadence and given the
// environment (terrain and wind)
return fastest;
}

Returning a Class or Interface
If this section confuses you, skip it and return to it after you have finished the lesson on
interfaces and inheritance.
When a method uses a class name as its return type, such as whosFastest does, the class of the
type of the returned object must be either a subclass of, or the exact class of, the return type.
Suppose that you have a class hierarchy in which ImaginaryNumber is a subclass of
java.lang.Number, which is in turn a subclass of Object, as illustrated in the following figure.

The class hierarchy for ImaginaryNumber
Now suppose that you have a method declared to return a Number:
public Number returnANumber() {
...
}

The returnANumber method can return an ImaginaryNumber but not an Object.
ImaginaryNumber is a Number because it's a subclass of Number. However, an Object is not
necessarily a Number — it could be a String or another type.
You can override a method and define it to return a subclass of the original method, like this:
public ImaginaryNumber returnANumber() {
...
}

This technique, called covariant return type, means that the return type is allowed to vary in the
same direction as the subclass.

Note: You also can use interface names as return types. In this case, the object returned must
implement the specified interface.

Using the this Keyword
Within an instance method or a constructor, this is a reference to the current object — the
object whose method or constructor is being called. You can refer to any member of the current
object from within an instance method or a constructor by using this.

Using this with a Field
The most common reason for using the this keyword is because a field is shadowed by a
method or constructor parameter.
For example, the Point class was written like this
public int x = 0;
public int y = 0;
//constructor
public Point(int a, int b) {
x = a;
y = b;
}
}

but it could have been written like this:
public int x = 0;
public int y = 0;
//constructor
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}

Each argument to the constructor shadows one of the object's fields — inside the constructor x is
a local copy of the constructor's first argument. To refer to the Point field x, the constructor
must use this.x.

Using this with a Constructor
From within a constructor, you can also use the this keyword to call another constructor in the
same class. Doing so is called an explicit constructor invocation. Here's another Rectangle
class, with a different implementation from the one in the Objects section.
public class Rectangle {
private int x, y;
private int width, height;
public Rectangle() {
this(0, 0, 0, 0);
}
public Rectangle(int width, int height) {
this(0, 0, width, height);
}
public Rectangle(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
...
}

This class contains a set of constructors. Each constructor initializes some or all of the rectangle's
member variables. The constructors provide a default value for any member variable whose
initial value is not provided by an argument. For example, the no-argument constructor calls the
four-argument constructor with four 0 values and the two-argument constructor calls the fourargument constructor with two 0 values. As before, the compiler determines which constructor to
call, based on the number and the type of arguments.
If present, the invocation of another constructor must be the first line in the constructor.

Controlling Access to Members of a Class
Access level modifiers determine whether other classes can use a particular field or invoke a
particular method. There are two levels of access control:
At the top level—public, or package-private (no explicit modifier).
At the member level—public, private, protected, or package-private (no explicit
modifier).
A class may be declared with the modifier public, in which case that class is visible to all
classes everywhere. If a class has no modifier (the default, also known as package-private), it is
visible only within its own package (packages are named groups of related classes — you will
learn about them in a later lesson.)
At the member level, you can also use the public modifier or no modifier (package-private) just
as with top-level classes, and with the same meaning. For members, there are two additional
access modifiers: private and protected. The private modifier specifies that the member can
only be accessed in its own class. The protected modifier specifies that the member can only be
accessed within its own package (as with package-private) and, in addition, by a subclass of its
class in another package.
The following table shows the access to members permitted by each modifier.
Access Levels
Modifier Class Package Subclass World
public

Y

Y

Y

Y

protected

Y

Y

Y

N

no modifier Y

Y

N

N

private

N

N

N

Y

The first data column indicates whether the class itself has access to the member defined by the
access level. As you can see, a class always has access to its own members. The second column
indicates whether classes in the same package as the class (regardless of their parentage) have
access to the member. The third column indicates whether subclasses of the class declared
outside this package have access to the member. The fourth column indicates whether all classes
have access to the member.
Access levels affect you in two ways. First, when you use classes that come from another source,
such as the classes in the Java platform, access levels determine which members of those classes
your own classes can use. Second, when you write a class, you need to decide what access level
every member variable and every method in your class should have.

Let's look at a collection of classes and see how access levels affect visibility. The following
figure shows the four classes in this example and how they are related.

Classes and Packages of the Example Used to Illustrate Access Levels
The following table shows where the members of the Alpha class are visible for each of the
access modifiers that can be applied to them.
Visibility
Modifier Alpha Beta Alphasub Gamma
public

Y

Y

Y

Y

protected

Y

Y

Y

N

no modifier Y

Y

N

N

private

N

N

N

Y

Tips on Choosing an Access Level:
If other programmers use your class, you want to ensure that errors from misuse cannot happen.
Access levels can help you do this.
Use the most restrictive access level that makes sense for a particular member. Use
private unless you have a good reason not to.
Avoid public fields except for constants. (Many of the examples in the tutorial use
public fields. This may help to illustrate some points concisely, but is not recommended
for production code.) Public fields tend to link you to a particular implementation and
limit your flexibility in changing your code.

Understanding Instance and Class Members
In this section, we discuss the use of the static keyword to create fields and methods that
belong to the class, rather than to an instance of the class.

Class Variables
When a number of objects are created from the same class blueprint, they each have their own
distinct copies of instance variables. In the case of the Bicycle class, the instance variables are
cadence, gear, and speed. Each Bicycle object has its own values for these variables, stored in
different memory locations.
Sometimes, you want to have variables that are common to all objects. This is accomplished with
the static modifier. Fields that have the static modifier in their declaration are called static
fields or class variables. They are associated with the class, rather than with any object. Every
instance of the class shares a class variable, which is in one fixed location in memory. Any
object can change the value of a class variable, but class variables can also be manipulated
without creating an instance of the class.
For example, suppose you want to create a number of Bicycle objects and assign each a serial
number, beginning with 1 for the first object. This ID number is unique to each object and is
therefore an instance variable. At the same time, you need a field to keep track of how many
Bicycle objects have been created so that you know what ID to assign to the next one. Such a
field is not related to any individual object, but to the class as a whole. For this you need a class
variable, numberOfBicycles, as follows:
public class Bicycle {
private int cadence;
private int gear;
private int speed;
// add an instance variable for the object ID
private int id;
// add a class variable for the
// number of Bicycle objects instantiated
private static int numberOfBicycles = 0;
...
}

Class variables are referenced by the class name itself, as in
Bicycle.numberOfBicycles

This makes it clear that they are class variables.

Note: You can also refer to static fields with an object reference like
myBike.numberOfBicycles

but this is discouraged because it does not make it clear that they are class variables.

You can use the Bicycle constructor to set the id instance variable and increment the
numberOfBicycles class variable:
private
private
private
private
private

int cadence;
int gear;
int speed;
int id;
static int numberOfBicycles = 0;

public Bicycle(int startCadence, int startSpeed, int startGear){
gear = startGear;
cadence = startCadence;
speed = startSpeed;
// increment number of Bicycles
// and assign ID number
id = ++numberOfBicycles;
}
// new method to return the ID instance variable
public int getID() {
return id;
}
...
}

Class Methods
The Java programming language supports static methods as well as static variables. Static
methods, which have the static modifier in their declarations, should be invoked with the class
name, without the need for creating an instance of the class, as in
ClassName.methodName(args)

Note: You can also refer to static methods with an object reference like
instanceName.methodName(args)

but this is discouraged because it does not make it clear that they are class methods.

A common use for static methods is to access static fields. For example, we could add a static
method to the Bicycle class to access the numberOfBicycles static field:
public static int getNumberOfBicycles() {

return numberOfBicycles;
}

Not all combinations of instance and class variables and methods are allowed:
Instance methods can access instance variables and instance methods directly.
Instance methods can access class variables and class methods directly.
Class methods can access class variables and class methods directly.
Class methods cannot access instance variables or instance methods directly—they must
use an object reference. Also, class methods cannot use the this keyword as there is no
instance for this to refer to.

Constants
The static modifier, in combination with the final modifier, is also used to define constants.
The final modifier indicates that the value of this field cannot change.
For example, the following variable declaration defines a constant named PI, whose value is an
approximation of pi (the ratio of the circumference of a circle to its diameter):
static final double PI = 3.141592653589793;

Constants defined in this way cannot be reassigned, and it is a compile-time error if your
program tries to do so. By convention, the names of constant values are spelled in uppercase
letters. If the name is composed of more than one word, the words are separated by an
underscore (_).

Note: If a primitive type or a string is defined as a constant and the value is known at compile
time, the compiler replaces the constant name everywhere in the code with its value. This is
called a compile-time constant. If the value of the constant in the outside world changes (for
example, if it is legislated that pi actually should be 3.975), you will need to recompile any
classes that use this constant to get the current value.

The Bicycle Class
After all the modifications made in this section, the Bicycle class is now:
private int cadence;
private int gear;
private int speed;
private int id;

private static int numberOfBicycles = 0;
public Bicycle(int startCadence,
int startSpeed,
int startGear){
gear = startGear;
speed = startSpeed;
id = ++numberOfBicycles;
}
public int getID() {
return id;
}
public static int getNumberOfBicycles() {
return numberOfBicycles;
}
public int getCadence(){
return cadence;
}
public void setCadence(int newValue){
cadence = newValue;
}
public int getGear(){
return gear;
}
public void setGear(int newValue){
gear = newValue;
}
public int getSpeed(){
return speed;
}
public void applyBrake(int decrement){
speed -= decrement;
}
public void speedUp(int increment){
speed += increment;
}
}

Initializing Fields
As you have seen, you can often provide an initial value for a field in its declaration:
public class BedAndBreakfast {
// initialize to 10
public static int capacity = 10;
// initialize to false
private boolean full = false;
}

This works well when the initialization value is available and the initialization can be put on one
line. However, this form of initialization has limitations because of its simplicity. If initialization
requires some logic (for example, error handling or a for loop to fill a complex array), simple
assignment is inadequate. Instance variables can be initialized in constructors, where error
handling or other logic can be used. To provide the same capability for class variables, the Java
programming language includes static initialization blocks.

Note: It is not necessary to declare fields at the beginning of the class definition, although this is
the most common practice. It is only necessary that they be declared and initialized before they
are used.

Static Initialization Blocks
A static initialization block is a normal block of code enclosed in braces, { }, and preceded by
the static keyword. Here is an example:
static {
// whatever code is needed for initialization goes here
}

A class can have any number of static initialization blocks, and they can appear anywhere in the
class body. The runtime system guarantees that static initialization blocks are called in the order
that they appear in the source code.
There is an alternative to static blocks — you can write a private static method:
class Whatever {
public static varType myVar = initializeClassVariable();
private static varType initializeClassVariable() {
// initialization code goes here
}

}

The advantage of private static methods is that they can be reused later if you need to reinitialize
the class variable.

Initializing Instance Members
Normally, you would put code to initialize an instance variable in a constructor. There are two
alternatives to using a constructor to initialize instance variables: initializer blocks and final
methods.
Initializer blocks for instance variables look just like static initializer blocks, but without the
static keyword:
{
// whatever code is needed for initialization goes here
}

The Java compiler copies initializer blocks into every constructor. Therefore, this approach can
be used to share a block of code between multiple constructors.
A final method cannot be overridden in a subclass. This is discussed in the lesson on interfaces
and inheritance. Here is an example of using a final method for initializing an instance variable:
class Whatever {
private varType myVar = initializeInstanceVariable();
protected final varType initializeInstanceVariable() {
// initialization code goes here
}
}

This is especially useful if subclasses might want to reuse the initialization method. The method
is final because calling non-final methods during instance initialization can cause problems.

Summary of Creating and Using Classes and
Objects
A class declaration names the class and encloses the class body between braces. The class name
can be preceded by modifiers. The class body contains fields, methods, and constructors for the
class. A class uses fields to contain state information and uses methods to implement behavior.
Constructors that initialize a new instance of a class use the name of the class and look like
methods without a return type.
You control access to classes and members in the same way: by using an access modifier such as
public in their declaration.
You specify a class variable or a class method by using the static keyword in the member's
declaration. A member that is not declared as static is implicitly an instance member. Class
variables are shared by all instances of a class and can be accessed through the class name as
well as an instance reference. Instances of a class get their own copy of each instance variable,
which must be accessed through an instance reference.
You create an object from a class by using the new operator and a constructor. The new operator
returns a reference to the object that was created. You can assign the reference to a variable or
use it directly.
Instance variables and methods that are accessible to code outside of the class that they are
declared in can be referred to by using a qualified name. The qualified name of an instance
variable looks like this:
objectReference.variableName

The qualified name of a method looks like this:
objectReference.methodName(argumentList)

or:
objectReference.methodName()

The garbage collector automatically cleans up unused objects. An object is unused if the program
holds no more references to it. You can explicitly drop a reference by setting the variable holding
the reference to null.

Nested Classes
The Java programming language allows you to define a class within another class. Such a class is
called a nested class and is illustrated here:
class OuterClass {
...
class NestedClass {
...
}
}

Terminology: Nested classes are divided into two categories: static and non-static. Nested
classes that are declared static are called static nested classes. Non-static nested classes are
called inner classes.
class OuterClass {
...
static class StaticNestedClass {
...
}
class InnerClass {
...
}
}

A nested class is a member of its enclosing class. Non-static nested classes (inner classes) have
access to other members of the enclosing class, even if they are declared private. Static nested
classes do not have access to other members of the enclosing class. As a member of the
OuterClass, a nested class can be declared private, public, protected, or package private.
(Recall that outer classes can only be declared public or package private.)

Why Use Nested Classes?
Compelling reasons for using nested classes include the following:
It is a way of logically grouping classes that are only used in one place: If a class is
useful to only one other class, then it is logical to embed it in that class and keep the two
together. Nesting such "helper classes" makes their package more streamlined.
It increases encapsulation: Consider two top-level classes, A and B, where B needs
access to members of A that would otherwise be declared private. By hiding class B
within class A, A's members can be declared private and B can access them. In addition,
B itself can be hidden from the outside world.
It can lead to more readable and maintainable code: Nesting small classes within toplevel classes places the code closer to where it is used.

Static Nested Classes

As with class methods and variables, a static nested class is associated with its outer class. And
like static class methods, a static nested class cannot refer directly to instance variables or
methods defined in its enclosing class: it can use them only through an object reference.

Note: A static nested class interacts with the instance members of its outer class (and other
classes) just like any other top-level class. In effect, a static nested class is behaviorally a toplevel class that has been nested in another top-level class for packaging convenience.

Static nested classes are accessed using the enclosing class name:
OuterClass.StaticNestedClass

For example, to create an object for the static nested class, use this syntax:
OuterClass.StaticNestedClass nestedObject =
new OuterClass.StaticNestedClass();

Inner Classes
As with instance methods and variables, an inner class is associated with an instance of its
enclosing class and has direct access to that object's methods and fields. Also, because an inner
class is associated with an instance, it cannot define any static members itself.
Objects that are instances of an inner class exist within an instance of the outer class. Consider
the following classes:
class OuterClass {
...
class InnerClass {
...
}
}

An instance of InnerClass can exist only within an instance of OuterClass and has direct
access to the methods and fields of its enclosing instance.
To instantiate an inner class, you must first instantiate the outer class. Then, create the inner
object within the outer object with this syntax:
OuterClass.InnerClass innerObject = outerObject.new InnerClass();

There are two special kinds of inner classes: local classes and anonymous classes.

Shadowing

If a declaration of a type (such as a member variable or a parameter name) in a particular scope
(such as an inner class or a method definition) has the same name as another declaration in the
enclosing scope, then the declaration shadows the declaration of the enclosing scope. You cannot
refer to a shadowed declaration by its name alone. The following example, ShadowTest,
demonstrates this:
public class ShadowTest {
public int x = 0;
class FirstLevel {
public int x = 1;
void methodInFirstLevel(int x) {
System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
}
}
public static void main(String... args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}

The following is the output of this example:
x = 23
this.x = 1
ShadowTest.this.x = 0

This example defines three variables named x: the member variable of the class ShadowTest, the
member variable of the inner class FirstLevel, and the parameter in the method
methodInFirstLevel. The variable x defined as a parameter of the method
methodInFirstLevel shadows the variable of the inner class FirstLevel. Consequently, when
you use the variable x in the method methodInFirstLevel, it refers to the method parameter. To
refer to the member variable of the inner class FirstLevel, use the keyword this to represent
the enclosing scope:

Refer to member variables that enclose larger scopes by the class name to which they belong.
For example, the following statement accesses the member variable of the class ShadowTest
from the method methodInFirstLevel:
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);

Inner Class Example
To see an inner class in use, first consider an array. In the following example, you create an
array, fill it with integer values, and then output only values of even indices of the array in
ascending order.
The DataStructure class that follows consists of:
The DataStructure outer class, which includes methods to add an integer onto the array
and print out values of even indices of the array.
The InnerEvenIterator inner class, which is similar to a standard Java iterator.
Iterators are used to step through a data structure and typically have methods to test for
the last element, retrieve the current element, and move to the next element.
A main method that instantiates a DataStructure object (ds) and uses it to fill the
arrayOfInts array with integer values (0, 1, 2, 3, and so on), then calls a printEven
method to print out values of even indices of arrayOfInts.
public class DataStructure {
// create an array
private final static int SIZE = 15;
private int[] arrayOfInts = new int[SIZE];
public DataStructure() {
// fill the array with ascending integer values
for (int i = 0; i < SIZE; i++) {
arrayOfInts[i] = i;
}
}
public void printEven() {
// print out values of even indices of the array
InnerEvenIterator iterator = this.new InnerEvenIterator();
while (iterator.hasNext()) {
System.out.println(iterator.getNext() + " ");
}
}
// inner class implements the Iterator pattern
private class InnerEvenIterator {
// start stepping through the array from the beginning
private int next = 0;
public boolean hasNext() {
// check if a current element is the last in the array
return (next <= SIZE - 1);
}
public int getNext() {
// record a value of an even index of the array
int retValue = arrayOfInts[next];

//get the next even element
next += 2;
return retValue;
}
}
public static void main(String s[]) {
// fill the array with integer values and print out only
// values of even indices
DataStructure ds = new DataStructure();
ds.printEven();
}
}

The output is:
0 2 4 6 8 10 12 14

Note that the InnerEvenIterator class refers directly to the arrayOfInts instance variable of
the DataStructure object.
You can use inner classes to implement helper classes such as the one shown in the preceeding
example. To handle user-interface events, you must know how to use inner classes, because the
event-handling mechanism makes extensive use of them.

Local and Anonymous Classes
There are two additional types of inner classes. You can declare an inner class within the body of
a method. These classes are known as local classes. You can also declare an inner class within
the body of a method without naming the class. These classes are known as anonymous classes.

Modifiers
You can use the same modifiers for inner classes that you use for other members of the outer
class. For example, you can use the access specifiers private, public, and protected to
restrict access to inner classes, just as you use them to restrict access do to other class members.

Local Classes
Local classes are classes that are defined in a block, which is a group of zero or more statements
between balanced braces. You typically find local classes defined in the body of a method.
This section covers the following topics:
Declaring Local Classes
Accessing Members of an Enclosing Class
o Shadowing and Local Classes
Local Classes Are Similar To Inner Classes

Declaring Local Classes
You can define a local class inside any block (see Expressions, Statements, and Blocks for more
information). For example, you can define a local class in a method body, a for loop, or an if
clause.
The following example, LocalClassExample, validates two phone numbers. It defines the local
class PhoneNumber in the method validatePhoneNumber:
public class LocalClassExample {
static String regularExpression = "[^0-9]";
public static void validatePhoneNumber(
String phoneNumber1, String phoneNumber2) {
final int numberLength = 10;
// Valid in Java SE 8 and later:
// int numberLength = 10;
class PhoneNumber {
String formattedPhoneNumber = null;
PhoneNumber(String phoneNumber) {
// numberLength = 7;
String currentNumber = phoneNumber.replaceAll(
regularExpression, "");
if (currentNumber.length() == numberLength)
formattedPhoneNumber = currentNumber;
else
formattedPhoneNumber = null;
}
public String getNumber() {

return formattedPhoneNumber;
}
//
//
//
//

public void printOriginalNumbers() {
System.out.println("Original numbers are " + phoneNumber1 +
" and " + phoneNumber2);
}
}
PhoneNumber myNumber1 = new PhoneNumber(phoneNumber1);
PhoneNumber myNumber2 = new PhoneNumber(phoneNumber2);

//

myNumber1.printOriginalNumbers();
if (myNumber1.getNumber() == null)
System.out.println("First number is invalid");
else
System.out.println("First number is " + myNumber1.getNumber());
if (myNumber2.getNumber() == null)
System.out.println("Second number is invalid");
else
System.out.println("Second number is " + myNumber2.getNumber());
}
validatePhoneNumber("603-555-0123", "555-0123");
}

}

The example validates a phone number by first removing all characters from the phone number
except the digits 0 through 9. After, it checks whether the phone number contains exactly ten
digits (the length of a phone number in North America). This example prints the following:
First number is 6035550123
Second number is invalid

Accessing Members of an Enclosing Class
A local class has access to the members of its enclosing class. In the previous example, the
PhoneNumber constructor accesses the member LocalClassExample.regularExpression.
In addition, a local class has access to local variables. However, a local class can only access
local variables that are declared final. For example, the PhoneNumber constructor can access the
local variable numberLength because it is declared final.

However, starting in Java SE 8, a local class can access local variables and parameters of the
enclosing block that are final or effectively final. A variable or parameter whose value is never
changed after it is initialized is effectively final. For example, suppose that the variable
numberLength is not declared final, and you add the highlighted assignment statement in the
PhoneNumber constructor:
PhoneNumber(String phoneNumber) {
numberLength = 7;
String currentNumber = phoneNumber.replaceAll(
regularExpression, "");
formattedPhoneNumber = currentNumber;
else
formattedPhoneNumber = null;
}

Because of this assignment statement, the variable numberLength is not effectively final
anymore. As a result, the Java compiler generates an error message similar to "local variables
referenced from an inner class must be final or effectively final" where the inner class
PhoneNumber tries to access the numberLength variable:

Starting in Java SE 8, if you declare the local class in a method, it can access the method's
parameters. For example, you can define the following method in the PhoneNumber local class:
public void printOriginalNumbers() {
System.out.println("Original numbers are " + phoneNumber1 +
" and " + phoneNumber2);
}

The method printOriginalNumbers accesses the parameters phoneNumber1 and phoneNumber2
of the method validatePhoneNumber.

Shadowing and Local Classes
Declarations of a type (such as a variable) in a local class shadow declarations in the enclosing
scope that have the same name. See Shadowing for more information.

Local Classes Are Similar To Inner Classes
Local classes are similar to inner classes because they cannot define or declare any static
members. Local classes in static methods, such as the class PhoneNumber, which is defined in the
static method vaidatePhoneNumber, can only refer to static members of the enclosing class. For
example, if you do not define the member variable regularExpression as static, then the Java
compiler generates an error similar to "non-static variable regularExpression cannot be
referenced from a static context."

Local classes are non-static because they have access to instance members of the enclosing
block. Consequently, they cannot contain most kinds of static declarations.
You cannot declare an interface inside a block; interfaces are inherently static. For example, the
following code excerpt does not compile because the interface HelloThere is defined inside the
body of the method greetInEnglish:
public void greetInEnglish() {
interface HelloThere {
public void greet();
}
class EnglishHelloThere implements HelloThere {
public void greet() {
System.out.println("Hello " + name);
}
}
HelloThere myGreeting = new EnglishHelloThere();
myGreeting.greet();
}

You cannot declare static initializers or member interfaces in a local class. The following code
excerpt does not compile because the method EnglishGoodbye.sayGoodbye is declared static.
The compiler generates an error similar to "modifier 'static' is only allowed in constant variable
declaration" when it encounters this method definition:
public void sayGoodbyeInEnglish() {
class EnglishGoodbye {
public static void sayGoodbye() {
System.out.println("Bye bye");
}
}
EnglishGoodbye.sayGoodbye();
}

A local class can have static members provided that they are constant variables. (A constant
variable is a variable of primitive type or type String that is declared final and initialized with a
compile-time constant expression. A compile-time constant expression is typically a string or an
arithmetic expression that can be evaluated at compile time. See Understanding Instance and
Class Members for more information.) The following code excerpt compiles because the static
member EnglishGoodbye.farewell is a constant variable:
public void sayGoodbyeInEnglish() {
class EnglishGoodbye {
public static final String farewell = "Bye bye";
public void sayGoodbye() {
System.out.println(farewell);
}
}
EnglishGoodbye myEnglishGoodbye = new EnglishGoodbye();
myEnglishGoodbye.sayGoodbye();
}

Anonymous Classes
Anonymous classes enable you to make your code more concise. They enable you to declare and
instantiate a class at the same time. They are like local classes except that they do not have a
name. Use them if you need to use a local class only once.
Declaring Anonymous Classes
Syntax of Anonymous Classes
Accessing Local Variables of the Enclosing Scope, and Declaring and Accessing
Members of the Anonymous Class
Examples of Anonymous Classes

Declaring Anonymous Classes
While local classes are class declarations, anonymous classes are expressions, which means that
you define the class in another expression. The following example,
HelloWorldAnonymousClasses, uses anonymous classes in the initialization statements of the
local variables frenchGreeting and spanishGreeting, but uses a local class for the
initialization of the variable englishGreeting:
public class HelloWorldAnonymousClasses {
interface HelloWorld {
public void greet();
public void greetSomeone(String someone);
}
public void sayHello() {
class EnglishGreeting implements HelloWorld {
String name = "world";
greetSomeone("world");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hello " + name);
}
}
HelloWorld englishGreeting = new EnglishGreeting();
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
greetSomeone("tout le monde");
}

name = someone;
System.out.println("Salut " + name);
}
};
HelloWorld spanishGreeting = new HelloWorld() {
String name = "mundo";
greetSomeone("mundo");
}
name = someone;
System.out.println("Hola, " + name);
}
};
englishGreeting.greet();
frenchGreeting.greetSomeone("Fred");
spanishGreeting.greet();
}
HelloWorldAnonymousClasses myApp =
new HelloWorldAnonymousClasses();
myApp.sayHello();
}
}

Syntax of Anonymous Classes
As mentioned previously, an anonymous class is an expression. The syntax of an anonymous
class expression is like the invocation of a constructor, except that there is a class definition
contained in a block of code.
Consider the instantiation of the frenchGreeting object:
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
greetSomeone("tout le monde");
}
name = someone;
System.out.println("Salut " + name);
}
};

The anonymous class expression consists of the following:
The new operator
The name of an interface to implement or a class to extend. In this example, the
anonymous class is implementing the interface HelloWorld.

Parentheses that contain the arguments to a constructor, just like a normal class instance
creation expression. Note: When you implement an interface, there is no constructor, so
you use an empty pair of parentheses, as in this example.
A body, which is a class declaration body. More specifically, in the body, method
declarations are allowed but statements are not.
Because an anonymous class definition is an expression, it must be part of a statement. In this
example, the anonymous class expression is part of the statement that instantiates the
frenchGreeting object. (This explains why there is a semicolon after the closing brace.)

Accessing Local Variables of the Enclosing Scope, and
Declaring and Accessing Members of the Anonymous Class
Anonymous classes have the same access to local variables of the enclosing scope as local
classes:
An anonymous class has access to the members of its enclosing class.
An anonymous class cannot access local variables in its enclosing scope that are not
declared as final or effectively final.
Like a nested class, a declaration of a type (such as a variable) in an anonymous class
shadows any other declarations in the enclosing scope that have the same name. See
Shadowing for more information.
Anonymous classes also have the same restrictions as local classes with respect to their
members:
You cannot declare static initializers or member interfaces in an anonymous class.
An anonymous class can have static members provided that they are constant variables.
Note that you can declare the following in anonymous classes:
Fields
Extra methods (even if they do not implement any methods of the supertype)
Instance initializers
Local classes
However, you cannot declare constructors in an anonymous class.

Examples of Anonymous Classes
Anonymous classes are often used in graphical user interface (GUI) applications.
Consider the JavaFX example HelloWorld.java (from the section Hello World, JavaFX Style
from Getting Started with JavaFX). This sample creates a frame that contains a Say 'Hello
World' button. The anonymous class expression is highlighted:

import
import
import
import
import
import

javafx.event.ActionEvent;
javafx.event.EventHandler;
javafx.scene.Scene;
javafx.scene.control.Button;
javafx.scene.layout.StackPane;
javafx.stage.Stage;

public class HelloWorld extends Application {
launch(args);
}
@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("Hello World!");
Button btn = new Button();
btn.setText("Say 'Hello World'");
btn.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
System.out.println("Hello World!");
}
});
StackPane root = new StackPane();
root.getChildren().add(btn);
primaryStage.setScene(new Scene(root, 300, 250));
primaryStage.show();
}
}

In this example, the method invocation btn.setOnAction specifies what happens when you
select the Say 'Hello World' button. This method requires an object of type
EventHandler<ActionEvent>. The EventHandler<ActionEvent> interface contains only one
method, handle. Instead of implementing this method with a new class, the example uses an
anonymous class expression. Notice that this expression is the argument passed to the
btn.setOnAction method.
Because the EventHandler<ActionEvent> interface contains only one method, you can use a
lambda expression instead of an anonymous class expression. See the section Lambda
Expressions for more information.
Anonymous classes are ideal for implementing an interface that contains two or more methods.
The following JavaFX example is from the section Customization of UI Controls. The
highlighted code creates a text field that only accepts numeric values. It redefines the default
implementation of the TextField class with an anonymous class by overriding the replaceText
and replaceSelection methods inherited from the TextInputControl class.
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;

import
import
import
import
import
import
import

javafx.geometry.Insets;
javafx.scene.Group;
javafx.scene.Scene;
javafx.scene.control.*;
javafx.scene.layout.GridPane;
javafx.scene.layout.HBox;
javafx.stage.Stage;

public class CustomTextFieldSample extends Application {
final static Label label = new Label();
@Override
public void start(Stage stage) {
Group root = new Group();
Scene scene = new Scene(root, 300, 150);
stage.setScene(scene);
stage.setTitle("Text Field Sample");
GridPane grid = new GridPane();
grid.setPadding(new Insets(10, 10, 10, 10));
grid.setVgap(5);
grid.setHgap(5);
scene.setRoot(grid);
final Label dollar = new Label("$");
GridPane.setConstraints(dollar, 0, 0);
grid.getChildren().add(dollar);
final TextField sum = new TextField() {
@Override
public void replaceText(int start, int end, String text) {
if (!text.matches("[a-z, A-Z]")) {
super.replaceText(start, end, text);
}
label.setText("Enter a numeric value");
}
@Override
public void replaceSelection(String text) {
if (!text.matches("[a-z, A-Z]")) {
super.replaceSelection(text);
}
}
};
sum.setPromptText("Enter the total");
sum.setPrefColumnCount(10);
GridPane.setConstraints(sum, 1, 0);
grid.getChildren().add(sum);
Button submit = new Button("Submit");
GridPane.setConstraints(submit, 2, 0);
grid.getChildren().add(submit);
submit.setOnAction(new EventHandler<ActionEvent>() {
@Override

public void handle(ActionEvent e) {
label.setText(null);
}
});
GridPane.setConstraints(label, 0, 1);
GridPane.setColumnSpan(label, 3);
grid.getChildren().add(label);
scene.setRoot(grid);
stage.show();
}
launch(args);
}
}

Lambda Expressions
Beta Draft 2013-10-15
This section was updated to reflect features and conventions of the upcoming Java SE 8
release. You can download the current JDK 8 snapshot from java.net.

One issue with anonymous classes is that if the implementation of your anonymous class is very
simple, such as an interface that contains only one method, then the syntax of anonymous classes
may seem unwieldy and unclear. In these cases, you're usually trying to pass functionality as an
argument to another method, such as what action should be taken when someone clicks a button.
Lambda expressions enable you to do this, to treat functionality as method argument, or code as
data.
The previous section, Anonymous Classes, shows you how to implement a base class without
giving it a name. Although this is often more concise than a named class, for classes with only
one method, even an anonymous class seems a bit excessive and cumbersome. Lambda
expressions let you express instances of single-method classes more compactly.
Ideal Use Case for Lambda Expressions
o Approach 1: Create Methods That Search for Members That Match One
Characteristic
o Approach 2: Create More Generalized Search Methods
o Approach 3: Specify Search Criteria Code in a Local Class

o
o
o
o
o
o

Approach 4: Specify Search Criteria Code in an Anonymous Class
Approach 5: Specify Search Criteria Code with a Lambda Expression
Approach 6: Use Standard Functional Interfaces with Lambda Expressions
Approach 7: Use Lambda Expressions Throughout Your Application
Approach 8: Use Generics More Extensively
Approach 9: Use Aggregate Operations That Accept Lambda Expressions as
Parameters
Lambda Expressions in GUI Applications
Syntax of Lambda Expressions
Accessing Local Variables of the Enclosing Scope
Target Typing
o Target Types and Method Arguments

Ideal Use Case for Lambda Expressions
Suppose that you are creating a social networking application. You want to create a feature that
enables an administrator to perform any kind of action, such as sending a message, on members
of the social networking application that satisfy certain criteria. The following table describes
this use case in detail:
Field
Name

Description
Perform action on selected members

Primary Actor

Administrator

Preconditions

Administrator is logged in to the system.

Postconditions

Action is performed only on members that fit the specified criteria.

Main Success
Scenario

1. Administrator specifies criteria of members on which to perform a
certain action.
2. Administrator specifies an action to perform on those selected
members.
3. Administrator selects the Submit button.
4. The system finds all members that match the specified criteria.
5. The system performs the specified action on all matching members.

Extensions

1a. Administrator has an option to preview those members who match the
specified criteria before he or she specifies the action to be performed or
before selecting the Submit button.

Frequency of
Occurrence

Many times during the day.

Suppose that members of this social networking application are represented by the following
Person class:
public class Person {

public enum Sex {
MALE, FEMALE
}
String name;
LocalDate birthday;
Sex gender;
String emailAddress;
public int getAge() {
// ...
}
public void printPerson() {
// ...
}
}

Suppose that the members of your social networking application are stored in a List<Person>
instance.
This section begins with a naive approach to this use case. It improves upon this approach with
local and anonymous classes, and then finishes with an efficient and concise approach using
lambda expressions. Find the code excerpts described in this section in the example RosterTest.

Approach 1: Create Methods That Search for Members That Match One
Characteristic
One simplistic approach is to create several methods; each method searches for members that
match one characteristic, such as gender or age. The following method prints members that are
older than a specified age:
public static void printPersonsOlderThan(List<Person> roster, int age) {
for (Person p : roster) {
if (p.getAge() >= age) {
p.printPerson();
}
}
}

Note: A List is an ordered Collection. A collection is an object that groups multiple elements
into a single unit. Collections are used to store, retrieve, manipulate, and communicate aggregate
data. For more information about collections, see the Collections trail.
This approach can potentially make your application brittle: Suppose that you upgrade your
application and change the structure of the Person class such that it contains different member
variables; perhaps the class records and measures ages with a different data type or algorithm.
You would have to rewrite a lot of your API to accommodate this change. In addition, this

approach is unnecessarily restrictive; what if you wanted to print members younger than a certain
age, for example?

Approach 2: Create More Generalized Search Methods
The following method is more generic than printPersonsOlderThan; it prints members within
a specified range of ages:
public static void printPersonsWithinAgeRange(
List<Person> roster, int low, int high) {
if (low >= p.getAge() && p.getAge() < high) {
p.printPerson();
}
}
}

What if you want to print members of a specified sex, or a combination of a specified gender and
age range? What if you decide to change the Person class and add other attributes such as
relationship status or geographical location? Although this method is more generic than
printPersonsOlderThan, trying to create a separate method for each possible search query can
still lead to brittle code. You can instead separate the code that specifies the criteria for which
you want to search in a different class.

Approach 3: Specify Search Criteria Code in a Local Class
The following method does not contain any code that specifies search criteria:
public static void printPersons(
List<Person> roster, CheckPerson tester) {
if (tester.test(p)) {
p.printPerson();
}
}
}

To specify the search criteria, you implement the CheckPerson interface:
interface CheckPerson {
boolean test(Person p);
}

The following class filters members that are eligible for Selective Service in the United States:
those who are male and between the ages of 18 and 25:
class CheckPersonEligibleForSelectiveService implements CheckPerson {
public boolean test(Person p) {
return p.gender == Person.Sex.MALE &&
p.getAge() >= 18 &&

p.getAge() <= 25;
}
}

To use this class, you create a new instance of it and invoke the printPersons method:
printPersons(
roster, new CheckPersonEligibleForSelectiveService());

Although this approach is less brittle—you don't have to rewrite methods if you change the
structure of the Person—you still have additional code: a new interface and a local class for each
search you plan to perform in your application. Because
CheckPersonEligibleForSelectiveService implements an interface, you can use an
anonymous class instead of a local class and bypass the need to declare a new class for each
search.

Approach 4: Specify Search Criteria Code in an Anonymous Class
One of the arguments of the following invocation of the method printPersons is an anonymous
class that filters members that are eligible for Selective Service in the United States: those who
are male and between the ages of 18 and 25:
printPersons(
roster,
new CheckPerson() {
public boolean test(Person p) {
return p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25;
}
}
);

This approach reduces the amount of code required, because you don't have to create a new class
for each search that you want to perform. However, the syntax of anonymous classes is bulky
considering that the CheckPerson interface contains only one method. In this case, you can use a
lambda expression instead of an anonymous class, as described in the next section.

Approach 5: Specify Search Criteria Code with a Lambda Expression
The CheckPerson interface is a functional interface. A functional interface is any interface that
contains only one method. Because a functional interface contains only one method, you can
omit the name of that method when you implement it. To do this, instead of using an anonymous
class expression, you use a lambda expression, which is highlighted in the following method
invocation:
printPersons(
roster,
(Person p) -> p.getGender() == Person.Sex.MALE

&& p.getAge() >= 18
&& p.getAge() <= 25
);

See Syntax of Lambda Expressions for information about how to define lambda expressions.
You can use a standard functional interface in place of the interface CheckPerson, which
reduces even further the amount of code required.

Approach 6: Use Standard Functional Interfaces with Lambda Expressions
Reconsider the CheckPerson interface:
interface CheckPerson {
boolean test(Person p);
}

This is a very simple interface. It's a functional interface because it contains only one method
without an implementation. This method takes one parameter and returns a boolean value. The
method is so simple that it might not be worth it to define one in your application. Consequently,
the JDK defines several standard functional interfaces, which you can find in the package
java.util.function.
For example, you can use the Predicate<T> interface in place of CheckPerson. This interface
contains the method boolean test(T t):
interface Predicate<T> {
boolean test(T t);
}

The interface Predicate<T> is an example of a generic interface. (For more information about
generics, see the Generics (Updated) lesson.) Generic types (such as generic interfaces) specify
one or more type parameters within angle brackets (<>). This interface contains only one type
parameter, T. When you declare or instantiate a generic type with actual type arguments, you
have a parameterized type. For example, the parameterized type Predicate<Person> is the
following:
interface Predicate<Person> {
boolean test(Person t);
}

This parameterized type contains a method that has the same return type and parameters as
CheckPerson.boolean test(Person p). Consequently, you can use Predicate<T> in place of
CheckPerson as the following method demonstrates:
public static void printPersonsWithPredicate(
List<Person> roster, Predicate<Person> tester) {

p.printPerson();
}
}
}

As a result, the following method invocation is the same as when you invoked printPersons in
Approach 3: Specify Search Criteria Code in a Local Class to obtain members who are eligible
for Selective Service:
printPersonsWithPredicate(
roster,
p -> p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25
);

This is not the only possible place in this method to use a lambda expression. The following
approach suggests other ways to use lambda expressions.

Approach 7: Use Lambda Expressions Throughout Your Application
Reconsider the method printPersonsWithPredicate to see where else you could use lambda
expressions:
public static void printPersonsWithPredicate(
List<Person> roster, Predicate<Person> tester) {
p.printPerson();
}
}
}

This method invokes the method printPerson on each Person instance. You can specify the
action performed on each Person instance with a lambda expression. Remember, to use a
lambda expression, you need to implement a functional interface. In this case, you need a
functional interface that contains a method that takes one argument (an object of type Person)
and returns void. The Consumer<T> interface contains the method void accept(T t). The
following method replaces the invocation p.printPerson() with an instance of
Consumer<Person> that invokes the method accept:
public static void processPersons(
List<Person> roster,
Predicate<Person> tester,
Consumer<Person> block) {
block.accept(p);
}
}
}

As a result, the following method invocation is the same as when you invoked printPersons in
Approach 3: Specify Search Criteria Code in a Local Class to obtain members who are eligible
for Selective Service. The lambda expression used to print members is highlighted:
processPersons(
roster,
&& p.getAge() >= 18
&& p.getAge() <= 25,
p -> p.printPerson()
);

What if you want to do more with your members' profiles than printing them out. Suppose that
you want to validate the members' profiles or retrieve their contact information? In this case, you
need a functional interface that contains a method that returns a value. The Function<T,R>
interface contains the method R apply(T t). The following method retrieves the data specified
by the parameter mapper, and then performs an action on it specified by the parameter block:
public static void processPersonsWithFunction(
List<Person> roster,
Predicate<Person> tester,
Function<Person, String> mapper,
Consumer<String> block) {
String data = mapper.apply(p);
block.accept(data);
}
}
}

The following method retrieves the email address from each member contained in roster and
then prints it:
processPersonsWithFunction(
roster,
&& p.getAge() >= 18
&& p.getAge() <= 25,
p -> p.getEmailAddress(),
email -> System.out.println(email)
);

Approach 8: Use Generics More Extensively
Reconsider the method processPersonsWithFunction. The following is a generic version of it
that accepts, as a parameter, a collection that contains elements of any data type:
public static <X, Y> void processElements(
Iterable<X> source,
Predicate<X> tester,
Function <X, Y> mapper,

Consumer<Y> block) {
for (X p : source) {
Y data = mapper.apply(p);
block.accept(data);
}
}
}

To print the e-mail address of members who are eligible for Selective Service, invoke the
processElements method as follows:
processElements(
roster,
&& p.getAge() >= 18
&& p.getAge() <= 25,
p -> p.getEmailAddress(),
);

This method invocation performs the following actions:
1. Obtains a source of objects from the collection source. In this example, it obtains a
source of Person objects from the collection roster. Notice that the collection roster,
which is a collection of type List, is also an object of type Iterable.
2. Filters objects that match the Predicate object tester. In this example, the Predicate
object is a lambda expression that specifies which members would be eligible for
Selective Service.
3. Maps each filtered object to a value as specified by the Function object mapper. In this
example, the Function object is a lambda expression that returns the e-mail address of a
member.
4. Performs an action on each mapped object as specified by the Consumer object block. In
this example, the Consumer object is a lambda expression that prints a string, which is the
e-mail address returned by the Function object.
You can replace each of these actions with an aggregate operation.

Approach 9: Use Aggregate Operations That Accept Lambda Expressions as
Parameters
The following example uses aggregate operations to print the e-mail addresses of those members
contained in the collection roster who are eligible for Selective Service:
roster
.stream()
.filter(
&& p.getAge() >= 18
&& p.getAge() <= 25)

.map(p -> p.getEmailAddress())
.forEach(email -> System.out.println(email));

The following table maps each of the operations the method processElements performs with
the corresponding aggregate operation:
processElements

Action

Aggregate Operation

Obtain a source of objects

Stream<E>stream()

Filter objects that match a Predicate
object

Stream<T>filter(Predicate<? super T>
predicate)

Map objects to another value as specified
by a Function object

<R> Stream<R>map(Function<? super T,?
extends R> mapper)

Perform an action as specified by a
Consumer object

void forEach(Consumer<? super T> action)

The operations filter, map, and forEach are aggregate operations. Aggregate operations
process elements from a stream, not directly from a collection (which is the reason why the first
method invoked in this example is stream). A stream is a sequence of elements. Unlike a
collection, it is not a data structure that stores elements. Instead, a stream carries values from a
source, such as collection, through a pipeline. A pipeline is a sequence of stream operations,
which in this example is filter- map-forEach. In addition, aggregate operations typically
accept lambda expressions as parameters, enabling you to customize how they behave.
For a more thorough discussion of aggregate operations, see the Aggregate Operations lesson.

Lambda Expressions in GUI Applications
To process events in a graphical user interface (GUI) application, such as keyboard actions,
mouse actions, and scroll actions, you typically create event handlers, which usually involves
implementing a particular interface. Often, event handler interfaces are functional interfaces;
they tend to have only one method.
In the JavaFX example HelloWorld.java (discussed in the previous section Anonymous
Classes), you can replace the highlighted anonymous class with a lambda expression in this
statement:
btn.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
System.out.println("Hello World!");
}
});

The method invocation btn.setOnAction specifies what happens when you select the button
represented by the btn object. This method requires an object of type
EventHandler<ActionEvent>. The EventHandler<ActionEvent> interface contains only one
method, void handle(T event). This interface is a functional interface, so you could use the
following highlighted lambda expression to replace it:
btn.setOnAction(
event -> System.out.println("Hello World!")
);

Syntax of Lambda Expressions
A lambda expression consists of the following:
A comma-separated list of formal parameters enclosed in parentheses. The
CheckPerson.test method contains one parameter, p, which represents an instance of
the Person class.
Note: You can omit the data type of the parameters in a lambda expression. In addition,
you can omit the parentheses if there is only one parameter. For example, the following
lambda expression is also valid:
&& p.getAge() >= 18
&& p.getAge() <= 25

The arrow token, ->
A body, which consists of a single expression or a statement block. This example uses the
following expression:
p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25

If you specify a single expression, then the Java runtime evaluates the expression and
then returns its value. Alternatively, you can use a return statement:
p -> {
return p.getGender() == Person.Sex.MALE
&& p.getAge() >= 18
&& p.getAge() <= 25;
}

A return statement is not an expression; in a lambda expression, you must enclose
statements in braces ({}). However, you do not have to enclose a void method invocation
in braces. For example, the following is a valid lambda expression:

Note that a lambda expression looks a lot like a method declaration; you can consider lambda
expressions as anonymous methods—methods without a name.
The following example, Calculator, is an example of lambda expressions that take more than
one formal parameter:
public class Calculator {
interface IntegerMath {
int operation(int a, int b);
}
public int operateBinary(int a, int b, IntegerMath op) {
return op.operation(a, b);
}
Calculator myApp = new Calculator();
IntegerMath addition = (a, b) -> a + b;
IntegerMath subtraction = (a, b) -> a - b;
System.out.println("40 + 2 = " +
myApp.operateBinary(40, 2, addition));
System.out.println("20 - 10 = " +
myApp.operateBinary(20, 10, subtraction));
}
}

The method operateBinary performs a mathematical operation on two integer operands. The
operation itself is specified by an instance of IntegerMath. The example defines two operations
with lambda expressions, addition and subtraction. The example prints the following:
40 + 2 = 42
20 - 10 = 10

Accessing Local Variables of the Enclosing Scope
Lambda expressions have the same access to local variables of the enclosing scope as local and
anonymous classes. However, unlike local and anonymous classes, lambda expressions do not
have any shadowing issues (see Shadowing for more information). Lambda expressions are
lexically scoped. This means that they do not inherit any names from a supertype or introduce a
new level of scoping. Declarations in a lambda expression are interpreted just as they are in the
enclosing environment. The following example, LambdaScopeTest, demonstrates this:
import java.util.functions.Block;
public class LambdaScopeTest {

public int x = 0;
class FirstLevel {
public int x = 1;
//
//
//
//
//

The following statement causes the compiler to generate
the error "local variables referenced from a lambda expression
must be final or effectively final" in statement A:
x = 99;

Block<Integer> myBlock = (y) ->
{
System.out.println("x = " + x); // Statement A
System.out.println("y = " + y);
System.out.println("LambdaScopeTest.this.x = " +
LambdaScopeTest.this.x);
};
myBlock.apply(x);
}
}
LambdaScopeTest st = new LambdaScopeTest();
LambdaScopeTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}

This example generates the following output:
x = 23
y = 23
this.x = 1
LambdaScopeTest.this.x = 0

If you substitute the parameter x in place of y in the declaration of the lambda expression
myBlock, then the compiler generates an error:
Block<Integer> myBlock = (y) -> {
// ...
}

The compiler generates the error "variable x is already defined in method
methodInFirstLevel(int)" because the lambda expression does not introduce a new level of
scoping. Consequently, you can directly access fields, methods, and local variables of the
enclosing scope. For example, the lambda expression directly accesses the parameter x of the

method methodInFirstLevel. To access variables in the enclosing class, use the keyword this.
In this example, this.x refers to the member variable FirstLevel.x.
However, like local and anonymous classes, a lambda expression can only access local variables
and parameters of the enclosing block that are final or effectively final. For example, suppose
that you add the following assignment statement immediately after the methodInFirstLevel
definition statement:
x = 99;
// ...
}

Because of this assignment statement, the variable FirstLevel.x is not effectively final
anymore. As a result, the Java compiler generates an error message similar to "local variables
referenced from a lambda expression must be final or effectively final" where the lambda
expression myBlock tries to access the FirstLevel.x variable:
System.out.println("x = " + x);

Target Typing
How do you determine the type of a lambda expression? Recall the lambda expression that
selected members who are male and between the ages 18 and 25 years:
&& p.getAge() >= 18
&& p.getAge() <= 25

This lambda expression was used in the following two methods:
public static void printPersons(List<Person> roster, CheckPerson
tester) in Approach 3: Specify Search Criteria Code in a Local Class
public void printPersonsWithPredicate(List<Person> roster,
Predicate<Person> tester) in Approach 6: Use Standard Functional Interfaces

with

Lambda Expressions
When the Java runtime invokes the method printPersons, it's expecting a data type of
CheckPerson, so the lambda expression is of this type. However, when the Java runtime invokes
the method printPersonsWithPredicate, it's expecting a data type of Predicate<Person>, so
the lambda expression is of this type. The data type that these methods expect is called the target
type. To determine the type of a lambda expression, the Java compiler uses the target type of the
context or situation in which the lambda expression was found. It follows that you can only use
lambda expressions in situations in which the Java compiler can determine a target type:
Variable declarations
Assignments

Return statements
Array initializers
Method or constructor arguments
Lambda expression bodies
Conditional expressions, ?:
Cast expressions

Target Types and Method Arguments
For method arguments, the Java compiler determines the target type with two other language
features: overload resolution and type argument inference.
Consider the following two functional interfaces ( java.lang.Runnable and
java.util.concurrent.Callable<V>):
public interface Runnable {
void run();
}
public interface Callable<V> {
V call();
}

The method Runnable.run does not return a value, whereas Callable<V>.call does.
Suppose that you have overloaded the method invoke as follows. (Overloaded methods are those
that have the same name and belong to the same class, but have different parameter lists or return
values. See Defining Methods for more information):
void invoke(Runnable r) {
r.run();
}
<T> T invoke(Callable<T> c) {
return c.call();
}

Which method will be invoked in the following statement?
String s = invoke(() -> "done");

The method invoke(Callable<T>) will be invoked because that method returns a value; the
method invoke(Runnable) does not. In this case, the type of the lambda expression () ->
"done" is Callable<T>.

Method References

You use lambda expressions to create anonymous methods. Sometimes, however, a lambda
expression does nothing but call an existing method. In those cases, it's often clearer to refer to
the existing method by name. Method references enable you to do this; they are compact, easyto-read lambda expressions for methods that already have a name.
Consider again the Person class discussed in the section Lambda Expressions:
public class Person {
public enum Sex {
MALE, FEMALE
}
String name;
LocalDate birthday;
Sex gender;
String emailAddress;
public int getAge() {
// ...
}
public Calendar getBirthday() {
return birthday;
}
public static int compareByAge(Person a, Person b) {
return a.birthday.compareTo(b.birthday);
}}

Suppose that the members of your social networking application are contained in an array, and
you want to sort the array by age. You could use the following code (find the code excerpts
described in this section in the example MethodReferencesTest):
Person[] rosterAsArray = roster.toArray(new Person[roster.size()]);
class PersonAgeComparator implements Comparator<Person> {
public int compare(Person a, Person b) {

return a.getBirthday().compareTo(b.getBirthday());
}
}
Arrays.sort(rosterAsArray, new PersonAgeComparator());

The method signature of this invocation of sort is the following:
static <T> void sort(T[] a, Comparator<? super T> c)

Notice that the class PersonAgeComparator is a functional interface. Therefore, you could use a
lambda expression instead of defining and then creating a new instance of a class that
implements Comparator<Person>:
Arrays.sort(rosterAsArray,
(Person a, Person b) -> {
}
);

However, this method to compare the birth dates of two Person instances already exists as
Person.compareByAge. You can invoke this method instead in the body of the lambda
expression:
Arrays.sort(rosterAsArray,
(a, b) -> Person.compareByAge(a, b)
);

Because this lambda expression invokes an existing method, you can use a method reference
instead of a lambda expression:
Arrays.sort(rosterAsArray, Person::compareByAge);

The method reference Person::compareByAge is semantically the same as the lambda
expression (a, b) -> Person.compareByAge(a, b). Each has the following characteristics:
Its formal parameter list is copied from Comparator<Person>.compare, which is
(Person, Person).
Its body calls the method Person.compareByAge.

Kinds of Method References
There are four kinds of method references:
Kind

Example

Reference to a static method

ContainingClass::staticMethodName

Reference to an instance method of a particular

ContainingObject::instanceMethodName

object
Reference to an instance method of an arbitrary
object of a particular type

ContainingType::methodName

Reference to a constructor

ClassName::new

Reference to a Static Method
The method reference Person::compareByAge is a reference to a static method.

Reference to an Instance Method of a Particular Object
The following is an example of a reference to an instance method of a particular object:
class ComparisonProvider {
public int compareByName(Person a, Person b) {
return a.getName().compareTo(b.getName());
}
public int compareByAge(Person a, Person b) {
}
}
ComparisonProvider myComparisonProvider = new ComparisonProvider();
Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);

The method reference myComparisonProvider::compareByName invokes the method
compareByName that is part of the object myComparisonProvider. The JRE infers the method
type arguments, which in this case are (Person, Person).

Reference to an Instance Method of an Arbitrary Object of a Particular Type
The following is an example of a reference to an instance method of an arbitrary object of a
particular type:
String[] stringArray = { "Barbara", "James", "Mary", "John",
"Patricia", "Robert", "Michael", "Linda" };
Arrays.sort(stringArray, String::compareToIgnoreCase);

The equivalent lambda expression for the method reference String::compareToIgnoreCase
would have the formal parameter list (String a, String b), where a and b are arbitrary
names used to better describe this example. The method reference would invoke the method
a.compareToIgnoreCase(b).

Reference to a Constructor
You can reference a constructor in the same way as a static method by using the name new. The
following method copies elements from one collection to another:

public static <T, SOURCE extends Collection<T>, DEST extends Collection<T>>
DEST transferElements(
SOURCE sourceCollection,
Supplier<DEST> collectionFactory) {
DEST result = collectionFactory.get();
for (T t : sourceCollection) {
result.add(t);
}
return result;
}

The functional interface Supplier contains one method get that takes no arguments and returns
an object. Consequently, you can invoke the method transferElements with a lambda
expression as follows:
Set<Person> rosterSetLambda =
transferElements(roster, () -> { return new HashSet<>(); });

You can use a constructor reference in place of the lambda expression as follows:
Set<Person> rosterSet = transferElements(roster, HashSet::new);

The Java compiler infers that you want to create a HashSet collection that contains elements of
type Person. Alternatively, you can specify this as follows:
Set<Person> rosterSet = transferElements(roster, HashSet<Person>::new);

When to Use Nested Classes, Local Classes,
Anonymous Classes, and Lambda
Expressions

As mentioned in the section Nested Classes, nested classes enable you to logically group classes
that are only used in one place, increase the use of encapsulation, and create more readable and
maintainable code. Local classes, anonymous classes, and lambda expressions also impart these
advantages; however, they are intended to be used for more specific situations:

Local class: Use it if you need to create more than one instance of a class, access its
constructor, or introduce a new, named type (because, for example, you need to invoke
additional methods later).
Anonymous class: Use it if you need an instance of a class or a nonfunctional interface,
fields, or additional methods.
Lambda expression:
o Use it if you are encapsulating a single unit of behavior that you want to pass to
other code. For example, you would use a lambda expression if you want a certain
action performed on each element of a collection, when a process is completed, or
when a process encounters an error.
o Use it if you need a simple instance of a functional interface and none of the
preceeding criteria apply (for example, you do not need a constructor, a named
type, fields, or additional methods).
Nested class: Use it if your requirements are similar to those of a local class, you want to
make the type more widely available, and you don't require access to local variables or
method parameters.
o Use a non-static nested class (or inner class) if you require access to an enclosing
instance's non-public fields and methods. Use a static nested class if you don't
require this access.

Questions and Exercises: Nested Classes
Questions
1. The program Problem.java doesn't compile. What do you need to do to make it
compile? Why?
2. Use the Java API documentation for the Box class (in the javax.swing package) to help
you answer the following questions.
a. What static nested class does Box define?
b. What inner class does Box define?
c. What is the superclass of Box's inner class?
d. Which of Box's nested classes can you use from any class?
e. How do you create an instance of Box's Filler class?

Exercises
1. Get the file Class1.java. Compile and run Class1. What is the output?
Check your answers.

Questions and Exercises: Enum Types
Questions

1. True or false: an Enum type can be a subclass of java.lang.String.

Exercises
1. Rewrite the class Card from the exercise in Questions and Exercises: Classes so that it
represents the rank and suit of a card with enum types.
2. Rewrite the Deck class.
Check your answers.

Questions and Exercises: Classes
Questions
1. Consider the following class:
2. public class IdentifyMyParts {
3.
public static int x = 7;
4.
public int y = 3;
5. }

a. What are the class variables?
b. What are the instance variables?
c. What is the output from the following code:
d.
e.
f.
g.
h.
i.
j.
k.
l.
m.
n.

IdentifyMyParts a = new IdentifyMyParts();
IdentifyMyParts b = new IdentifyMyParts();
a.y = 5;
b.y = 6;
a.x = 1;
b.x = 2;
System.out.println("a.y = " + a.y);
System.out.println("b.y = " + b.y);
System.out.println("a.x = " + a.x);
System.out.println("b.x = " + b.x);
System.out.println("IdentifyMyParts.x = " + IdentifyMyParts.x);

Exercises
1. Write a class whose instances represent a single playing card from a deck of cards.
Playing cards have two distinguishing properties: rank and suit. Be sure to keep your
solution as you will be asked to rewrite it in Enum Types.

Hint:
You can use the assert statement to check your assignments. You write:

assert (boolean expression to test);

If the boolean expression is false, you will get an error message. For example,
assert toString(ACE) == "Ace";

should return true, so there will be no error message.
If you use the assert statement, you must run your program with the ea flag:
java -ea YourProgram.class

2. Write a class whose instances represent a full deck of cards. You should also keep this
solution.
3. 3. Write a small program to test your deck and card classes. The program can be as
simple as creating a deck of cards and displaying its cards.
Check your answers.
S

Questions and Exercises: Objects
Questions
1. What's wrong with the following program?
2. public class SomethingIsWrong {
3.
4.
Rectangle myRect;
5.
myRect.width = 40;
6.
myRect.height = 50;
7.
System.out.println("myRect's area is " + myRect.area());
8.
}
9. }

10. The following code creates one array and one string object. How many references to
those objects exist after the code executes? Is either object eligible for garbage
collection?
11.
12.
13.
14.
15.
16.

...
String[] students = new String[10];
String studentName = "Peter Parker";
students[0] = studentName;
studentName = null;
...

17. How does a program destroy an object that it creates?

Exercises
1. Fix the program called SomethingIsWrong shown in Question 1.
2. Given the following class, called NumberHolder, write some code that creates an instance
of the class, initializes its two member variables, and then displays the value of each
member variable.
3. public class NumberHolder {
4.
public int anInt;
5.
public float aFloat;
6. }

Check your answers.

Enum Types
An enum type is a special data type that enables for a variable to be a set of predefined constants.
The variable must be equal to one of the values that have been predefined for it. Common
examples include compass directions (values of NORTH, SOUTH, EAST, and WEST) and the
days of the week.
Because they are constants, the names of an enum type's fields are in uppercase letters.
In the Java programming language, you define an enum type by using the enum keyword. For
example, you would specify a days-of-the-week enum type as:
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
THURSDAY, FRIDAY, SATURDAY
}

You should use enum types any time you need to represent a fixed set of constants. That includes
natural enum types such as the planets in our solar system and data sets where you know all
possible values at compile time—for example, the choices on a menu, command line flags, and
so on.
Here is some code that shows you how to use the Day enum defined above:
public class EnumTest {
Day day;
public EnumTest(Day day) {
this.day = day;
}
public void tellItLikeItIs() {
switch (day) {

case MONDAY:
System.out.println("Mondays are bad.");
break;
case FRIDAY:
System.out.println("Fridays are better.");
break;
case SATURDAY: case SUNDAY:
System.out.println("Weekends are best.");
break;
default:
System.out.println("Midweek days are so-so.");
break;
}
}
EnumTest firstDay = new EnumTest(Day.MONDAY);
firstDay.tellItLikeItIs();
EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
thirdDay.tellItLikeItIs();
EnumTest fifthDay = new EnumTest(Day.FRIDAY);
fifthDay.tellItLikeItIs();
EnumTest sixthDay = new EnumTest(Day.SATURDAY);
sixthDay.tellItLikeItIs();
EnumTest seventhDay = new EnumTest(Day.SUNDAY);
seventhDay.tellItLikeItIs();
}
}

The output is:
Mondays are bad.
Midweek days are so-so.
Fridays are better.
Weekends are best.
Weekends are best.

Java programming language enum types are much more powerful than their counterparts in other
languages. The enum declaration defines a class (called an enum type). The enum class body can
include methods and other fields. The compiler automatically adds some special methods when it
creates an enum. For example, they have a static values method that returns an array containing
all of the values of the enum in the order they are declared. This method is commonly used in
combination with the for-each construct to iterate over the values of an enum type. For example,
this code from the Planet class example below iterates over all the planets in the solar system.
for (Planet p : Planet.values()) {
System.out.printf("Your weight on %s is %f%n",
p, p.surfaceWeight(mass));
}

Note: All enums implicitly extend java.lang.Enum. Since Java does not support multiple
inheritance, an enum cannot extend anything else.

In the following example, Planet is an enum type that represents the planets in the solar system.
They are defined with constant mass and radius properties.
Each enum constant is declared with values for the mass and radius parameters. These values are
passed to the constructor when the constant is created. Java requires that the constants be defined
first, prior to any fields or methods. Also, when there are fields and methods, the list of enum
constants must end with a semicolon.

Note: The constructor for an enum type must be package-private or private access. It
automatically creates the constants that are defined at the beginning of the enum body. You
cannot invoke an enum constructor yourself.

In addition to its properties and constructor, Planet has methods that allow you to retrieve the
surface gravity and weight of an object on each planet. Here is a sample program that takes your
weight on earth (in any unit) and calculates and prints your weight on all of the planets (in the
same unit):
public enum
MERCURY
VENUS
EARTH
MARS
JUPITER
SATURN
URANUS
NEPTUNE

Planet {
(3.303e+23,
(4.869e+24,
(5.976e+24,
(6.421e+23,
(1.9e+27,
(5.688e+26,
(8.686e+25,
(1.024e+26,

2.4397e6),
6.0518e6),
6.37814e6),
3.3972e6),
7.1492e7),
6.0268e7),
2.5559e7),
2.4746e7);

private final double mass;
// in kilograms
private final double radius; // in meters
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
}
private double mass() { return mass; }
private double radius() { return radius; }
// universal gravitational constant (m3 kg-1 s-2)
public static final double G = 6.67300E-11;
double surfaceGravity() {
return G * mass / (radius * radius);
}
double surfaceWeight(double otherMass) {
return otherMass * surfaceGravity();

}
if (args.length != 1) {
System.err.println("Usage: java Planet <earth_weight>");
System.exit(-1);
}
double earthWeight = Double.parseDouble(args[0]);
double mass = earthWeight/EARTH.surfaceGravity();
for (Planet p : Planet.values())
System.out.printf("Your weight on %s is %f%n",
p, p.surfaceWeight(mass));
}
}

If you run Planet.class from the command line with an argument of 175, you get this output:
$ java Planet 175
Your weight on MERCURY is 66.107583
Your weight on VENUS is 158.374842
Your weight on EARTH is 175.000000
Your weight on MARS is 66.279007
Your weight on JUPITER is 442.847567
Your weight on SATURN is 186.552719
Your weight on URANUS is 158.397260
Your weight on NEPTUNE is 199.207413

Defining an Interface
An interface declaration consists of modifiers, the keyword interface, the interface name, a
comma-separated list of parent interfaces (if any), and the interface body. For example:
public interface GroupedInterface extends Interface1, Interface2, Interface3
{
// constant declarations
// base of natural logarithms
double E = 2.718282;
// method signatures
void doSomething (int i, double x);
int doSomethingElse(String s);
}

The public access specifier indicates that the interface can be used by any class in any package.
If you do not specify that the interface is public, your interface will be accessible only to classes
defined in the same package as the interface.

An interface can extend other interfaces, just as a class can extend or subclass another class.
However, whereas a class can extend only one other class, an interface can extend any number of
interfaces. The interface declaration includes a comma-separated list of all the interfaces that it
extends.

The Interface Body
The interface body contains method declarations for all the methods included in the interface. A
method declaration within an interface is followed by a semicolon, but no braces, because an
interface does not provide implementations for the methods declared within it. All methods
declared in an interface are implicitly public, so the public modifier can be omitted.
An interface can contain constant declarations in addition to method declarations. All constant
values defined in an interface are implicitly public, static, and final. Once again, these
modifiers can be omitted.

Implementing an Interface
To declare a class that implements an interface, you include an implements clause in the class
declaration. Your class can implement more than one interface, so the implements keyword is
followed by a comma-separated list of the interfaces implemented by the class. By convention,
the implements clause follows the extends clause, if there is one.

A Sample Interface, Relatable
Consider an interface that defines how to compare the size of objects.
public interface Relatable {
// this (object calling isLargerThan)
// and other must be instances of
// the same class returns 1, 0, -1
// if this is greater // than, equal
// to, or less than other
public int isLargerThan(Relatable other);
}

If you want to be able to compare the size of similar objects, no matter what they are, the class
that instantiates them should implement Relatable.
Any class can implement Relatable if there is some way to compare the relative "size" of
objects instantiated from the class. For strings, it could be number of characters; for books, it
could be number of pages; for students, it could be weight; and so forth. For planar geometric
objects, area would be a good choice (see the RectanglePlus class that follows), while volume
would work for three-dimensional geometric objects. All such classes can implement the
isLargerThan() method.

If you know that a class implements Relatable, then you know that you can compare the size of
the objects instantiated from that class.

Implementing the Relatable Interface
Here is the Rectangle class that was presented in the Creating Objects section, rewritten to
implement Relatable.
public class RectanglePlus
implements Relatable {
public int width = 0;
public int height = 0;
public Point origin;
// four constructors
public RectanglePlus() {
}
public RectanglePlus(Point p) {
origin = p;
}
public RectanglePlus(int w, int h) {
width = w;
height = h;
}
public RectanglePlus(Point p, int w, int h) {
origin = p;
width = w;
height = h;
}
// a method for moving the rectangle
public void move(int x, int y) {
origin.x = x;
origin.y = y;
}
// a method for computing
// the area of the rectangle
}
// a method required to implement
// the Relatable interface
public int isLargerThan(Relatable other) {
RectanglePlus otherRect
= (RectanglePlus)other;
if (this.getArea() < otherRect.getArea())
return -1;
else if (this.getArea() > otherRect.getArea())
return 1;
else

return 0;
}
}

Because RectanglePlus implements Relatable, the size of any two RectanglePlus objects
can be compared.

Note: The isLargerThan method, as defined in the Relatable interface, takes an object of type
Relatable. The line of code, shown in bold in the previous example, casts other to a
RectanglePlus instance. Type casting tells the compiler what the object really is. Invoking
getArea directly on the other instance (other.getArea()) would fail to compile because the
compiler does not understand that other is actually an instance of RectanglePlus.

Using an Interface as a Type
When you define a new interface, you are defining a new reference data type. You can use
interface names anywhere you can use any other data type name. If you define a reference
variable whose type is an interface, any object you assign to it must be an instance of a class that
implements the interface.
As an example, here is a method for finding the largest object in a pair of objects, for any objects
that are instantiated from a class that implements Relatable:
public Object findLargest(Object object1, Object object2) {
Relatable obj1 = (Relatable)object1;
if ((obj1).isLargerThan(obj2) > 0)
return object1;
else
return object2;
}

By casting object1 to a Relatable type, it can invoke the isLargerThan method.
If you make a point of implementing Relatable in a wide variety of classes, the objects
instantiated from any of those classes can be compared with the findLargest() method—
provided that both objects are of the same class. Similarly, they can all be compared with the
following methods:
public Object findSmallest(Object object1, Object object2) {
if ((obj1).isLargerThan(obj2) < 0)
return object1;
else
return object2;

}
public boolean isEqual(Object object1, Object object2) {
if ( (obj1).isLargerThan(obj2) == 0)
return true;
else
return false;
}

These methods work for any "relatable" objects, no matter what their class inheritance is. When
they implement Relatable, they can be of both their own class (or superclass) type and a
Relatable type. This gives them some of the advantages of multiple inheritance, where they can
have behavior from both a superclass and an interface.

Rewriting Interfaces
Consider an interface that you have developed called DoIt:
public interface DoIt {
void doSomething(int i, double x);
}

Suppose that, at a later time, you want to add a third method to DoIt, so that the interface now
becomes:
public interface DoIt {
void doSomething(int i, double x);
boolean didItWork(int i, double x, String s);
}

If you make this change, all classes that implement the old DoIt interface will break because
they don't implement the interface anymore. Programmers relying on this interface will protest
loudly.
Try to anticipate all uses for your interface and to specify it completely from the beginning.
Given that this is often impossible, you may need to create more interfaces later. For example,
you could create a DoItPlus interface that extends DoIt:
public interface DoItPlus extends DoIt {
boolean didItWork(int i, double x, String s);
}

Now users of your code can choose to continue to use the old interface or to upgrade to the new
interface.

Summary of Interfaces
An interface defines a protocol of communication between two objects.
An interface declaration contains signatures, but no implementations, for a set of methods, and
might also contain constant definitions.
A class that implements an interface must implement all the methods declared in the interface.
An interface name can be used anywhere a type can be used.

Questions and Exercises: Interfaces
Questions
1. What methods would a class that implements the java.lang.CharSequence interface
have to implement?
2. What is wrong with the following interface?
3. public interface SomethingIsWrong {
4.
void aMethod(int aValue){
5.
System.out.println("Hi Mom");
6.
}
7. }

8. Fix the interface in question 2.
9. Is the following interface valid?
10. public interface Marker {
11. }

Exercises
1. Write a class that implements the CharSequence interface found in the java.lang
package. Your implementation should return the string backwards. Select one of the
sentences from this book to use as the data. Write a small main method to test your class;
make sure to call all four methods.
2. Suppose you have written a time server that periodically notifies its clients of the current
date and time. Write an interface the server could use to enforce a particular protocol on
its clients.
Check your answers.

Inheritance
In the preceding lessons, you have seen inheritance mentioned several times. In the Java
language, classes can be derived from other classes, thereby inheriting fields and methods from
those classes.

Definitions: A class that is derived from another class is called a subclass (also a derived class,
extended class, or child class). The class from which the subclass is derived is called a
superclass (also a base class or a parent class).
Excepting Object, which has no superclass, every class has one and only one direct superclass
(single inheritance). In the absence of any other explicit superclass, every class is implicitly a
subclass of Object.
Classes can be derived from classes that are derived from classes that are derived from classes,
and so on, and ultimately derived from the topmost class, Object. Such a class is said to be
descended from all the classes in the inheritance chain stretching back to Object.

The idea of inheritance is simple but powerful: When you want to create a new class and there is
already a class that includes some of the code that you want, you can derive your new class from
the existing class. In doing this, you can reuse the fields and methods of the existing class
without having to write (and debug!) them yourself.
A subclass inherits all the members (fields, methods, and nested classes) from its superclass.
Constructors are not members, so they are not inherited by subclasses, but the constructor of the
superclass can be invoked from the subclass.

The Java Platform Class Hierarchy
The Object class, defined in the java.lang package, defines and implements behavior common
to all classes—including the ones that you write. In the Java platform, many classes derive
directly from Object, other classes derive from some of those classes, and so on, forming a
hierarchy of classes.

All Classes in the Java Platform are Descendants of Object
At the top of the hierarchy, Object is the most general of all classes. Classes near the bottom of
the hierarchy provide more specialized behavior.

An Example of Inheritance
Here is the sample code for a possible implementation of a Bicycle class that was presented in
the Classes and Objects lesson:
// the
public
public
public

Bicycle class has three fields
int cadence;
int gear;
int speed;

// the Bicycle class has one constructor
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
speed = startSpeed;
}
// the Bicycle class has four methods
public void setCadence(int newValue) {
cadence = newValue;
}
public void setGear(int newValue) {
gear = newValue;
}
public void applyBrake(int decrement) {
speed -= decrement;
}

public void speedUp(int increment) {
speed += increment;
}
}

A class declaration for a MountainBike class that is a subclass of Bicycle might look like this:
public class MountainBike extends Bicycle {
// the MountainBike subclass adds one field
public int seatHeight;
// the MountainBike subclass has one constructor
public MountainBike(int startHeight,
int startCadence,
int startSpeed,
int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}
// the MountainBike subclass adds one method
public void setHeight(int newValue) {
seatHeight = newValue;
}
}
MountainBike

inherits all the fields and methods of Bicycle and adds the field seatHeight and
a method to set it. Except for the constructor, it is as if you had written a new MountainBike
class entirely from scratch, with four fields and five methods. However, you didn't have to do all
the work. This would be especially valuable if the methods in the Bicycle class were complex
and had taken substantial time to debug.

What You Can Do in a Subclass
A subclass inherits all of the public and protected members of its parent, no matter what package
the subclass is in. If the subclass is in the same package as its parent, it also inherits the packageprivate members of the parent. You can use the inherited members as is, replace them, hide
them, or supplement them with new members:
The inherited fields can be used directly, just like any other fields.
You can declare a field in the subclass with the same name as the one in the superclass,
thus hiding it (not recommended).
You can declare new fields in the subclass that are not in the superclass.
The inherited methods can be used directly as they are.
You can write a new instance method in the subclass that has the same signature as the
one in the superclass, thus overriding it.
You can write a new static method in the subclass that has the same signature as the one
in the superclass, thus hiding it.

You can declare new methods in the subclass that are not in the superclass.
You can write a subclass constructor that invokes the constructor of the superclass, either
implicitly or by using the keyword super.
The following sections in this lesson will expand on these topics.

Private Members in a Superclass
A subclass does not inherit the private members of its parent class. However, if the superclass
has public or protected methods for accessing its private fields, these can also be used by the
subclass.
A nested class has access to all the private members of its enclosing class—both fields and
methods. Therefore, a public or protected nested class inherited by a subclass has indirect access
to all of the private members of the superclass.

Casting Objects
We have seen that an object is of the data type of the class from which it was instantiated. For
example, if we write
public MountainBike myBike = new MountainBike();

then myBike is of type MountainBike.
MountainBike is descended from Bicycle and Object. Therefore, a MountainBike is a
Bicycle and is also an Object, and it can be used wherever Bicycle or Object objects are

called for.
The reverse is not necessarily true: a Bicyclemay be a MountainBike, but it isn't necessarily.
Similarly, an Objectmay be a Bicycle or a MountainBike, but it isn't necessarily.
Casting shows the use of an object of one type in place of another type, among the objects
permitted by inheritance and implementations. For example, if we write
Object obj = new MountainBike();

then obj is both an Object and a MountainBike (until such time as obj is assigned another
object that is not a MountainBike). This is called implicit casting.
If, on the other hand, we write
MountainBike myBike = obj;

we would get a compile-time error because obj is not known to the compiler to be a
MountainBike. However, we can tell the compiler that we promise to assign a MountainBike to
obj by explicit casting:
MountainBike myBike = (MountainBike)obj;

This cast inserts a runtime check that obj is assigned a MountainBike so that the compiler can
safely assume that obj is a MountainBike. If obj is not a MountainBike at runtime, an
exception will be thrown.

Note: You can make a logical test as to the type of a particular object using the instanceof
operator. This can save you from a runtime error owing to an improper cast. For example:
if (obj instanceof MountainBike) {
MountainBike myBike = (MountainBike)obj;
}

Here the instanceof operator verifies that obj refers to a MountainBike so that we can make
the cast with knowledge that there will be no runtime exception thrown.

Overriding and Hiding Methods
Instance Methods
An instance method in a subclass with the same signature (name, plus the number and the type of
its parameters) and return type as an instance method in the superclass overrides the superclass's
method.
The ability of a subclass to override a method allows a class to inherit from a superclass whose
behavior is "close enough" and then to modify behavior as needed. The overriding method has
the same name, number and type of parameters, and return type as the method it overrides. An
overriding method can also return a subtype of the type returned by the overridden method. This
is called a covariant return type.
When overriding a method, you might want to use the @Override annotation that instructs the
compiler that you intend to override a method in the superclass. If, for some reason, the compiler
detects that the method does not exist in one of the superclasses, it will generate an error. For
more information on @Override, see Annotations.

Class Methods
If a subclass defines a class method with the same signature as a class method in the superclass,
the method in the subclass hides the one in the superclass.

The distinction between hiding and overriding has important implications. The version of the
overridden method that gets invoked is the one in the subclass. The version of the hidden method
that gets invoked depends on whether it is invoked from the superclass or the subclass. Let's look
at an example that contains two classes. The first is Animal, which contains one instance method
and one class method:
public class Animal {
public static void testClassMethod() {
System.out.println("The class" + " method in Animal.");
}
public void testInstanceMethod() {
System.out.println("The instance " + " method in Animal.");
}
}

The second class, a subclass of Animal, is called Cat:
public class Cat extends Animal {
public static void testClassMethod() {
System.out.println("The class method" + " in Cat.");
}
public void testInstanceMethod() {
System.out.println("The instance method" + " in Cat.");
}
Cat myCat = new Cat();
Animal myAnimal = myCat;
Animal.testClassMethod();
myAnimal.testInstanceMethod();
}
}

The Cat class overrides the instance method in Animal and hides the class method in Animal.
The main method in this class creates an instance of Cat and calls testClassMethod() on the
class and testInstanceMethod() on the instance.
The output from this program is as follows:
The class method in Animal.
The instance method in Cat.

As promised, the version of the hidden method that gets invoked is the one in the superclass, and
the version of the overridden method that gets invoked is the one in the subclass.

Modifiers
The access specifier for an overriding method can allow more, but not less, access than the
overridden method. For example, a protected instance method in the superclass can be made
public, but not private, in the subclass.

You will get a compile-time error if you attempt to change an instance method in the superclass
to a class method in the subclass, and vice versa.

Summary
The following table summarizes what happens when you define a method with the same
signature as a method in a superclass.
Defining a Method with the Same Signature as a Superclass's Method
Superclass Instance Method Superclass Static Method
Generates a compile-time error
Subclass Instance Method Overrides
Subclass Static Method Generates a compile-time error Hides
Note: In a subclass, you can overload the methods inherited from the superclass. Such
overloaded methods neither hide nor override the superclass methods—they are new methods,
unique to the subclass.

Polymorphism
The dictionary definition of polymorphism refers to a principle in biology in which an organism
or species can have many different forms or stages. This principle can also be applied to objectoriented programming and languages like the Java language. Subclasses of a class can define
their own unique behaviors and yet share some of the same functionality of the parent class.
Polymorphism can be demonstrated with a minor modification to the Bicycle class. For
example, a printDescription method could be added to the class that displays all the data
currently stored in an instance.
public void printDescription(){
System.out.println("nBike is " + "in gear " + this.gear
+ " with a cadence of " + this.cadence +
" and travelling at a speed of " + this.speed + ". ");
}

To demonstrate polymorphic features in the Java language, extend the Bicycle class with a
MountainBike and a RoadBike class. For MountainBike, add a field for suspension, which is a
String value that indicates if the bike has a front shock absorber, Front. Or, the bike has a front
and back shock absorber, Dual.
Here is the updated class:
public class MountainBike extends Bicycle {
private String suspension;
public MountainBike(

int startCadence,
int startSpeed,
int startGear,
String suspensionType){
super(startCadence,
startSpeed,
startGear);
this.setSuspension(suspensionType);
}
public String getSuspension(){
return this.suspension;
}
public void setSuspension(String suspensionType) {
this.suspension = suspensionType;
}
public void printDescription() {
super.printDescription();
System.out.println("The " + "MountainBike has a" +
getSuspension() + " suspension.");
}
}

Note the overridden printDescription method. In addition to the information provided before,
additional data about the suspension is included to the output.
Next, create the RoadBike class. Because road or racing bikes have skinny tires, add an attribute
to track the tire width. Here is the RoadBike class:
public class RoadBike extends Bicycle{
// In millimeters (mm)
private int tireWidth;
public RoadBike(int startCadence,
int startSpeed,
int startGear,
int newTireWidth){
super(startCadence,
startSpeed,
startGear);
this.setTireWidth(newTireWidth);
}
public int getTireWidth(){
return this.tireWidth;
}
public void setTireWidth(int newTireWidth){
this.tireWidth = newTireWidth;
}
public void printDescription(){
super.printDescription();

System.out.println("The RoadBike" + " has " + getTireWidth() +
" MM tires.");
}
}

Note that once again, the printDescription method has been overridden. This time,
information about the tire width is displayed.
To summarize, there are three classes: Bicycle, MountainBike, and RoadBike. The two
subclasses override the printDescription method and print unique information.
Here is a test program that creates three Bicycle variables. Each variable is assigned to one of
the three bicycle classes. Each variable is then printed.
public class TestBikes {
public static void main(String[] args){
Bicycle bike01, bike02, bike03;
bike01 = new Bicycle(20, 10, 1);
bike02 = new MountainBike(20, 10, 5, "Dual");
bike03 = new RoadBike(40, 20, 8, 23);
bike01.printDescription();
}
}

The following is the output from the test program:
Bike is in gear 1 with a cadence of 20 and travelling at a speed of 10.
The MountainBike has a Dual suspension.
The RoadBike has 23 MM tires.

The Java virtual machine (JVM) calls the appropriate method for the object that is referred to in
each variable. It does not call the method that is defined by the variable's type. This behavior is
referred to as virtual method invocation and demonstrates an aspect of the important
polymorphism features in the Java language.

Using the Keyword super

Accessing Superclass Members
If your method overrides one of its superclass's methods, you can invoke the overridden method
through the use of the keyword super. You can also use super to refer to a hidden field
(although hiding fields is discouraged). Consider this class, Superclass:
public class Superclass {
public void printMethod() {
System.out.println("Printed in Superclass.");
}
}

Here is a subclass, called Subclass, that overrides printMethod():
public class Subclass extends Superclass {
// overrides printMethod in Superclass
public void printMethod() {
super.printMethod();
System.out.println("Printed in Subclass");
}
Subclass s = new Subclass();
s.printMethod();
}
}

Within Subclass, the simple name printMethod() refers to the one declared in Subclass,
which overrides the one in Superclass. So, to refer to printMethod() inherited from
Superclass, Subclass must use a qualified name, using super as shown. Compiling and
executing Subclass prints the following:
Printed in Superclass.
Printed in Subclass

Subclass Constructors
The following example illustrates how to use the super keyword to invoke a superclass's
constructor. Recall from the Bicycleexample that MountainBike is a subclass of Bicycle. Here
is the MountainBike (subclass) constructor that calls the superclass constructor and then adds
initialization code of its own:
public MountainBike(int startHeight,
int startCadence,
int startSpeed,
int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}

Invocation of a superclass constructor must be the first line in the subclass constructor.
The syntax for calling a superclass constructor is
super();

or:
super(parameter list);

With super(), the superclass no-argument constructor is called. With super(parameter list),
the superclass constructor with a matching parameter list is called.

Note: If a constructor does not explicitly invoke a superclass constructor, the Java compiler
automatically inserts a call to the no-argument constructor of the superclass. If the super class
does not have a no-argument constructor, you will get a compile-time error. Objectdoes have
such a constructor, so if Object is the only superclass, there is no problem.

If a subclass constructor invokes a constructor of its superclass, either explicitly or implicitly,
you might think that there will be a whole chain of constructors called, all the way back to the
constructor of Object. In fact, this is the case. It is called constructor chaining, and you need to
be aware of it when there is a long line of class descent.

Object as a Superclass
The Object class, in the java.lang package, sits at the top of the class hierarchy tree. Every
class is a descendant, direct or indirect, of the Object class. Every class you use or write inherits
the instance methods of Object. You need not use any of these methods, but, if you choose to do
so, you may need to override them with code that is specific to your class. The methods inherited
from Object that are discussed in this section are:
protected Object clone() throws CloneNotSupportedException

Creates and returns a copy of this object.
public boolean equals(Object obj)

Indicates whether some other object is "equal to" this one.
protected void finalize() throws Throwable

Called by the garbage collector on an object when garbage
collection determines that there are no more references to the object
public final Class getClass()

Returns the runtime class of an object.
public int hashCode()

Returns a hash code value for the object.
public String toString()

Returns a string representation of the object.

The notify, notifyAll, and wait methods of Object all play a part in synchronizing the
activities of independently running threads in a program, which is discussed in a later lesson and
won't be covered here. There are five of these methods:
public
public
public
public
public

final
final
final
final
final

void
void
void
void
void

notify()
notifyAll()
wait()
wait(long timeout)
wait(long timeout, int nanos)

Note: There are some subtle aspects to a number of these methods, especially the clone method.

The clone() Method
If a class, or one of its superclasses, implements the Cloneable interface, you can use the
clone() method to create a copy from an existing object. To create a clone, you write:
aCloneableObject.clone();
Object's

implementation of this method checks to see whether the object on which clone() was
invoked implements the Cloneable interface. If the object does not, the method throws a
CloneNotSupportedException exception. Exception handling will be covered in a later lesson.
For the moment, you need to know that clone() must be declared as
protected Object clone() throws CloneNotSupportedException

or:
public Object clone() throws CloneNotSupportedException

if you are going to write a clone() method to override the one in Object.
If the object on which clone() was invoked does implement the Cloneable interface, Object's
implementation of the clone() method creates an object of the same class as the original object
and initializes the new object's member variables to have the same values as the original object's
corresponding member variables.
The simplest way to make your class cloneable is to add implements Cloneable to your class's
declaration. then your objects can invoke the clone() method.
For some classes, the default behavior of Object's clone() method works just fine. If, however,
an object contains a reference to an external object, say ObjExternal, you may need to override
clone() to get correct behavior. Otherwise, a change in ObjExternal made by one object will
be visible in its clone also. This means that the original object and its clone are not

independent—to decouple them, you must override clone() so that it clones the object
andObjExternal. Then the original object references ObjExternal and the clone references a
clone of ObjExternal, so that the object and its clone are truly independent.

The equals() Method
The equals() method compares two objects for equality and returns true if they are equal. The
equals() method provided in the Object class uses the identity operator (==) to determine
whether two objects are equal. For primitive data types, this gives the correct result. For objects,
however, it does not. The equals() method provided by Object tests whether the object
references are equal—that is, if the objects compared are the exact same object.
To test whether two objects are equal in the sense of equivalency (containing the same
information), you must override the equals() method. Here is an example of a Book class that
overrides equals():
public class Book {
...
public boolean equals(Object obj) {
if (obj instanceof Book)
return ISBN.equals((Book)obj.getISBN());
else
return false;
}
}

Consider this code that tests two instances of the Book class for equality:
// Swing Tutorial, 2nd edition
Book firstBook = new Book("0201914670");
Book secondBook = new Book("0201914670");
if (firstBook.equals(secondBook)) {
System.out.println("objects are equal");
} else {
System.out.println("objects are not equal");
}

This program displays objects are equal even though firstBook and secondBook reference
two distinct objects. They are considered equal because the objects compared contain the same
ISBN number.
You should always override the equals() method if the identity operator is not appropriate for
your class.

Note: If you override equals(), you must override hashCode() as well.

The finalize() Method
The Object class provides a callback method, finalize(), that may be invoked on an object
when it becomes garbage. Object's implementation of finalize() does nothing—you can
override finalize() to do cleanup, such as freeing resources.
The finalize() method may be called automatically by the system, but when it is called, or
even if it is called, is uncertain. Therefore, you should not rely on this method to do your cleanup
for you. For example, if you don't close file descriptors in your code after performing I/O and
you expect finalize() to close them for you, you may run out of file descriptors.

The getClass() Method
You cannot override getClass.
The getClass() method returns a Class object, which has methods you can use to get
information about the class, such as its name (getSimpleName()), its superclass
(getSuperclass()), and the interfaces it implements (getInterfaces()). For example, the
following method gets and displays the class name of an object:
void printClassName(Object obj) {
System.out.println("The object's" + " class is " +
obj.getClass().getSimpleName());
}

The Class class, in the java.lang package, has a large number of methods (more than 50). For
example, you can test to see if the class is an annotation (isAnnotation()), an interface
(isInterface()), or an enumeration (isEnum()). You can see what the object's fields are
(getFields()) or what its methods are (getMethods()), and so on.

The hashCode() Method
The value returned by hashCode() is the object's hash code, which is the object's memory
address in hexadecimal.
By definition, if two objects are equal, their hash code must also be equal. If you override the
equals() method, you change the way two objects are equated and Object's implementation of
hashCode() is no longer valid. Therefore, if you override the equals() method, you must also
override the hashCode() method as well.

The toString() Method
You should always consider overriding the toString() method in your classes.

The Object's toString() method returns a String representation of the object, which is very
useful for debugging. The String representation for an object depends entirely on the object,
which is why you need to override toString() in your classes.
You can use toString() along with System.out.println() to display a text representation of
an object, such as an instance of Book:
System.out.println(firstBook.toString());

which would, for a properly overridden toString() method, print something useful, like this:
ISBN: 0201914670; The Swing Tutorial; A Guide to Constructing GUIs, 2nd
Edition

Writing Final Classes and Methods
You can declare some or all of a class's methods final. You use the final keyword in a method
declaration to indicate that the method cannot be overridden by subclasses. The Object class
does this—a number of its methods are final.
You might wish to make a method final if it has an implementation that should not be changed
and it is critical to the consistent state of the object. For example, you might want to make the
getFirstPlayer method in this ChessAlgorithm class final:
class ChessAlgorithm {
enum ChessPlayer { WHITE, BLACK }
...
final ChessPlayer getFirstPlayer() {
return ChessPlayer.WHITE;
}
...
}

Methods called from constructors should generally be declared final. If a constructor calls a nonfinal method, a subclass may redefine that method with surprising or undesirable results.
Note that you can also declare an entire class final. A class that is declared final cannot be
subclassed. This is particularly useful, for example, when creating an immutable class like the
String class.

Abstract Methods and Classes
An abstract class is a class that is declared abstract—it may or may not include abstract
methods. Abstract classes cannot be instantiated, but they can be subclassed.
An abstract method is a method that is declared without an implementation (without braces, and
followed by a semicolon), like this:
abstract void moveTo(double deltaX, double deltaY);

If a class includes abstract methods, the class itself must be declared abstract, as in:
public abstract class GraphicObject {
// declare fields
// declare non-abstract methods
abstract void draw();
}

When an abstract class is subclassed, the subclass usually provides implementations for all of the
abstract methods in its parent class. However, if it does not, the subclass must also be declared
abstract.

Note: All of the methods in an interface (see the Interfaces section) are implicitly abstract, so
the abstract modifier is not used with interface methods (it could be—it's just not necessary).

Abstract Classes versus Interfaces
Unlike interfaces, abstract classes can contain fields that are not static and final, and they can
contain implemented methods. Such abstract classes are similar to interfaces, except that they
provide a partial implementation, leaving it to subclasses to complete the implementation. If an
abstract class contains only abstract method declarations, it should be declared as an interface
instead.
Multiple interfaces can be implemented by classes anywhere in the class hierarchy, whether or
not they are related to one another in any way. Think of Comparable or Cloneable, for example.
By comparison, abstract classes are most commonly subclassed to share pieces of
implementation. A single abstract class is subclassed by similar classes that have a lot in
common (the implemented parts of the abstract class), but also have some differences (the
abstract methods).

An Abstract Class Example

In an object-oriented drawing application, you can draw circles, rectangles, lines, Bezier curves,
and many other graphic objects. These objects all have certain states (for example: position,
orientation, line color, fill color) and behaviors (for example: moveTo, rotate, resize, draw) in
common. Some of these states and behaviors are the same for all graphic objects—for example:
position, fill color, and moveTo. Others require different implementations—for example, resize
or draw. All GraphicObjects must know how to draw or resize themselves; they just differ in
how they do it. This is a perfect situation for an abstract superclass. You can take advantage of
the similarities and declare all the graphic objects to inherit from the same abstract parent
object—for example, GraphicObject, as shown in the following figure.

Classes Rectangle, Line, Bezier, and Circle inherit from GraphicObject
First, you declare an abstract class, GraphicObject, to provide member variables and methods
that are wholly shared by all subclasses, such as the current position and the moveTo method.
GraphicObject also declares abstract methods for methods, such as draw or resize, that need
to be implemented by all subclasses but must be implemented in different ways. The
GraphicObject class can look something like this:
abstract class GraphicObject {
int x, y;
...
void moveTo(int newX, int newY) {
...
}
abstract void draw();
abstract void resize();
}

Each non-abstract subclass of GraphicObject, such as Circle and Rectangle, must provide
implementations for the draw and resize methods:
class Circle extends GraphicObject {
void draw() {
...
}
void resize() {
...
}
}
class Rectangle extends GraphicObject {
void draw() {
...
}
void resize() {
...

}
}

When an Abstract Class Implements an Interface
In the section on Interfaces, it was noted that a class that implements an interface must
implement all of the interface's methods. It is possible, however, to define a class that does not
implement all of the interface methods, provided that the class is declared to be abstract. For
example,
abstract class X implements Y {
// implements all but one method of Y
}
class XX extends X {
// implements the remaining method in Y
}

In this case, class X must be abstract because it does not fully implement Y, but class XX does,
in fact, implement Y.

Class Members
An abstract class may have static fields and static methods. You can use these static
members with a class reference—for example, AbstractClass.staticMethod()—as you
would with any other class.

Summary of Inheritance
Except for the Object class, a class has exactly one direct superclass. A class inherits fields and
methods from all its superclasses, whether direct or indirect. A subclass can override methods
that it inherits, or it can hide fields or methods that it inherits. (Note that hiding fields is generally
bad programming practice.)
The table in Overriding and Hiding Methods section shows the effect of declaring a method with
the same signature as a method in the superclass.
The Object class is the top of the class hierarchy. All classes are descendants from this class and
inherit methods from it. Useful methods inherited from Object include toString(), equals(),
clone(), and getClass().
You can prevent a class from being subclassed by using the final keyword in the class's
declaration. Similarly, you can prevent a method from being overridden by subclasses by
declaring it as a final method.

An abstract class can only be subclassed; it cannot be instantiated. An abstract class can contain
abstract methods—methods that are declared but not implemented. Subclasses then provide the
implementations for the abstract methods.

Questions and Exercises: Inheritance
Questions
1. Consider the following two classes:
public class ClassA {
public void methodOne(int i) {
}
public void methodTwo(int i) {
}
public static void methodThree(int i) {
}
public static void methodFour(int i) {
}
}
public class ClassB extends ClassA {
public static void methodOne(int i) {
}
}
public void methodThree(int i) {
}
}
}

a. Which method overrides a method in the superclass?
b. Which method hides a method in the superclass?
c. What do the other methods do?
2. Consider the Card, Deck, and DisplayDeck classes you wrote in Questions and Exercises:
Classes. What Object methods should each of these classes override?

Exercises
1. Write the implementations for the methods that you answered in question 2.

Check your answers.

Answers to Questions and Exercises:
Inheritance
Questions
Question 1: Consider the following two classes:
public class ClassA {
public void methodOne(int i) {
}
}
public static void methodThree(int i) {
}
}
}
public class ClassB extends ClassA {
public static void methodOne(int i) {
}
}
public void methodThree(int i) {
}
}
}

Question 1a: Which method overrides a method in the superclass?
Answer 1a: methodTwo
Question 1b: Which method hides a method in the superclass?
Answer 1b: methodFour
Question 1c: What do the other methods do?
Answer 1c: They cause compile-time errors.
Question 2: Consider the Card, Deck, and DisplayDeck classes you wrote in the previous
exercise. What Object methods should each of these classes override?
Answer 2: Card and Deck should override equals, hashCode, and toString.

Exercises
Exercise 1: Write the implementations for the methods that you answered in question 2.
Answer 1: See Card2.

S

Answers to Questions and Exercises: Classes
Questions
1. Consider the following class:
2. public class IdentifyMyParts {
3.
public static int x = 7;
4.
public int y = 3;
5. }

a. Question: What are the class variables?
Answer: x
b. Question: What are the instance variables?
Answer: y
c. Question: What is the output from the following code:
d.
e.
f.
g.
h.
i.
j.
k.
l.
m.
n.

IdentifyMyParts a = new IdentifyMyParts();
IdentifyMyParts b = new IdentifyMyParts();
a.y = 5;
b.y = 6;
a.x = 1;
b.x = 2;
System.out.println("a.y = " + a.y);
System.out.println("b.y = " + b.y);
System.out.println("a.x = " + a.x);
System.out.println("b.x = " + b.x);
System.out.println("IdentifyMyParts.x = " + IdentifyMyParts.x);

Answer: Here is the output:
a.y = 5
b.y = 6
a.x = 2
b.x = 2
IdentifyMyParts.x = 2

Because x is defined as a public static int in the class IdentifyMyParts,
every reference to x will have the value that was last assigned because x is a static
variable (and therefore a class variable) shared across all instances of the class.
That is, there is only one x: when the value of x changes in any instance it affects
the value of x for all instances of IdentifyMyParts.

This is covered in the Class Variables section of Understanding Instance and
Class Members.

Exercises
1. Exercise: Write a class whose instances represent a single playing card from a deck of
cards. Playing cards have two distinguishing properties: rank and suit. Be sure to keep
your solution as you will be asked to rewrite it in Enum Types.
Answer: Card.java .
2. Exercise: Write a class whose instances represents a full deck of cards. You should also
keep this solution.
Answer: See Deck.java .
3. Exercise: Write a small program to test your deck and card classes. The program can be
as simple as creating a deck of cards and displaying its cards.
Answer: See DisplayDeck.java .

Answers to Questions and Exercises: Objects
Questions
1. Question: What's wrong with the following program?
2. public class SomethingIsWrong {
3.
4.
Rectangle myRect;
5.
myRect.width = 40;
6.
myRect.height = 50;
7.
8.
}
9. }

Answer: The code never creates a Rectangle object. With this simple program, the
compiler generates an error. However, in a more realistic situation, myRect might be
initialized to null in one place, say in a constructor, and used later. In that case, the
program will compile just fine, but will generate a NullPointerException at runtime.
10. Question: The following code creates one array and one string object. How many
references to those objects exist after the code executes? Is either object eligible for
garbage collection?
11. ...
12. String[] students = new String[10];
13. String studentName = "Peter Smith";

14. students[0] = studentName;
15. studentName = null;
16. ...

Answer: There is one reference to the students array and that array has one reference to
the string Peter Smith. Neither object is eligible for garbage collection.
17. Question: How does a program destroy an object that it creates?
Answer: A program does not explicitly destroy objects. A program can set all references
to an object to null so that it becomes eligible for garbage collection. But the program
does not actually destroy objects.

Exercises
1. Exercise: Fix the program called SomethingIsWrong shown in Question 1.
Answer: See SomethingIsRight:
public class SomethingIsRight {
Rectangle myRect = new Rectangle();
myRect.width = 40;
myRect.height = 50;
}
}

2. Exercise: Given the following class, called NumberHolder, write some code that creates
an instance of the class, initializes its two member variables, and then displays the value
of each member variable.
3.
4. public class NumberHolder {
5.
public int anInt;
6.
public float aFloat;
7. }

Answer: See NumberHolderDisplay:
public class NumberHolderDisplay {
NumberHolder aNumberHolder = new NumberHolder();
aNumberHolder.anInt = 1;
aNumberHolder.aFloat = 2.3f;
System.out.println(aNumberHolder.anInt);
System.out.println(aNumberHolder.aFloat);
}
}

Answers to Questions and Exercises: Nested
Classes
Questions
1. Question: The program Problem.java doesn't compile. What do you need to do to make
it compile? Why?
Answer: Delete static in front of the declaration of the Inner class. An static inner
class does not have access to the instance fields of the outer class. See
ProblemSolved.java.
2. Use the Java API documentation for the Box class (in the javax.swing package) to help
you answer the following questions.
a. Question: What static nested class does Box define?
Answer: Box.Filler
b. Question: What inner class does Box define?
Answer: Box.AccessibleBox
c. Question: What is the superclass of Box's inner class?
Answer: [java.awt.]Container.AccessibleAWTContainer
d. Question: Which of Box's nested classes can you use from any class?
Answer: Box.Filler
e. Question: How do you create an instance of Box's Filler class?
Answer: new Box.Filler(minDimension, prefDimension, maxDimension)

Exercises
1. Exercise: Get the file Class1.java. Compile and run Class1. What is the output?
Answer: InnerClass1: getString invoked.
InnerClass1: getAnotherString invoked.

Answers to Questions and Exercises: Enum
Types
Questions
1. Question: True or false: an Enum type can be a subclass of java.lang.String.
Answer: All enums implicitly extend java.lang.Enum. Since Java does not support
multiple inheritance, an enum cannot extend anything else.

Exercises
1. Exercise: Rewrite the class Card from the exercise in Questions and Exercises: Classes
so that it represents the rank and suit of a card with enum types.
Answer: See Card3.java, Suit.java, and Rank.java.
2. Exercise: Rewrite the Deck class.
Answer: See Deck3.java.

Java execise

More Related Content

What's hot (20)

Similar to Java execise (20)

Recently uploaded (20)

Java execise