Chapter 10 Abstract Classes and Interfaces

Chapter 10 Abstract Classes and
Interfaces
Chapter 6 Arrays
Chapter 7 Objects and Classes
Chapter 8 Strings and Text I/O

GUI can be covered after §10.2, “Abstract Classes”
Chapter 9 Inheritance and Polymorphism Chapter 12 GUI Basics
§10.2, “Abstract Classes” Chapter 13 Graphics
§10.4, “Interfaces” Chapter 14 Event-Driven Programming
Chapter 11 Object-Oriented Design

Exception and binary I/O can be covered after Chapter 9
Chapter 17 Exceptions and Assertions
Chapter 18 Binary I/O
Liang, Introduction to Java Programming, Sixth Edition, (c) 2007 Pearson Education, Inc. All righ
ts reserved. 0-13-148952-6 1
Objectives
 To design and use abstract classes (§10.2).
 To process a calendar using the Calendar and GregorianCalendar classes (§10.3).
 To declare interfaces to model weak inheritance relationships (§10.4).
 To define a natural order using the Comparable interface (§10.4.1).
 To know the similarities and differences between an abstract class and an
interface (§10.4.2).
 To declare custom interfaces (§10.4.3).
 (Optional) To enable objects cloneable using the Cloneable interface (§10.4.4).
 To use wrapper classes (Byte, Short, Integer, Long, Float, Double, Character, and
Boolean) to wrap primitive data values into objects (§10.5).
 (Optional) To use the BigInteger and BigDecimal classes for computing very
large numbers with arbitrary precisions (§10.5.6).
 To create a generic sort method (§10.5).
 To simplify programming using JDK 1.5 automatic conversion between primitive
types and wrapper class types (§10.6).
 (Optional GUI) To handle GUI events (§10.7).
ts reserved. 0-13-148952-6 2
The abstract Modifier
 The abstract class
– Cannot be instantiated
– Should be extended and implemented in
subclasses
 The abstract method

– Method signature without
implementation
ts reserved. 0-13-148952-6 3
From Chapter 9
GeometricObject
-color: String The color of the object (default: white).
-filled: boolean Indicates whether the object is filled with a color (default: false).
-dateCreated: java.util.Date The date when the object was created.
+GeometricObject() Creates a GeometricObject.
+getColor(): String Returns the color.
+setColor(color: String): void Sets a new color.
+isFilled(): boolean Returns the filled property.
+setFilled(filled: boolean): void Sets a new filled property.
+getDateCreated(): java.util.Date Returns the dateCreated.
+toString(): String Returns a string representation of this object.
Circle Rectangle
-radius: double -width: double
+Circle() -height: double
+Circle(radius: double) +Rectangle()
+getRadius(): double +Rectangle(width: double, height: double)
+setRadius(radius: double): void +getWidth(): double
+getArea(): double +setWidth(width: double): void
+getPerimeter(): double +getHeight(): double
+getDiameter(): double +setHeight(height: double): void
+getArea(): double
+getPerimeter(): double
ts reserved. 0-13-148952-6 4
Abstract Classes
GeometricObject
-color: String
-filled: boolean
-dateCreated: java.util.Date
The # sign indicates
protected modifer #GeometricObject()
+getColor(): String
+setColor(color: String): void
+isFilled(): boolean
+setFilled(filled: boolean): void
+getDateCreated(): java.util.Date
+toString(): String
+getArea(): double
+getPerimeter(): double
GeometricObject
Circle Rectangle
-radius: double -width: double Circle
+Circle() -height: double
+Circle(radius: double) +Rectangle()
+getRadius(): double +Rectangle(width: double, height: double) Rectangle
+setRadius(radius: double): void +getWidth(): double
+getDiameter(): double +setWidth(width: double): void
+getHeight(): double
+setHeight(height: double): void
ts reserved. 0-13-148952-6 5
NOTE
An abstract method cannot be contained in
a nonabstract class. If a subclass of an
abstract superclass does not implement all
the abstract methods, the subclass must be
declared abstract. In other words, in a
nonabstract subclass extended from an
abstract class, all the abstract methods
must be implemented, even if they are not
used in the subclass.
ts reserved. 0-13-148952-6 6
NOTE
An abstract class cannot be instantiated
using the new operator, but you can still
define its constructors, which are invoked
in the constructors of its subclasses. For
instance, the constructors of
GeometricObject are invoked in the Circle
class and the Rectangle class.
ts reserved. 0-13-148952-6 7
NOTE
A class that contains abstract methods
must be abstract. However, it is possible to
declare an abstract class that contains no
abstract methods. In this case, you cannot
create instances of the class using the new
operator. This class is used as a base class
for defining a new subclass.
ts reserved. 0-13-148952-6 8
NOTE
A subclass can be abstract even if its
superclass is concrete. For example, the
Object class is concrete, but its subclasses,
such as GeometricObject, may be abstract.
ts reserved. 0-13-148952-6 9
NOTE
A subclass can override a method from its
superclass to declare it abstract. This is
rare, but useful when the implementation
of the method in the superclass becomes
invalid in the subclass. In this case, the
subclass must be declared abstract.
ts reserved. 0-13-148952-6 10
NOTE
You cannot create an instance from an
abstract class using the new operator, but
an abstract class can be used as a data
type. Therefore, the following statement,
which creates an array whose elements are
of GeometricObject type, is correct.
GeometricObject[] geo = new
GeometricObject[10];
ts reserved. 0-13-148952-6 11
Example: Using the GeometricObject
Class
 Objective: This example creates two geometric
objects: a circle, and a rectangle, invokes the
equalArea method to check if the two objects
have equal area, and invokes the
displayGeometricObject method to display the
objects.
TestGeometricObject Run
ts reserved. 0-13-148952-6 12
The Abstract Calendar Class and Its
GregorianCalendar subclass
java.util.Calendar
#Calendar() Constructs a default calendar.
+get(field: int): int Returns the value of the given calendar field.
+set(field: int, value: int): void Sets the given calendar to the specified value.
+set(year: int, month: int, Sets the calendar with the specified year, month, and date. The month
dayOfMonth: int): void parameter is 0-based, that is, 0 is for January.
+getActualMaximum(field: int): int Returns the maximum value that the specified calendar field could have.
+add(field: int, amount: int): void Adds or subtracts the specified amount of time to the given calendar field.
+getTime(): java.util.Date Returns a Date object representing this calendar’s time value (million
second offset from the Unix epoch).
+setTime(date: java.util.Date): void Sets this calendar’s time with the given Date object.
java.util.GregorianCalendar
+GregorianCalendar() Constructs a GregorianCalendar for the current time.
+GregorianCalendar(year: int, Constructs a GregorianCalendar for the specified year, month, and day of
month: int, dayOfMonth: int) month.
+GregorianCalendar(year: int, Constructs a GregorianCalendar for the specified year, month, day of
month: int, dayOfMonth: int, month, hour, minute, and second. The month parameter is 0-based, that
hour:int, minute: int, second: int) is, 0 is for January.
ts reserved. 0-13-148952-6 13
The Abstract Calendar Class and Its
GregorianCalendar subclass
An instance of java.util.Date represents a specific
instant in time with millisecond precision.
java.util.Calendar is an abstract base class for
extracting detailed information such as year, month,
date, hour, minute and second from a Date object.
Subclasses of Calendar can implement specific
calendar systems such as Gregorian calendar, Lunar
Calendar and Jewish calendar. Currently,
java.util.GregorianCalendar for the Gregorian
calendar is supported in the Java API.
ts reserved. 0-13-148952-6 14
The GregorianCalendar Class
You can use new GregorianCalendar() to construct
a default GregorianCalendar with the current time
and use new GregorianCalendar(year, month, date)
to construct a GregorianCalendar with the specified
year, month, and date. The month parameter is 0-
based, i.e., 0 is for January.
ts reserved. 0-13-148952-6 15
The get Method in Calendar Class
The get(int field) method defined in the Calendar class is
useful to extract the value for a given time field. The time
fields are defined as constants such as YEAR, MONTH,
DATE, HOUR (for the 12-hour clock), HOUR_OF_DAY
(for the 24-hour clock), MINUTE, SECOND,
DAY_OF_WEEK (the day number within the current week
with 1 for Sunday), DAY_OF_MONTH (same as the
DATE value), DAY_OF_YEAR (the day number within
the current year with 1 for the first day of the year),
WEEK_OF_MONTH (the week number within the current
month), and WEEK_OF_YEAR (the week number within
the current year). For example, the following code
ts reserved. 0-13-148952-6 16
Optional Path
You may cover Chapter 12, “GUI Basics”, and
Chapter 13, “Graphics,” now. See the Chapter
Dependency Chart.
ts reserved. 0-13-148952-6 17
Interfaces
An interface is a classlike construct that contains only
constants and abstract methods. In many ways, an interface
is similar to an abstract class, but an abstract class can
contain variables and concrete methods as well as constants
and abstract methods.
To distinguish an interface from a class, Java uses the

following syntax to declare an interface:
public interface InterfaceName {

constant declarations;
method signatures;
}
ts reserved. 0-13-148952-6 18
Interface is a Special Class
An interface is treated like a special class in Java.
Each interface is compiled into a separate bytecode
file, just like a regular class. Like an abstract class,
you cannot create an instance from an interface
using the new operator, but in most cases you can
use an interface more or less the same way you use
an abstract class. For example, you can use an
interface as a data type for a variable, as the result
of casting, and so on.
ts reserved. 0-13-148952-6 19
Define Interfaces
Suppose you want to design a generic method to
find the larger of two objects. The objects can be
students, dates, or circles. Since compare methods
are different for different types of objects, you
need to define a generic compare method to
determine the order of the two objects. Then you
can tailor the method to compare students, dates, or
circles. For example, you can use student ID as the
key for comparing students, radius as the key for
comparing circles, and volume as the key for
comparing dates. You can use an interface to
define a generic compareTo method, as follows:
ts reserved. 0-13-148952-6 20
Example of an Interface
// This interface is defined in

// java.lang package
package java.lang;
public interface Comparable {

public int compareTo(Object o);
}
ts reserved. 0-13-148952-6 21
String and Date Classes
Many classes (e.g., String and Date) in the Java library
implement Comparable to define a natural order for the
objects. If you examine the source code of these classes,
you will see the keyword implements used in the classes,
as shown below:
public class String extends Object public class Date extends Object
implements Comparable { implements Comparable {
// class body omitted // class body omitted
} }
new String() instanceof String

new String() instanceof Comparable
new java.util.Date() instanceof java.util.Date
new java.util.Date() instanceof Comparable
ts reserved. 0-13-148952-6 22
Generic max Method
// Max.java: Find a maximum object // Max.java: Find a maximum object
public class Max { public class Max {
/** Return the maximum of two objects */ /** Return the maximum of two objects */
public static Comparable max public static Object max
(Comparable o1, Comparable o2) { (Object o1, Object o2) {
if (o1.compareTo(o2) > 0) if (((Comparable)o1).compareTo(o2) > 0)
return o1; return o1;
else else
return o2; return o2;
} }
} }
(a) (b)
String s1 = "abcdef"; Date d1 = new Date();

String s2 = "abcdee"; Date d2 = new Date();
String s3 = (String)Max.max(s1, s2); Date d3 = (Date)Max.max(d1, d2);
The return value from the max method is of the Comparable

type. So, you need to cast it to String or Date explicitly.
ts reserved. 0-13-148952-6 23
Declaring Classes to Implement Comparable
Notation: GeometricObject «interface»
The interface name and the - java.lang.Comparable
method names are italicized.
The dashed lines and hollow Rectangle +compareTo(o: Object): int
triangles are used to point to -
the interface.
ComparableRectangle
-
ComparableRectangle
You cannot use the max method to find the larger of two instances of Rectangle,
because Rectangle does not implement Comparable. However, you can declare a
new rectangle class that implements Comparable. The instances of this new class
are comparable. Let this new class be named ComparableRectangle.
ComparableRectangle rectangle1 = new ComparableRectangle(4, 5);

ComparableRectangle rectangle2 = new ComparableRectangle(3, 6);
System.out.println(Max.max(rectangle1, rectangle2));
ts reserved. 0-13-148952-6 24
Interfaces vs. Abstract Classes
In an interface, the data must be constants; an abstract class can
have all types of data.
Each method in an interface has only a signature without
implementation; an abstract class can have concrete methods.
Variables Constructors Methods
Abstract No restrictions Constructors are invoked by subclasses No restrictions.

class through constructor chaining. An abstract
class cannot be instantiated using the new
operator.
Interface All variables No constructors. An interface cannot be All methods must be

must be public instantiated using the new operator. public abstract
static final instance methods
ts reserved. 0-13-148952-6 25
Interfaces vs. Abstract Classes, cont.
All data fields are public final static and all methods are public abstract in an
interface. For this reason, these modifiers can be omitted, as shown below:
public interface T1 { public interface T1 {

public static final int K = 1; Equivalent int K = 1;
public abstract void p(); void p();

} }
A constant defined in an interface can be accessed using syntax

InterfaceName.CONSTANT_NAME (e.g., T1.K).
ts reserved. 0-13-148952-6 26
Interfaces vs. Abstract Classes, cont.
All classes share a single root, the Object class, but there is no single root for
interfaces. Like a class, an interface also defines a type. A variable of an interface
type can reference any instance of the class that implements the interface. If a class
extends an interface, this interface plays the same role as a superclass. You can use
an interface as a data type and cast a variable of an interface type to its subclass,
and vice versa.
Interface1_2 Interface2_2
Interface1_1 Interface1 Interface2_1
Object Class1 Class2
Suppose that c is an instance of Class2. c is also an instance of Object, Class1,

Interface1, Interface1_1, Interface1_2, Interface2_1, and Interface2_2.
ts reserved. 0-13-148952-6 27
Caution: conflict interfaces
In rare occasions, a class may implement two interfaces
with conflict information (e.g., two same constants with
different values or two methods with same signature but
different return type). This type of errors will be detected
by the compiler.
ts reserved. 0-13-148952-6 28
Whether to use an interface or a class?
Abstract classes and interfaces can both be used to model common
features. How do you decide whether to use an interface or a class?
In general, a strong is-a relationship that clearly describes a parent-
child relationship should be modeled using classes. For example, a
staff member is a person. So their relationship should be modeled
using class inheritance. A weak is-a relationship, also known as an
is-kind-of relationship, indicates that an object possesses a certain
property. A weak is-a relationship can be modeled using interfaces.
For example, all strings are comparable, so the String class
implements the Comparable interface. You can also use interfaces
to circumvent single inheritance restriction if multiple inheritance is
desired. In the case of multiple inheritance, you have to design one
as a superclass, and others as interface. See Chapter 10, “Object-
Oriented Modeling,” for more discussions.
ts reserved. 0-13-148952-6 29
Creating Custom Interfaces
public interface Edible {
/** Describe how to eat */
class abstract Fruit
public String howToEat();
implements Edible {
}
}
class Animal { class Apple extends Fruit {

} public String howToEat() {
return "Make apple cider";
class Chicken extends Animal }
implements Edible { }
public String howToEat() {
return "Fry it"; class Orange extends Fruit {
} public String howToEat() {
} return "Make orange juice";
}
class Tiger extends Animal { }
}
ts reserved. 0-13-148952-6 30
Implements Multiple Interfaces
class Chicken extends Animal implements Edible, Comparable {
int weight;
public Chicken(int weight) {
this.weight = weight;
}
public String howToEat() {
return "Fry it";
}
public int compareTo(Object o) {
return weight – ((Chicken)o).weight;
}
}
ts reserved. 0-13-148952-6 31
Creating Custom Interfaces, cont.
public interface Edible {
/** Describe how to eat */
public String howToEat();
}
public class TestEdible {

public static void main(String[] args) {
Object[] objects = {new Tiger(), new Chicken(), new Apple()};
for (int i = 0; i < objects.length; i++)
showObject(objects[i]);
}
public static void showObject(Object object) {

if (object instanceof Edible)
System.out.println(((Edible)object).howToEat());
}
}
ts reserved. 0-13-148952-6 32
The Cloneable Interfaces
Marker Interface: An empty interface.
A marker interface does not contain constants or methods.
It is used to denote that a class possesses certain desirable
properties. A class that implements the Cloneable
interface is marked cloneable, and its objects can be
cloned using the clone() method defined in the Object
class.
package java.lang;
public interface Cloneable {
}
ts reserved. 0-13-148952-6 33
Examples
Many classes (e.g., Date and Calendar) in the Java library implement
Cloneable. Thus, the instances of these classes can be cloned. For
example, the following code
Calendar calendar = new GregorianCalendar(2003, 2, 1);

Calendar calendarCopy = (Calendar)calendar.clone();
System.out.println("calendar == calendarCopy is " +
(calendar == calendarCopy));
System.out.println("calendar.equals(calendarCopy) is " +
calendar.equals(calendarCopy));

displays
calendar == calendarCopy is false
calendar.equals(calendarCopy) is true
ts reserved. 0-13-148952-6 34
Implementing Cloneable Interface
To declare a custom class that implements the Cloneable
interface, the class must override the clone() method in
the Object class. The following code declares a class
named House that implements Cloneable and
Comparable.
House
ts reserved. 0-13-148952-6 35
Shallow vs. Deep Copy
House house1 = new House(1, 1750.50);
House house2 = (House)house1.clone();
house1: House Memory
id = 1 1
area = 1750.50 1750.50
whenBuilt reference whenBuilt: Date
house2 = house1.clone() date object contents
house1: House Memory
id = 1 1
area = 1750.50 1750.50
whenBuilt reference
ts reserved. 0-13-148952-6 36
Wrapper Classes
 Boolean  Integer NOTE: (1) The wrapper classes do
not have no-arg constructors. (2)
 Character  Long The instances of all wrapper
classes are immutable, i.e., their
 Short
 Float
internal values cannot be changed
 Double once the objects are created.
 Byte
Comparable Object
- -
Number Character Boolean

- - -
Double Float Long Integer Short Byte

- - - - - -
ts reserved. 0-13-148952-6 37
The toString, equals, and hashCode
Methods
Each wrapper class overrides the toString,
equals, and hashCode methods defined in the
Object class. Since all the numeric wrapper
classes and the Character class implement the
Comparable interface, the compareTo
method is implemented in these classes.
ts reserved. 0-13-148952-6 38
The Number Class
Each numeric wrapper class extends the
abstract Number class, which contains the
methods doubleValue, floatValue, intValue,
longValue, shortValue, and byteValue. These
methods “convert” objects into primitive type
values. The methods doubleValue, floatValue,
intValue, longValue are abstract. The methods
byteValue and shortValue are not abstract,
which simply return (byte)intValue() and
(short)intValue(), respectively.
ts reserved. 0-13-148952-6 39
The Integer and Double Classes
java.lang.Number java.lang.Integer
-value: int
+byteValue(): byte +MAX_VALUE: int
+shortValue(): short +MIN_VALUE: int
+intValue(): int
+longVlaue(): long +Integer(value: int)
+floatValue(): float +Integer(s: String)
+doubleValue():double +valueOf(s: String): Integer
+valueOf(s: String, radix: int): Integer
+parseInt(s: String): int
java.lang.Comparable +parseInt(s: String, radix: int): int
+compareTo(o: Object): int

java.lang.Double
-value: double
+MAX_VALUE: double
+MIN_VALUE: double
+Double(value: double)
+Double(s: String)
+valueOf(s: String): Double
+valueOf(s: String, radix: int): Double
+parseDouble(s: String): double
+parseDouble (s: String, radix: int): double
ts reserved. 0-13-148952-6 40
The Integer Class
and the Double Class
 Constructors
 Class Constants MAX_VALUE, MIN_VALUE
 Conversion Methods
ts reserved. 0-13-148952-6 41
Numeric Wrapper Class Constructors
You can construct a wrapper object either from a
primitive data type value or from a string
representing the numeric value. The constructors
for Integer and Double are:
public Integer(int value)
public Integer(String s)
public Double(double value)
public Double(String s)
ts reserved. 0-13-148952-6 42
Numeric Wrapper Class Constants
Each numerical wrapper class has the constants
MAX_VALUE and MIN_VALUE. MAX_VALUE
represents the maximum value of the corresponding
primitive data type. For Byte, Short, Integer, and Long,
MIN_VALUE represents the minimum byte, short, int,
and long values. For Float and Double, MIN_VALUE
represents the minimum positive float and double values.
The following statements display the maximum integer
(2,147,483,647), the minimum positive float (1.4E-45),
and the maximum double floating-point number
(1.79769313486231570e+308d).
ts reserved. 0-13-148952-6 43
Conversion Methods
Each numeric wrapper class implements the
abstract methods doubleValue, floatValue,
intValue, longValue, and shortValue, which
are defined in the Number class. These
methods “convert” objects into primitive
type values.
ts reserved. 0-13-148952-6 44
The Static valueOf Methods
The numeric wrapper classes have a useful
class method, valueOf(String s). This method
creates a new object initialized to the value
represented by the specified string. For
example:

Double doubleObject = Double.valueOf("12.4");
Integer integerObject = Integer.valueOf("12");
ts reserved. 0-13-148952-6 45
The Methods for Parsing Strings into
Numbers
You have used the parseInt method in the
Integer class to parse a numeric string into an
int value and the parseDouble method in the
Double class to parse a numeric string into a
double value. Each numeric wrapper class
has two overloaded parsing methods to parse
a numeric string into an appropriate numeric
value.
ts reserved. 0-13-148952-6 46
Example: Sorting an Array of Objects
Objective: The example presents a generic

method for sorting an array of objects. The
objects are instances of the Comparable interface
and they are compared using the compareTo
method.
GenericSort Run
ts reserved. 0-13-148952-6 47
TIP
Java provides a static sort method for sorting an
array of Object in the java.util.Arrays class. So
you can use the following code to sort arrays in
this example:
java.util.Arrays.sort(intArray);
java.util.Arrays.sort(doubleArray);
java.util.Arrays.sort(charArray);
java.util.Arrays.sort(stringArray);
ts reserved. 0-13-148952-6 48
NOTE
Arrays are objects. An array is an instance of the
Object class. Furthermore, if A is a subclass of B,
every instance of A[] is an instance of B[].
Therefore, the following statements are all true:
new int[10] instanceof Object

new GregorianCalendar[10] instanceof Calendar[];
new Calendar[10] instanceof Object[]
new Calendar[10] instanceof Object
ts reserved. 0-13-148952-6 49
CAUTION
Although an int value can be assigned to a double
type variable, int[] and double[] are two
incompatible types. Therefore, you cannot assign
an int[] array to a variable of double[] or Object[]
type.
ts reserved. 0-13-148952-6 50
JDK 1.5 Automatic Conversion Between Primitive
Feature
Types and Wrapper Class Types
JDK 1.5 allows primitive type and wrapper classes to be converted automatically. For
example, the following statement in (a) can be simplified as in (b):
Equivalent
Integer[] intArray = {new Integer(2), Integer[] intArray = {2, 4, 3};
new Integer(4), new Integer(3)};
(a) New JDK 1.5 boxing (b)
Integer[] intArray = {1, 2, 3};

System.out.println(intArray[0] + intArray[1] + intArray[2]);
Unboxing
ts reserved. 0-13-148952-6 51
NOTE to Instructor
Optional path:
You may cover Chapter 14, “Event-Driven

Programming,” or Chapter 21, “Generics,” now
ts reserved. 0-13-148952-6 52
Optional
GUI
Handling GUI Events
Source object (e.g., button)

Listener object contains a method for
processing the event.
HandleEvent Run
ts reserved. 0-13-148952-6 53
animation
Trace Execution
public class HandleEvent extends JFrame {
public HandleEvent() { 1. Start from the
… main method to
OKListenerClass listener1 = new OKListenerClass(); create a window and
jbtOK.addActionListener(listener1); display it
…
}

…
}
}
class OKListenerClass implements ActionListener {

public void actionPerformed(ActionEvent e) {
System.out.println("OK button clicked");
}
}
ts reserved. 0-13-148952-6 54
animation
Trace Execution
public HandleEvent() { 2. Click OK
…
OKListenerClass listener1 = new OKListenerClass();
jbtOK.addActionListener(listener1);
…
}

…
}
}

}
}
ts reserved. 0-13-148952-6 55
animation
Trace Execution
public HandleEvent() { 3. Click OK. The
… JVM invokes the
OKListenerClass listener1 = new OKListenerClass(); listener’s
jbtOK.addActionListener(listener1); actionPerformed
… method
}

…
}
}

}
}
ts reserved. 0-13-148952-6 56

Chapter 10 Abstract Classes and Interfaces

Uploaded by

Document Informationclick to expand document information

Copyright:

Available Formats

Chapter 10 Abstract Classes and Interfaces

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chapter 10 Abstract Classes and Interfaces

Uploaded by

Copyright:

Available Formats

Chapter 10 Abstract Classes and

Chapter 7 Objects and Classes

Chapter 8 Strings and Text I/O

Chapter 9 Inheritance and Polymorphism Chapter 12 GUI Basics

§10.2, “Abstract Classes” Chapter 13 Graphics

§10.4, “Interfaces” Chapter 14 Event-Driven Programming

Chapter 11 Object-Oriented Design

Chapter 17 Exceptions and Assertions

Chapter 18 Binary I/O

 The abstract method

To distinguish an interface from a class, Java uses the

public interface InterfaceName {

// This interface is defined in

public interface Comparable {

new String() instanceof String

String s1 = "abcdef"; Date d1 = new Date();

The return value from the max method is of the Comparable

ComparableRectangle rectangle1 = new ComparableRectangle(4, 5);

Variables Constructors Methods

Abstract No restrictions Constructors are invoked by subclasses No restrictions.

Interface All variables No constructors. An interface cannot be All methods must be

public interface T1 { public interface T1 {

public abstract void p(); void p();

A constant defined in an interface can be accessed using syntax

Interface1_1 Interface1 Interface2_1

Object Class1 Class2

Suppose that c is an instance of Class2. c is also an instance of Object, Class1,

class Animal { class Apple extends Fruit {

public class TestEdible {

public static void showObject(Object object) {

Calendar calendar = new GregorianCalendar(2003, 2, 1);

house1: House Memory

house2 = house1.clone() date object contents

house1: House Memory

Number Character Boolean

Double Float Long Integer Short Byte

+compareTo(o: Object): int

 Class Constants MAX_VALUE, MIN_VALUE

Objective: The example presents a generic

new int[10] instanceof Object

(a) New JDK 1.5 boxing (b)

Integer[] intArray = {1, 2, 3};

You may cover Chapter 14, “Event-Driven

Source object (e.g., button)

public static void main(String[] args) {

class OKListenerClass implements ActionListener {

public static void main(String[] args) {

class OKListenerClass implements ActionListener {

public static void main(String[] args) {

class OKListenerClass implements ActionListener {

You might also like