Transcript
Computer Science Notes
Chapter 14: Abstract Classes and Interfaces
These notes are meant to accompany Introduction to Java Programming: Brief Version, eighth edition by Y. Daniel Lang.
Programming Skills in a Nutshell:
At the end of this chapter you should have the following programming skills:
To recognize when to create an interface that gives common functionality across several classes.
To recognize when to create an abstract class.
To correctly overload or override methods of a superclass in one of its subclasses.
To correctly implement some of the fundamental methods in the Object superclass.
Abstract classes and interfaces are two ways of guaranteeing that classes have the same behavior in certain ways.
Abstract classes are used when the classes are arranged in a hierarchy.
Example: circles, rectangles, and triangles are all subcases of geometric objects that have areas and perimeters.
they can all have getArea() and getPerimeter() methods (“common behavior”), even though the calculations behind those methods are different.
Interfaces are used when the classes are not hierarchical.
Classes for automobiles and humans are not hierarchical, but both objects have mass… both can have a getMass() method
Book’s Statement of Skills:
To design and use abstract classes. (11.2)
To process a calendar using the Calendar and GregorianCalendar classes. (11.3)
To specify common behavior for objects using interfaces. (11.4)
To define interfaces and declare classes that implement interfaces. (11.4)
To define a natural order using the Comparable interface. (11.5)
To enable objects to listen for action events using the ActionListener interface. (11.6)
To make objects cloneable using the Cloneable interface. (11.7)
To explore the differences between an abstract class and an interface. (11.8)
To create objects for primitive values using the wrapper classes Byte, Short, Integer, Long, Float, Double, Character, and Boolean). (11.9)
To create a generic sort method. (11.10)
To simplify programming using automatic conversion between primitive types and wrapper class types. (11.11)
To use the BigInteger and BigDecimal classes for computing very large numbers with arbitrarily high precision. (11.12)
Section 11.1: Introduction
An abstract class is a superclass that is so “abstract” it can not have any specific instances. An abstract class is meant as a template for its subclasses rather than a class that can actually be instantiated.
An interface is a collection of similarly-behaving methods that one wants a variety of classes to possess, even if those classes are not in an inheritance hierarchy. An interface can not be instantiated, either; only the classes that implement the interface (and thus all have a common method) can be instantiated (just like only the subclasses of an abstract class can be instantiated). Interfaces are meant to give the effect of multiple inheritance (Java only allows single inheritance).
Section 11.2: Abstract Classes
Class design should ensure that a superclass contains common features of its subclasses.
When the common features (i.e., methods) must be implemented differently for each subclass, then the method is declared to be abstract, which means that the subclasses must implement the methods specified by the abstract parent class.
The names of abstract classes and methods are italicized in UML diagrams.
See the UML diagram below for how Lab #9: Geometric Objects in Hierarchy could be re-organized using abstract classes and methods.
Abstract classes are like regular classes with data fields and methods, but you can’t create an instance of them with the new operator.
See www.cs.armstrong.edu/liang/intro7e/book/GeometricObject.java
See www.cs.armstrong.edu/liang/intro7e/book/Circle.java
See www.cs.armstrong.edu/liang/intro7e/book/Rectangle.java
Section 11.2.1: Why Abstract Methods?
Note one advantage is that since all GeometricObject2D objects are guaranteed to have a getArea() method, your Pyramid class does not have to fool around with figuring out what type of object the base is made of: a Rectangle or a Triangle.
See www.cs.armstrong.edu/liang/intro7e/book/TestGeometricObject.java
Section 11.2.2: Interesting Points on Abstract Classes
Abstract method can’t be in a concrete (i.e., non-abstract) class.
Abstract classes can’t be instantiated, but can still have constructors.
Abstract methods must be in abstract classes, but abstract classes don’t need to have abstract methods.
An abstract subclass can have a concrete superclass.
A subclass can override a superclass method to be abstract.
Abstract classes can be a data type.
Section 11.3: Example: Calendar and GregorianCalendar
The java.util.Date class is a basic class for representing an instant in time with millisecond precision.
The java.util.Calendar class is an abstract class for extracting detailed calendar info about an instant in time.
Concrete subclasses of Calendar can implement specific calendar systems, like Gregorian, lunar, or Jewish calendars.
Currently, the only standard class supported in Java is the java.util.GregorianCalendar class.
See http://java.sun.com/javase/6/docs/api/
See http://java.sun.com/javase/6/docs/api/java/util/Calendar.html
See http://java.sun.com/javase/6/docs/api/java/util/GregorianCalendar.html
See www.cs.armstrong.edu/liang/intro7e/book/TestCalendar.java
Section 11.4: Interfaces
An interface is a classlike construct that contains only constants and abstract methods.
An interface is similar to an abstract class, but its intent is to specify common behavior across objects not in the same hierarchy.
Syntax for an interface:
modifier interface InterFaceName
{
/** Constant declarations */
/** Method signatures */
}
As with an abstract class, you cannot create an instance of an interface (e.g., with the new operator), but an interface can be used in similar ways, like as a data type for a variable, and as the result of casting.
To state that a class you write will implement the methods in an interface, you use the keyword implements followed by a comma-separated list of the interfaces the class implements.
See www.cs.armstrong.edu/liang/intro7e/book/TestEdible.java
See www.cs.armstrong.edu/liang/intro7e/book/Edible.java
All methods are modified as public abstract in an interface.
All data fields are modified as public final static in an interface.
Since these must always be the modifiers, they may be omitted…
Constants can be accessed in an interface using InterfaceName.CONSTANT_NAME
Section 11.5: Example: The Comparable Interface
The Java API has an interface called Comparable that contains a single method: compareTo(Object o)
See http://java.sun.com/javase/6/docs/api/java/lang/Comparable.html
Classes that implement the Comparable interface can be compared and ordered using the compareTo method.
Many classes like String and Date implement the Comparable interface.
e1.compareTo(e2) is supposed to return a negative integer, zero, or positive integer if e1 is less than, equal to, or greater than e2 (respectively).
See www.cs.armstrong.edu/liang/intro7e/book/ComparableRectangle.java
Section 11.6: Example: The ActionListener Interface
In order for your program to respond to events like mouse clicks, right-clicks, etc., you need to:
Include a source object in your program that will respond to an event (like a JButton object)
create an object that handles the action event; this object must implement the ActionListener interface and its lone method of
actionPerformed(ActionEvent e)
register the ActionListener object with the source object using the addActionListener(ActionListener a) method.
See www.cs.armstrong.edu/liang/intro7e/book/HandleEvent.java
Section 11.7: Example: The Cloneable Interface
The Java API has another interface called Cloneable that simply marks whether implementing classes can be cloned (i.e., code exists for a copy to be made) using the clone() method of the Object class.
To declare a custom class that implements the Cloneable interface, the class must overrides the clone() method of the Object class.
At the least, your clone() method should use super.clone(), which returns a “shallow copy” with copies of the primitive data fields and references copied into reference fields.
this means that the clone’s reference fields refers to the same memory locations as the original, and not to new memory locations…
To perform a “deep copy”, you have to write code to create new objects for the reference data fields…
See www.cs.armstrong.edu/liang/intro7e/book/House.java
Section 11.8: Interfaces vs. Abstract Classes
Interfaces can have constants and abstract methods only, whereas abstract classes do not have these restrictions.
Class extension is restricted to single inheritance, but interfaces allow for multiple inheritance.
Interfaces can inherit from other interfaces using the extends keyword.
There is no root class for interfaces, unlike classes which all inherit ultimately from the Object class.
Section 11.9: Processing Primitive Data Type Values as Objects
Java has immutable “wrapper classes” built in for every primitive data type with a data field for the primitive type, and several additional methods that do things like convert back and forth between strings and other primitive data types.
Section 11.10: Sorting an Array of Objects
See www.cs.armstrong.edu/liang/intro7e/book/GenericSort.java
Section 11.11: Automatic Conversion between Primitive Types and Wrapper Class Types
The compiler allows you to can instantiate a wrapper class without using the standard constructor syntax; just set the wrapper class object equal to a primitive data value.
Section 11.12: The BigInteger and BigDecimal Classes
…allow you to store arbitrarily large integers and decimal numbers…
