chap 6 : Objects and classes (scjp/ocjp)

Objects and Classes

Ben Abdallah Helmi Architect 1
1
J2EE

Methods, Overloading and
Overriding
In the class that defines the original method, or a subclass of
that class, the method name can be re-used if the argument
list differs in terms of the type of at least one argument. This is
overloading. It is important to realize that a difference in return
type or list of thrown exceptions is insufficient to constitute an
overload and is illegal.
In a strict subclass of the class that defines the original
method, the method name can be re-used with identical
argument types and order and with identical return type. This
is overriding. In this case, additional restrictions apply to the
accessibility of, and exceptions that may be thrown by, the
method.
2
J2EE

Overloading Method Names
In Java, a method is uniquely identified by the combination
of its fully qualified class name, the method name, and
the exact sequence of its argument types. Overloading is
the re-use of a method name in the one class or subclass
for a different method.
1. public void aMethod(String s) { }
2. public void aMethod() { }
3. public void aMethod(int i, String s) { }
4. public void aMethod(String s, int i) { }
3
J2EE

One last point to consider is the return type of an
overloaded method. The language treats methods with
overloaded names as totally different methods, and as
such they can have different return types (you will see
shortly that overriding methods do not have this freedom).

4
J2EE

To summarize, these are the key
points about overloading methods:
The identity of a method is determined by the combination
of its fully qualified class; its name; and the
type, order, and count of arguments in the argument list.
Two or more methods in the same class (including
methods inherited from a superclass) with the same name
but different argument lists are called overloaded.
Methods with overloaded names are effectively
independent methods—using the same name is really just
a convenience to the programmer. Return
type, accessibility, and exception lists may vary freely
5
J2EE

Method Overriding
There are a number of key distinctions between overloading and overriding:
• Overloaded methods supplement each other; an overriding method replaces the
method it overrides.
• Overloaded methods can exist, in any number, in the same class. Each method
in a parent class can be overridden at most once in any one subclass.
• Overloaded methods must have different argument lists; overriding methods
must have argument lists of identical type and order (otherwise they are simply
treated as overloaded methods).
• The return type of an overloaded method may be chosen freely; the return type
of an overriding method must be identical to that of the method it overrides.
• The exception list of an overriden method may be chosen according to the rules
defined earlier in this chapter.
• The access modifiers of an overriden method may be chosen according to the
rules defined earlier in this chapter.
6
J2EE

What Is Overriding For?
• Overloading allows multiple implementations of the same
essential functionality to use the same name. Overriding,
on the other hand, modifies the implementation of a
particular piece of behavior for a subclass.

7
J2EE

• The method name and the type and order of arguments must
be identical to those of a method in a parent class. If this is the
case, then the method is an attempt to override the
corresponding parent class method, and the remaining points
listed here must be adhered to or a compiler error arises. If
these criteria are not met, then the method is not an attempt to
override and the following rules are irrelevant.
• The return type must be the same as, or a subclass of, the
superclass version’s return type.
• Methods marked final may not be overridden.
• The accessibility must not be more restrictive than that of the
original method.
• The method may throw only checked exception types that are
the same as, or subclasses of, exception types thrown by the
original method.
J2EE

8

The second rule is new in release 5.0. Prior to 5.0, an overriding method’s return type had to exactly match
the superclass version’s return type. Now the rule has been expanded, to supportcovariant return types.
A covariant return type of an overriding method is a subclass of the return type of the superclass version.
Here’s an example:
class TheSuperclass {
Number getValue() {
return new Long(33);
}
}
class TheSubclass extends TheSuperclass {
Float getValue() {
return new Float(1.23f);
}
}
The superclass version returns a Number. The subclass version returns a Float, which extends
Number. This would be illegal without covariant return types.
In addition, while you can make the return type narrower, you can't make the parameter types wider.

When overriding a method, you can make its return type narrower ifJ2EE class.
it is a
9

Late Binding
Unlike traditional languages or runtime
environments, every time the Java system allocates
memory, it marks that memory with the type of the data
that it has been allocated to hold. So, given any
object, and without regard to the type associated with the
reference variable acting as a handle to that object, the
runtime system can determine the real class of that object
by inspection. This process is the basis of the instanceof
operator, which allows you to program a test to determine
the actual class of an object at runtime

10
J2EE

Variable-Length Argument Lists
• void xyz(String … stringies)
• Callers may invoke this method with any number of String
arguments (even none at all).
• Within the method, stringies appears as an array of
Strings.
• Many methods of the core Java classes accept variable
argument lists, so keep your eye out for the three dots in
method descriptions in the API pages.

11
J2EE

Constructors and Subclassing

• A constructor is invoked with a call of the form new
MyClass(arg1, arg2, ...). If the argument list is empty, the
constructor is called a no-arguments (or no-args)
constructor. If you do not explicitly code any constructors
for a class, the compiler automatically creates a default
constructor that does nothing except invoke the
superclass’ default constructor, via a mechanism
described in the next section. This “freebie” constructor is
called the default constructor. It has public access if the
class is public; otherwise its access mode is default.
• It is important to know that the superclass constructor
must be called before any reference is made to any part
of this object.
12
J2EE

Overloading Constructors
• Constructors are not inherited in the same way as normal methods. You can create an
object only if the class defines a constructor with an argument list that matches the one your
new call provides.
• If you define no constructors in a class, then the compiler provides a default that takes no
arguments. If you define even a single constructor, this default is not provided.
• It is common to provide multiple overloaded constructors—that is, constructors with different
argument lists. One constructor can call another using the syntax this(arguments).
• A constructor delays running its body until the parent parts of the class have been initialized.
This commonly happens because of an implicit call to super() added by the compiler. You
can provide your own call to super(arguments) to control the way the parent parts are
initialized. If you do so, it must be the first statement of the constructor.
• A constructor can use overloaded constructor versions to support its work. These are
invoked using the syntax this(arguments) and if supplied, this call must be the first statement
of the constructor. In such conditions, the initialization of the parent class is performed in the
overloaded constructor

13
J2EE

1. Consider this class:
1. public class Test1 {
2. public float aMethod(float a, float b) {
3. }
4.
5. }
Which of the following methods would be legal if added (individually) at line 4? (Choose
all
that apply.)
A. public int aMethod(int a, int b) { }
B. public float aMethod(float a, float b) { }
C. public float aMethod(float a, float b, int c) throws Exception { }
D. public float aMethod(float c, float d) { }
E. private float aMethod(int a, int b, int c) { }
14
J2EE

1. A, C, E. In each of these answers, the argument list
differs from the original, so the method is an overload.
Overloaded methods are effectively independent, and
there are no constraints on the accessibility, return
type, or exceptions that may be thrown. B would be a
legal overriding method, except that it cannot be defined
in the same class as the original method; rather, it must
be declared in a subclass. D is also an override, because
the types of its arguments are the same: changing the
parameter names is not sufficient to count as overloading.

15
J2EE

2. Consider these classes, defined in separate source files:
1. public class Test1 {
2. public float aMethod(float a, float b)
3. throws IOException {...
4. }
5. }
1. public class Test2 extends Test1 {
2.
3. }
Which of the following methods would be legal (individually) at line 2 in class Test2? (Choose
all that apply.)
A. float aMethod(float a, float b) {...}
B. public int aMethod(int a, int b) throws Exception {...}
C. public float aMethod(float a, float b) throws Exception {...}
D. public float aMethod(float p, float q) {...}

16
J2EE

2. B, D. A is illegal because it is less accessible than
the original method; the fact that it throws no
exceptions is perfectly acceptable. B is legal because it
overloads the method of the parent class, and as such it
is not constrained by any rules governing its return
value, accessibility, or argument list. The exception
thrown by C is sufficient to make that method illegal. D is
legal because the accessibility and return type are
identical, and the method is an override because the
types of the arguments are identical—remember that the
names of the arguments are irrelevant. The absence of
an exception list in D is not a problem: An overriding
method may legitimately throw fewer exceptions than its
original, but it may not throw more.
17
J2EE

3. You have been given a design document for a veterinary registration system
for implementation
in Java. It states:
“A pet has an owner, a registration date, and a vaccination-due date. A cat is a pet that
has a
flag indicating whether it has been neutered, and a textual description of its markings.”
Given that the Pet class has already been defined, which of the following fields would
be
appropriate for inclusion in the Cat class as members? (Choose all that apply.)
A. Pet thePet;
B. Date registered;
C. Date vaccinationDue;
D. Cat theCat;
E. boolean neutered;
F. String markings;
18
J2EE

3. E, F. The Cat class is a subclass of the Pet class, and as
such should extend Pet, rather than contain
an instance of Pet. B and C should be members of the Pet class
and as such are inherited
into the Cat class; therefore, they should not be declared in the
Cat class. D would declare a reference
to an instance of the Cat class, which is not generally
appropriate inside the Cat class
(unless, perhaps, you were asked to give the Cat a member that
refers to its mother). Finally, the
neutered flag and markings descriptions, E and F, are the items
called for by the specification;
these are correct items.
19
J2EE

4. You have been given a design document for a veterinary registration system for
implementation
in Java. It states:
“A pet has an owner, a registration date, and a vaccination-due date. A cat is a pet that has a
flag indicating if it has been neutered, and a textual description of its markings.”
Given that the Pet class has already been defined and you expect the Cat class to be used
freely
throughout the application, how would you make the opening declaration of the Cat class, up
to but not including the first opening brace? Use only these words and spaces: boolean, Cat,
class, Date, extends, Object, Owner, Pet, private, protected, public, String.
A. protected class Cat extends Owner
B. public class Cat extends Object
C. public class Cat extends Pet
D. private class Cat extends Pet
20
J2EE

4. C. The class should be public, because it is to be used
freely throughout the application. The
statement “A cat is a pet” tells you that the Cat class should
subclass Pet. The other words
offered are required for the body of the definitions of either
Cat or Pet—for use as member
variables—but are not part of the opening declaration.

21
J2EE

5. Consider the following classes, declared
in separate source files:
1. public class Base {
2. public void method(int i) {
3. System.out.print(“Value is “ + i);
4. }
5. }
1. public class Sub extends Base {
2. public void method(int j) {
3. System.out.print(“This value is “ + j);
4. }
5. public void method(String s) {
6. System.out.print(“I was passed “ + s);
7. }
8. public static void main(String args[]) {
9. Base b1 = new Base();
10. Base b2 = new Sub();
11. b1.method(5);
12. b2.method(6);13. }14. }

What output results when the main
method of the class Sub is run?
A. Value is 5Value is 6
B. This value is 5This value is 6
C. Value is 5This value is 6
D. This value is 5Value is 6
E. I was passed 5I was passed 6

22
J2EE

5. C. The first message is produced by the Base class
when b1.method(5) is called and is therefore
Value is 5. Despite the fact that variable b2 is declared as
being of the Base class, the behavior
that results when method() is invoked upon it is the
behavior associated with the class of the
actual object, not with the type of the variable. Because the
object is of class Sub, not of class
Base, the second message is generated by line 3 of class
Sub: This value is 6.
23
J2EE

6. Consider the following class definition:
1. public class Test extends Base {
2. public Test(int j) {
3. }
4. public Test(int j, int k) {
5. super(j, k);
6. }
7. }
Which of the following are legitimate calls to construct instances of the Test class? (Choose all
that apply.)
A. Test t = new Test();
B. Test t = new Test(1);
C. Test t = new Test(1, 2);
D. Test t = new Test(1, 2, 3);
E. Test t = (new Base()).new Test(1);

24
J2EE

6. B, C. Because the class has explicit constructors
defined, the default constructor is suppressed,
so A is not possible. B and C have argument lists that
match the constructors defined at lines
2 and 4 respectively, and so they are correct constructions.
D has three integer arguments, but
there are no constructors that take three arguments of any
kind in the Test class, so D is incorrect.
Finally, E is a syntax used for construction of inner classes
and is therefore wrong.
25
J2EE

7. Consider the following class definition:
1. public class Test extends Base {
2. public Test(int j) {
3. }
4. public Test(int j, int k) {
5. super(j, k);
6. }
7. }
Which of the following forms of constructor must exist explicitly in the definition of the Base
class? Assume Test and Base are in the same package. (Choose all that apply.)
A. Base() { }
B. Base(int j) { }
C. Base(int j, int k) { }
D. Base(int j, int k, int l) { }
26
J2EE

7. A, C. The constructor at lines 2 and 3 includes no explicit call to either this() or
super(),
which means that the compiler will generate a call to the no-args superclass
constructor, as in A.
The explicit call to super() at line 5 requires that the Base class must have a
constructor as in
C. This requirement has two consequences. First, C must be one of the required
constructors and
therefore one of the answers. Second, the Base class must have at least that
constructor defined
explicitly, so the default constructor is not generated but must be added explicitly.
Therefore the
constructor of A is also required and must be a correct answer. At no point in the Test
class is
there a call to either a superclass constructor with one or three arguments, so B and D
need not
explicitly exist.
27
J2EE

11. Which of the following may override a method
whose signature is void xyz(float f)?
A. void xyz(float f)
B. public void xyz(float f)
C. private void xyz(float f)
D. public int xyz(float f)
E. private int xyz(float f)

28
J2EE

11. A, B. A uses the original method’s signature
verbatim, which is legal. B makes the subclass version
more accessible, which is legal. C makes the subclass
version less accessible, which is not
legal. D and E change the return type, which is not legal.

29
J2EE

19. Suppose class X contains the following method:
void doSomething(int a, float b) { … }
Which of the following methods may appear in class
Y, which extends X?
A. public void doSomething(int a, float b) { … }
B. private void doSomething(int a, float b) { … }
C. public void doSomething(int a, float b)
throws java.io.IOException { … }
D. private void doSomething(int a, float b)
throws java.io.IOException { … }
30
J2EE

19. A. A method with default access may be overridden
to have default, protected, or public access
but not private access, because a method may not be
overridden with more restrictive access. An
overriding method may not declare that it throws exception
types that do not appear in the
superclass version.

31
J2EE

20. This question involves IOException, AWTException, and
EOFException. They are all checked
exception types. IOException and AWTException extend
Exception, and EOFException extends
IOException. Suppose class X contains the following method:
void doSomething() throws IOException{ … }
Which of the following methods may appear in class Y, which
extends X?
A. void doSomething() { … }
B. void doSomething() throws AWTException { … }
C. void doSomething() throws EOFException { … }
D. void doSomething() throws IOException, EOFException {
…}
32
J2EE

20. A, C, D. An overriding method may throw an
unlimited number of exception types, provided all
types are the same as, or are descended from, the types
that appear in the overridden version’s
declared list of thrown exception types.

33
J2EE

Inner Classes
The complexity of inner classes relates to scope and access—particularly access to variables
in enclosing scopes. Before we consider these matters, let’s look at the syntax of a basic inner
class, which is really quite simple. Consider this example:
1. public class OuterOne {
2. private int x;
3. public class InnerOne {
4. private int y;
5. public void innerMethod() {
6. System.out.println(“y is “ + y);
7. }
8. }
9. public void outerMethod() {
10. System.out.println(“x is “ + x);
11. }
12. // other methods...
13. }
When an inner class is declared like this, the enclosing class name becomes part of the fully qualified
name of the inner class.
34
J2EE

The Enclosing this Reference and
Construction of Inner Classes
• When an instance of an inner class is created, normally a
preexisting instance of the outer class must act as
context.
• The accessibility of the members of the enclosing class is
crucial and very useful. It is possible because the inner
class has a hidden reference to the outer class instance
that was the current context when the inner class object
was created. In effect, it ensures that the inner class and
the outer class belong together, rather than the inner
instance being just another member of the outer instance.
35
J2EE

36
J2EE

37
J2EE

Static Inner Classes
• When applied to an inner class, the meaning is similar.
Specifically, a static inner class does not have any
reference to an enclosing instance. As a result,methods
of a static inner class cannot use the keyword this (either
implied or explicit) to access instance variables of the
enclosing class

38
J2EE

39
J2EE

40
J2EE

Classes Defined inside Methods
already seen, but in this case there are three particular
points to be considered. The first point is that anything
declared inside a method is not a member of the class but
is local to the method. The immediate consequence is
that classes declared in methods are private to the
method and cannot be marked with any access modifier;
neither can they be marked as static.

41
J2EE

Accessing Method Variables
• Any variable, either a local variable or a formal
parameter, can be accessed by methods within an inner
class, provided that variable is marked final.

42
J2EE

1. public class MOuter {
2. private int m = (int)(Math.random() * 100);

4. MOuter that = new MOuter();
5. that.go((int)(Math.random() * 100),
6. (int)(Math.random() * 100));
7. }
8.

9. public void go(int x, final int y) {
10. int a = x + y;
11. final int b = x - y;
12. class MInner {
13. public void method() {
14. System.out.println(“m is “ + m);
15. // System.out.println(“x is “ + x); //Illegal!
16. System.out.println(“y is “ + y);
17. // System.out.println(“a is “ + a); //Illegal!
18. System.out.println(“b is “ + b);
19. }
20. }
21.
22. MInner that = new MInner();
23. that.method();
24. }
25. }

43
J2EE

Anonymous Classes
1. public void aMethod() {
2. theButton.addActionListener(
3. new ActionListener() {
4. public void actionPerformed(ActionEvent e) {
5. System.out.println(“The action has occurred”);
6. }
7. }
8. );
9. }
44
J2EE

Construction and Initialization of
Anonymous Inner Classes
• You need to understand a few points about the construction
and initialization of anonymous inner classes to succeed in
the Certification Exam and in real life. Let’s look at these
issues. As you have already seen, the class is instantiated
and declared in the same place. This means that anonymous
inner classes are unique to method scopes; you cannot have
Anonymity with a member class.
• You cannot define any specific constructor for an anonymous
inner class. This is a direct consequence of the fact that you
do not specify a name for the class, and therefore you cannot
use that name to specify a constructor. However, an inner
class can be constructed with arguments under some
conditions, and an inner class can have an initializer if you
wish.
45
J2EE

Anonymous Class Declarations
• Xxxx anXxxx = new Xxxx () { /* class body. */ };
• someMethod(new Xxxx () { /* class body. */ });

46
J2EE

Passing Arguments into the
Construction of an Anonymous Inner
Class
If the anonymous inner class extends another class, and that parent class has constructors that
take arguments, then you can arrange for one of these constructors to be invoked by specifying
the argument list to the construction of the anonymous inner class. An example follows:

// Assume this code appears in some method
Button b = new Button(“Anonymous Button“) {
// behavior for the button
};
// do things with the button b...
...
In this situation, the compiler will build a constructor for your anonymous inner class that
effectively invokes the superclass constructor with the argument list provided, something like this:
// This is not code you write! This exemplifies what the // compiler creates internally when asked to compile // something like the previous
anonymous example

class AnonymousButtonSubclass extends Button {
public AnonymousButtonSubclass(String s) {
super(s); }}

47
J2EE

Initializing an Anonymous Inner
Class
Sometimes you will want to perform some kind of initialization when an inner class is
constructed. In normal classes, you would create a constructor. In an anonymous
inner class, you cannot do
this, but you can use the initializer feature that was added to the language at JDK 1.1.
If you provide an unnamed block in class scope, then it will be invoked as part of the
construction process, like this:
public MyClass {
{ // initializer
System.out.println(“Creating an instance”);
}
}

This is true of any class, but the technique is particularly useful with anonymous inner
classes, where it is the only tool you have that provides some control over the
construction process.
48
J2EE

1. import java.awt.*;
2. import java.awt.event.*;
3.

4. public class X extends Frame {

A Complex Exa
Inner Classes

6. X x = new X();
7. x.pack();
8. x.setVisible(true);
9. }

10.
11. private int count;
12.
13. public X() {
14. final Label l = new Label("Count = " + count);
15. add(l, BorderLayout.SOUTH);

16.
17. add(
18. new Button("Hello " + 1) {
19. // initializer
20. addActionListener(
21. new ActionListener() {
22. public void actionPerformed(
23. ActionEvent ev) {
24. count++;
25. l.setText("Count = " + count);
26. } } ); } }, BorderLayout.NORTH ); } }

49
J2EE

50
J2EE

17. Which of the following are true?
A. An anonymous inner class may implement at most one
interface.
B. An anonymous inner class may implement arbitrarily many
interfaces.
C. An anonymous inner class may extend a parent class other
than Object.
D. An anonymous inner class that implements one interface may
extend a parent class other
than Object.
E. An anonymous inner class that implements several interfaces
may extend a parent class
other than Object.
51
J2EE

17. A, C. An anonymous inner class may either
implement a single interface or extend a parent class
other than Object, but not both.

52
J2EE

15. Which of the following restrictions apply to
anonymous inner classes?
A. They must be defined inside a code block.
B. They may only read and write final variables of the
enclosing class.
C. They may only call final methods of the enclosing
class.
D. They may not call the enclosing class’ synchronized
methods.
53
J2EE

15. A. An anonymous inner class must appear inside a
block of code. There are no restrictions preventing
an anonymous inner class from accessing the enclosing
class’ non-final data or methods
or calling the enclosing class’ synchronized methods.

54
J2EE

8. Consider the following definition:
1. public class Outer {
2. public int a = 1;
3. private int b = 2;
4. public void method(final int c) {
5. int d = 3;
6. class Inner {
7. private void iMethod(int e) {
8.

9. }
10. }
11. }
12. }
Which variables can be referenced at line 8? (Choose all that apply.)
A. a
B. b
C. c
D. d
E. e

55
J2EE

8. A, B, C, E. Because Inner is not a static inner class, it
has a reference to an enclosing object, and all the
variables of that object are accessible. Therefore A and B
are correct, despite the fact that b is marked private.
Variables in the enclosing method are accessible only if
those variables are marked final, so the method argument
c is correct, but the variable d is not. Finally, the
parameter e is of course accessible, because it is a
parameter to the method containing line 8.

56
J2EE

9. Which of the following statements are true? (Choose all that apply.)
A. Given that Inner is a nonstatic class declared inside a public class Outer and that appropriate
constructor forms are defined, an instance of Inner can be constructed like this: new
Outer().new Inner()
B. If an anonymous inner class inside the class Outer is defined to implement the interface
ActionListener, it can be constructed like this: new Outer().new ActionListener()
C. Given that Inner is a nonstatic class declared inside a public class Outer and that appropriate
constructor forms are defined, an instance of Inner can be constructed in a static
method like this: new Inner()
D. An anonymous class instance that implements the interface MyInterface can be constructed
and returned from a method like this:
1. return new MyInterface(int x) {
2. int x;
3. public MyInterface(int x) {
4. this.x = x;5. }6. };

57
J2EE

9. A. Construction of a normal (that is, a named and
nonstatic) inner class requires an instance of
the enclosing class. Often this enclosing instance is
provided via the implied this reference, but an explicit
reference can be used in front of the new operator, as
shown in A. Anonymous inner classes can be instantiated
only at the same point they are declared, so B is illegal. C
is illegal because Inner is a nonstatic inner class, and so it
requires a reference to an enclosing instance when it is
constructed. D is illegal because it attempts to use
arguments to the constructor of an anonymous inner
class that implements an interface.
58
J2EE

Contracts and Naming Conventions

• The equals contract is described in detail on the API page for
java.lang.Object, in the equals() method description. It has
several parts, of which the most important are
• Any object should be equal to itself.
• If x equals y, then y equals x.
• If x equals y and y equals z, then x equals z.
• The version of equals() inherited from Object uses the ==
operator to test for equality. If you override this behavior, the
compiler has no way to know whether your new version
honors the contract. Your choices are to make sure it does or
to forego the benefits of, for example, the Collections
framework. If you violate the contract and use collections
anyway, the resulting bugs could be very difficult to track
down.
59
J2EE

The hash code contract specifies behavior of the
hashCode() method. A hash code is an int that represents
the uniqueness of an object; it is used by classes that
need an efficient way to determine whether two objects
contain different values. The contract is specified on the
API page for java.lang.Object, in the hashCode() method
description. It requires that if two objects areequal
according to their equals() methods, then they must have
equal hash codes. Note that the converse is not part of
the contract: it’s okay for two unequal objects to have the
same hash code.
60
J2EE

public class Point3d {
private int x, y, z;
public boolean equals(Object ob) {
Point3D that = (Point3D ob);
return this.x == that.x &&
this.y == that.y &&
this.z == that.z;
}
public int hashCode() {
return x + y + z;
}
}
Two instances of this class are equal if their x, y, and z values match.
Clearly the hash code contract is honored. Note that it is possible for
unequal instances to have equal hash codes. For example, one
instance might have values (100, 200, 300) while another has values
(600, 1, -1). This is acceptable. However, be aware that collection
classes might slow down when dealing with unequal objects with
equal hash codes
61
J2EE

A hash code algorithm should strike a reasonable balance
between detecting uniqueness and running efficiently. You
can avoid slowing down collections by writing hashCode()
methods that are scrupulous about uniqueness, but it does
you no good to speed up collection efficiency if your
scrupulous hashCode() methods are inefficient. For
example, you might wonder about the following alternative
hashCode() version for Point3D:
public int hashCode() {
return (int)(Math.pow(2, x) +
Math.pow(3, y) +
Math.pow(5, z));
}
62
J2EE

The JavaBeans naming convention
• The convention specifies a discipline for choosing names for
properties and the methods that access and modify them.
Specifically, A property name begins with a lowercase letter. All
subsequent letters are lowercase except for the first letter of a
new word. Underscores are not used. Examples:
bear, innerClass, normalizedRotationalInertia
• A method that returns the value of a property is named
getXxx(), where xxx is the property name. Example:
getInnerClass()
• A method that modifies the value of a property is named
setXxx(), where xxx is the property name. Example:
setNormalizedRotationalInertia()
63
J2EE

•

If the property is a boolean, the getter method's prefix is either get or is. For
example, getStopped() or isStopped() are both valid JavaBeans names for a boolean
property.

• The setter method's prefix must be set. For example, setSize() is the valid JavaBean name
for a property named size.
• To complete the name of a getter or setter method, change the first letter of the property
name to uppercase, and then append it to the appropriate prefix (get, is, or set).
• Setter method signatures must be marked public, with a void return type
and an argument that represents the property type.
•

Getter method signatures must be marked public, take no arguments, and

have a return type that matches the argument type of the setter method for
that property.

•

Listener method names used to "register" a listener with an event source must use the
prefix add, followed by the listener type. For example, addActionListener() is a valid name
for a method that an event source will have to allow others to register for Action events.

•

Listener method names used to remove ("unregister") a listener must use the prefix
remove, followed by the listener type (using the same rules as the registration add method).

•

The type of listener to be added or removed must be passed as the argument to the method.

64
J2EE

Examples of valid JavaBean method signatures are
public void setMyValue(int v)
public int getMyValue()
public boolean isMyStatus()
public void addMyListener(MyListener m)
public void removeMyListener(MyListener m)
Examples of invalid JavaBean method signatures are
void setCustomerName(String s) // must be public
public void modifyMyValue(int v) // can't use 'modify'
public void addXListener(MyListener m) // listener type
mismatch
65
J2EE

Enums
• 5.0 introduces the enum, which is a class with certain
added functionality and also certain restrictions.
• Enums are subclasses of java.lang.Enum.

66
J2EE

public class TrafficLight {
private int state; // 1 means red
// 2 means yellow
// 3 means green
public int getState() {
return state;
}
}
Assume that the class also contains timing code to change
the state at appropriate intervals.
67
J2EE

This class is extremely prone to error. Anyone who modifies the class or calls
getState() has to know that 1 means red, 2 means yellow, and 3 means green. If
anyone’s code gets confused even for a moment about which value means which
color, the resulting bug could be very difficult to track down.
The common solution is to introduce constants:
public class TrafficLight {
public final static int RED = 1;
public final static int YELLOW = 2;
public final static int GREEN = 3;
private int state;
public int getState() {
return state;
}
}
68
J2EE

This code compares the light’s state only to constants
defined in the TrafficLight class, never to literal integer
values. You can hope people who call getState() use this
approach;
you can insist they do so in daily e-mail memos; but you
can’t guarantee they will do so.
Our code so far has numerous drawbacks, especially these:
It is possible to assign an out-of-range value to a light’s
state. Printing a light’s state is not very informative.

69
J2EE

A more robust approach is shown here:
1. public class LightState {
2. protected final String name;
3.
4. public final static LightState RED = new LightState("red");
5. public final static LightState YELLOW = new LightState("yellow");
6. public final static LightState GREEN = new LightState("green");
7.
8. private LightState(String s) {
9. name = s;
10. }
11.
12. public String name() {
13. return name;
14. }
15. }

The new approach represents states by using instances of the LightState class, rather than
ints. Note that the constructor is private, so you can never construct any instances from
outside the class or its subclasses; the only instances you will ever need are constructed
statically.
70
J2EE

You can’t use the new class as a switch statement argument as you
could with the ints of the previous example, but that’s a small price
to pay. Our original switching code becomes
LightState state = nextTrafficLight.getState();
if (state == LightState.RED)
stop();
else if (state == LightState.YELLOW)
floorIt();
else if (state == LightState.GREEN)
proceed();
else
assert false : “null light state.”;
71
J2EE

• This design ensures that the only possibly unexpected
state value for a traffic light is null.
• Also, debugging code can print out any LightState
instance and produce an informative result. In fact, this
approach is so useful that it has a name: the typesafe
enumeration design pattern. It is considered typesafe
because there is a dedicated type whose sole purpose is
to encode a few enumerated states, thus avoiding the
dangers of using arbitrarily assigned int values.

72
J2EE

•
•
•
•

public class A extends Enum { } // erreur
public class A extends Option { } // erreur
public enum Option extends A { } // erreur
public enum Option extends Option { } // erreur

73
J2EE

public enum Age {
jeune(20), mure(40), agé(60), vieux(80), cadavérique(999);

Age(int année) {
this.année=année;
}
private final int année;
private static Age getAge(int année) {
for(Age age:Age.values())
if (age.année>=année)
return age;
return cadavérique;
}
public static void main(String[] args) {

System.out.println(getAge(
new Scanner(System.in).nextInt()));
} // 35 mure

74
J2EE

public enum Option {
l{
public void performs() {
System.out.println("long");
}
}, a {
System.out.println("all");
}
}, v {
System.out.println("verbose");
}
};
public abstract void performs();
public static void performs(Set<Option> set) {
for(Option option:set)
option.performs();
}
}

75
J2EE

public interface Performer {
public void performs();
}
public enum Option implements Performer {
l{
System.out.println("long");
}
},
a{
System.out.println("all");
}
};
}

76
J2EE

• You can declare an enum anywhere you can declare a class.
• Compiling an enum generates a .class file whose name is derived from
the enum’s name.
• Enums inherit data and methods from Object.
• Enums may be converted and cast according to the same rules that
govern any class that extends Object.
• Enums may have main() methods and can be invoked as applications.
• Enums that have no explicit constructors get default no-args
constructors.
• Enums have restricted functionality. They are unlike traditional classes
in the following ways:
• Enums are declared with the enum keyword rather than the class
keyword.
• Enums may not be instantiated.
• Enums may not extend anything and may not be extended.
• Enums may be arguments in switch statements.
• Enums have built-in name() and toString() methods, both of which
return the name of the current instance.
J2EE

77

switch (nextTrafficLight.getState()) {
case LightState.RED:
stop();
break;
case LightState.YELLOW:
floorIt();
break;
case LightState.GREEN:
proceed();
break;
default:
assert false: “null light state”;
public enum LightState {
}
RED, YELLOW, GREEN;
}

78
J2EE

enum Quark {
UP('u', 2.0/3.0),
DOWN('d', -1.0/3.0),
CHARM('c', 2.0/3.0),
STRANGE('s', -1.0/3.0),
TRUTH('t', 2.0/3.0),
BEAUTY('b', -1.0/3.0);
private final char symbol;
private final double charge;

Quark(char symbol, double charge){
this.symbol = symbol;
this.charge = charge;
}
public char getSymbol(){
return symbol;
}
public double getCharge(){
return charge;
}
}

79
J2EE

10. Which of the following are legal enums?
A. enum Animals { LION, TIGER, BEAR }
B. enum Animals {
int age;
LION, TIGER, BEAR;
}
C. enum Animals {
LION, TIGER, BEAR;
int weight;
}

D. enum Animals {
LION(450), TIGER(450), BEAR;
int weight;
Animals(int w) {
weight = w;
}
}
E. enum Animals {
LION(450), TIGER(450), BEAR;
int weight;
Animals() { }
Animals(int w) {
weight = w;

}
}

80
J2EE

10. C, E. A is illegal because the list of names must be
terminated by a semicolon. B is illegal because the list
of names must be the first element in the enum body. C is
a legal enum that contains, in addition to its name list, a
variable. D is illegal because the declaration of Bear
requires the existence of a no-args constructor. E fixes
the bug in D by adding a no-args constructor.

81
J2EE

12. Which of the following are true? (Choose all that
apply.)
• A. An enum definition should declare that it extends
java.lang.Enum.
• B. An enum may be subclassed.
• C. An enum may contain public method definitions.
• D. An enum may contain private data.

82
J2EE

12. C, D. Enums may not extend or be extended. They
may contain methods and data just like ordinary
classes.

83
J2EE

13. Which of the following are true? (Choose all that
apply.)
A. An enum definition may contain the main() method of
an application.
B. You can call an enum’s toString() method.
C. You can call an enum’s wait() method.
D. You can call an enum’s notify() method.

84
J2EE

13. A, B, C, D. Enums may contain public static void
main() methods and may serve as application main
classes. Enums inherit from Object, so they have
toString(), wait(), and notify() methods.

85
J2EE

14. Suppose x and y are of type TrafficLightState, which
is an enum. What is the best way to
test whether x and y refer to the same constant?
A. if (x == y)
B. if (x.equals(y))
C. if (x.toString().equals(y.toString()))
D. if (x.hashCode() == y.hashCode())

86
J2EE

14. A. It is never possible to have two instances of an enum
that represent the same value. So the == operator is
reliable, and it’s faster than any method call.

87
J2EE

16. Given the following code, which of the following will
compile?
enum Spice {
NUTMEG, CINNAMON, CORIANDER, ROSEMARY; }
A. Spice sp = Spice.NUTMEG; Object ob = sp;
B. Spice sp = Spice.NUTMEG; Object ob = (Object)sp;
C. Object ob = new Object(); Spice sp = object;
D. Object ob = new Object(); Spice sp = (Spice)object;

88
J2EE

16. A, B, D. Enums may be converted to Object, just like
other objects. So A and B are legal, though the cast in
B is not necessary. Assigning an Object reference to an
enum requires a cast, so C is illegal, but D is legal

89
J2EE

18. Which methods return an enum constant’s name?
A. getName()
B. name()
C. toString()
D. nameString()
E. getNameString()

90
J2EE

18. B, C. Both name() and toString() return a constant’s
name. name() is final, but toString() can be
overridden.

91
J2EE

chap 6 : Objects and classes (scjp/ocjp)

Recommended

More Related Content

What's hot (20)

Viewers also liked (19)

Similar to chap 6 : Objects and classes (scjp/ocjp) (20)

More from It Academy (19)

Recently uploaded (20)

chap 6 : Objects and classes (scjp/ocjp)