Transcript Koffman_Ch03

Inheritance and Class Hierarchies
Chapter 3
Chapter Objectives
• To understand inheritance and how it facilitates code
reuse
• To understand how Java determines which method to
execute when there are multiple methods with the same
name in a class hierarchy
• To learn how to define and use abstract classes as base
classes in a hierarchy
• To study class Object and its methods and to learn how
to override them
• To learn how to “clone” an object and to understand the
difference between a true clone (deep copy) and a
shallow copy
Chapter 3: Inheritance and Class Hierarchies
2
Chapter Objectives (continued)
• To understand why Java does not implement multiple
inheritance and to see how you can gain some of the
advantages of multiple inheritance through interfaces
and delegation
• To become familiar with a class hierarchy for drawable
shapes
• To be introduced to an object factory and to learn how to
use it
• To understand how to create packages and to learn
more about visibility
Chapter 3: Inheritance and Class Hierarchies
3
Introduction to Inheritance and Class
Hierarchies
• Popularity of OOP is that it enables programmers to
reuse previously written code saved as classes
• All Java classes are arranged in a hierarchy, starting with
Object, which is the superclass of all Java classes
• Inheritance in OOP is analogous to inheritance in
humans
• Inheritance and hierarchical organization allow you to
capture the idea that one thing may be a refinement or
extension of another
Chapter 3: Inheritance and Class Hierarchies
4
Chapter 3: Inheritance and Class Hierarchies
5
Is-a Versus Has-a Relationships
• One misuse of inheritance is confusing the has-a
relationship with the is-a relationship
• The has-a relationship means that one class has the
second class as an attribute
• We can combine is-a and has-a relationships
• The keyword extends specifies that one class is a
subclass of another
Chapter 3: Inheritance and Class Hierarchies
6
A Superclass and a Subclass
• Consider two classes: Computer and Laptop
• A laptop is a kind of computer and is therefore a
subclass of computer
Chapter 3: Inheritance and Class Hierarchies
7
Class Computer and use of this.
public class Computer {
// Data Fields
private String manufacturer;
private String processor;
private int ramSize;
private int diskSize;
public Computer(String man, String processor, int ram, int disk) {
manufacturer = man;
this.processor = processor;
ramSize = ram;
diskSize = disk;
}
Why not
processor = processor;
Instead of
this.processor = processor;
Chapter 3: Inheritance and Class Hierarchies
8
Class Laptop
• Laptop “is a” computer
• Class Laptop is a subclass of Computer
public class LapTop extends Computer {
// Data Fields
private static final String DEFAULT_LT_MAN = "MyBrand";
private double screenSize;
private double weight;
.....
• Laptop also inherits data fields from Computer
Chapter 3: Inheritance and Class Hierarchies
9
Initializing Data Fields in a Subclass and the
No-Parameter Constructor
• Private data fields belonging to a base class must be
initialized by invoking the base class’s constructor with
the appropriate parameters
• If the execution of any constructor in a subclass does not
invoke a superclass constructor, Java automatically
invokes the no-parameter constructor for the superclass
• Initializes that part of the object inherited from the
superclass before the subclass starts to initialize its
part of the object
Chapter 3: Inheritance and Class Hierarchies
10
Class Laptop
• Must use superclass constructor to initialize data fields
private to superclass
• 1st statement of constructor body…
public LapTop(String man, String proc, int ram, int disk,
double screen, double wei) {
super(man, proc, ram, disk);
screenSize = screen;
weight = wei;
}
• …otherwise, the “no parameter
superclass invoked by default
Chapter 3: Inheritance and Class Hierarchies
constructor”
of
11
Protected Visibility for Superclass Data
Fields
• Private data fields are not accessible to derived classes
• Protected visibility allows data fields to be accessed
either by the class defining it or any subclass
• In general, it is better to use private visibility because
subclasses may be written by different programmers and
it is always good practice to restrict and control access to
the superclass data fields
Chapter 3: Inheritance and Class Hierarchies
12
Method Overriding
• If a derived class (subclass) has a
method found in its base class, method
will override the base class method
• The keyword super can be used to gain
access
to
superclass
methods
overridden by the base class
• A subclass method must have the same
return type as the corresponding
superclass method
Chapter 3: Inheritance and Class Hierarchies
13
Method Overriding
• Suppose main is…
public static void main(String[] args) {
Computer myComputer = new Computer(“Acme”,“Intel P4”,512, 60);
LapTop yourComputer = new LapTop(“Dell”,AMD”,256,40,15.0,7.5);
System.out.println(“My computer is: \n” + myComputer.toString());
System.out.println(“Your computer is: \n” +
yourComputer.toString());
}
• Suppose Computer defines toString, but LapTop does not
• So, what is printed by 2nd println?
Chapter 3: Inheritance and Class Hierarchies
14
Method Overriding
• Probably want to override toString in LapTop…
public String toString() {
String result = super.toString()
+ “/nScreen size: ” + screenSize + “ inches”
+ “/nWeight: ” + weight + “ pounds”
}
• Note that overridden method must have same return type
Chapter 3: Inheritance and Class Hierarchies
15
Method Overloading
• Method overloading: having multiple methods with the
same name but different signatures in a class
• Constructors are often overloaded
• For example:
• MyClass(int inputA, int inputB)
• MyClass(int inputA, int inputB, double inputC)
• Then there are 2 ways to call MyClass
Chapter 3: Inheritance and Class Hierarchies
16
Polymorphism
• A variable of a superclass type can reference an object
of a subclass type
• E.g., variable of Computer type can reference LapTop
• Polymorphism means many forms or many shapes
• Polymorphism allows the JVM to determine which
method to invoke at run time
• At compile time, the Java compiler can’t determine what
type of object a superclass may reference but it is known
at run time
Chapter 3: Inheritance and Class Hierarchies
17
Polymorphism
• What does the following code do?
theComputer = new Computer(“Acme”,“Intel P4”,512, 60);
System.out.println(theComputer.toString());
• What about the following?
theComputer = new LapTop(“Dell”,AMD”,256,40,15.0,7.5);
System.out.println(theComputer.toString());
• Which toString is called???
• Gets a little trickier with arrays…
Chapter 3: Inheritance and Class Hierarchies
18
Abstract Classes, Assignment, and Casting
in a Hierarchy
• An interface can declare methods but does not provide
an implementation of those methods
• Methods declared in an interface are called abstract
methods
• An abstract class can have abstract methods, data
fields, and actual methods
• Abstract class differs from a concrete class in that
• An abstract class cannot be instantiated
• An abstract class can declare abstract methods,
which must be implemented in its subclasses
Chapter 3: Inheritance and Class Hierarchies
19
Abstract Classes and Interfaces
• Like an interface, an abstract class can’t be instantiated
• An abstract class can have constructors to initialize its
data fields when a new subclass is created
• Subclass uses super(…) to call the constructor
• May implement an interface but it doesn’t have to define
all of the methods declared in the interface
• Implementation is left to its subclasses
Chapter 3: Inheritance and Class Hierarchies
20
Abstract Class Food
public abstract class Food {
// Data Field
private double calories;
// Abstract Methods
public abstract double percentProtein();
public abstract double percentFat();
public abstract double percentCarbohydrates();
// Methods
public double getCalories() {
return calories;
}
public void setCalories(double cal) {
calories = cal;
}
}
Chapter 3: Inheritance and Class Hierarchies
21
Abstract Class Food
• Actual subclasses must implement the abstract methods
public abstract double percentProtein();
public abstract double percentFat();
public abstract double percentCarbohydrates();
• Cannot create type Food objects
• But could have, say,
Food mySnack = new Vegetable(“carrot”);
Chapter 3: Inheritance and Class Hierarchies
22
Abstract Class Number and the Java
Wrapper Classes
Chapter 3: Inheritance and Class Hierarchies
23
Summary of Features of Actual Classes,
Abstract Classes, and Interfaces
Chapter 3: Inheritance and Class Hierarchies
24
Class Object
• Object is the root of the class hierarchy; every class has
Object as a superclass
• All classes inherit the methods defined in class Object
but may be overridden
Chapter 3: Inheritance and Class Hierarchies
25
The Method toString
• You should always override the toString method if you
want to represent an object’s state
• If you do not override it, the toString method for class
Object will return a string, but not what you expect
• Object’s toString method gives you the object’s class
name and hash code, not its state
• This is (almost certainly) not what you want
Chapter 3: Inheritance and Class Hierarchies
26
Operations Determined by Type of
Reference Variable
• Suppose you have
Object aThing = new Integer(25);
• Will this compile? Why or why not?
• Answer: Yes, since Object is a superclass of Integer
• Suppose you then have:
aThing.intValue();
• What happens and why?
• Answer: Compile time error, since Object determines
which operations are allowed and Object has no intValue
• But wait, there’s more…
Chapter 3: Inheritance and Class Hierarchies
27
Operations Determined by Type of
Reference Variable
• As on previous slide, suppose you have
Object aThing = new Integer(25);
• Consider this method call:
aThing.equals(new Integer("25"));
• Will this compile? Why or why not?
• Answer: This will compile: Object has equals method
• At runtime, which equals method?
• Answer: At execution time, Integer’s equals method is
called! Why?
Chapter 3: Inheritance and Class Hierarchies
28
Java is Strongly Typed
• As on previous slides, suppose you have
Object aThing = new Integer(25);
• Consiider the following:
Integer aNum = aThing;
• Will this compile? Why or why not?
• Answer: No, you will get a compile time error since Java
is “strongly typed”
• If Java allowed this to compile, it might die at runtime if
you tried to use Integer (only) method on Object type
• Strongly Typed means Java verifies types of
expressions are compatible at compile time
• But, there is a way around this…
Chapter 3: Inheritance and Class Hierarchies
29
Casting in a Class Hierarchy
• Java provides casting to enable us to process one object
referenced by one type through a reference variable of its
actual type
• Casting does not change the object referenced; it creates
anonymous reference to that object
• Can cast aThing to an Integer by
(Integer) aThing
• Succeeds only if object referenced by aThing is type
Integer
• Otherwise get a ClassCastException
• Use instanceof operator to avoid this
Chapter 3: Inheritance and Class Hierarchies
30
Downcasting
• Downcast: cast a higher type to a lower type
• Higher and lower in terms of class hierarchy
• But lower guy must be subclass
• For example, Object is higher than Integer
• So, (Integer)aThing is a downcast
• Can also downcast interface types
• “Upcasting” is allowed, but not necessary
• So don’t waste your time!
Chapter 3: Inheritance and Class Hierarchies
31
Java 5.0 Reduces Need for Casting
• Two new features that reduce the need for casting:
• Autoboxing/unboxing
• Generics
• Autoboxing/unboxing eases the conversion between a
primitive type and its corresponding wrapper type
Chapter 3: Inheritance and Class Hierarchies
32
The Method Object.equals
• The Object.equals method has a parameter of type
Object
• Compares two objects to determine whether they are
equal
• You must override the equals method if you want to be
able to compare two objects of a class
Chapter 3: Inheritance and Class Hierarchies
33
Cloning
• The purpose of cloning in object-oriented programming
is analogous to cloning in biology
• Create an independent copy of an object
• Initially, both objects will store the same information
• For a true clone, you can change one object without
affecting the other
• How to accomplish this?
Chapter 3: Inheritance and Class Hierarchies
34
How Not to Clone
• Consider the following code
• Both e1.name and e2.name reference “Jim”
• Definitely not a clone!
Chapter 3: Inheritance and Class Hierarchies
35
How Not to Clone
Chapter 3: Inheritance and Class Hierarchies
36
Shallow Copy
• Suppose we try this
public Object clone() {
Object cloned = new Employee(name, hours, rate, address);
return cloned;
}
• Then we could do this
Employee e2 = (Employee) e1.clone();
• Does this create a clone?
• Answer: No, e2 is a copy of e1 (good), but object
references are same in e1 and e2 (bad)
• Data fields are distinct, but not objects (next slide…)
Chapter 3: Inheritance and Class Hierarchies
37
• Statement e1.setAddressLine1("Room 224"); creates a
new String object that is referenced by e1.address.line1
and e2.address.line1
Chapter 3: Inheritance and Class Hierarchies
38
The Object.clone method
• Java provides the Object.clone method to solve the
shallow copy problem
• The initial copy is a shallow copy as the current object’s
data fields are copied
• To make a deep copy, you must create cloned copies of
all components by invoking their respective clone
methods
• Note that clone method gives shallow copy of data
structure (such as an array)
• Read the text!
Chapter 3: Inheritance and Class Hierarchies
39
The Object.clone method (continued)
• After e1.setAddressLine1("Room 224"); only
e1.address.line1 references the new String object.
Chapter 3: Inheritance and Class Hierarchies
40
Employee.clone()
Chapter 3: Inheritance and Class Hierarchies
41
Address.clone()
Chapter 3: Inheritance and Class Hierarchies
42
Multiple Inheritance, Multiple Interfaces, and
Delegation
• Multiple inheritance: the ability to extend more than one
class
• Multiple inheritance is a language feature that is difficult
to implement and can lead to ambiguity
• Therefore, Java does not allow a class to extend
more than one class
Chapter 3: Inheritance and Class Hierarchies
43
Using Multiple Interfaces to Emulate Multiple
Inheritance
• If we define two interfaces, a class can implement both
• Multiple interfaces emulate multiple inheritance
Chapter 3: Inheritance and Class Hierarchies
44
Using Multiple Interfaces to Emulate Multiple
Inheritance (continued)
Chapter 3: Inheritance and Class Hierarchies
45
Implementing Reuse Through Delegation
• You can reduce duplication of modifications and reduce
problems associated with version control through a
technique known as delegation
• In delegation, a method of one class accomplishes an
operation by delegating it to a method of another class
Chapter 3: Inheritance and Class Hierarchies
46
Implementing Reuse Through Delegation
• For example, can use Student getGPA method in
StudentWorker
• Why is this useful?
• If getGPA changes, only need to change in 1 place
Chapter 3: Inheritance and Class Hierarchies
47
Packages
• The Java API is organized into packages
• The package is declared by the first statement in the file
in which the class is defined
• Keyword package followed by the package name
• All classes in the same package must be stored in the
same directory or folder
• Classes that are not part of a package may access only
public members of classes in the package
Chapter 3: Inheritance and Class Hierarchies
48
The No-Package-Declared Environment and
Package Visibility
• There exists a default package
• Files that do not specify a package are considered
part of the default package
• If you don’t declare packages, all of your packages
belong to the same, default package
• Package visibility sits between private and protected
• Classes, data fields, and methods with package visibility are
accessible to all other methods of the same package but are
not accessible to methods outside of the package
• Classes, data fields, and methods that are declared
protected are visible to all members of the package
Chapter 3: Inheritance and Class Hierarchies
49
Visibility Supports Encapsulation
• Visibility and encapsulation in a Java program
• private visibility is for members of a class that should not
be accessible outside the class
• Not even classes that extend the class (subclasses)
• package visibility allows the developer of a library to
shield classes and class members from classes outside
the package
• protected visibility allows the package developer to give
control to programs that extend classes in the package
• Even subclasses that are outside the package
Chapter 3: Inheritance and Class Hierarchies
50
Visibility Supports Encapsulation (continued)
Chapter 3: Inheritance and Class Hierarchies
51
A Shape Class Hierarchy
Chapter 3: Inheritance and Class Hierarchies
52
A Shape Class Hierarchy (continued)
Chapter 3: Inheritance and Class Hierarchies
53
Chapter 3: Inheritance and Class Hierarchies
54
A Shape Class Hierarchy (continued)
Chapter 3: Inheritance and Class Hierarchies
55
Object Factories
• An object factory is a method that creates instances of
other classes
• Object factories are useful when:
• The necessary parameters are not known or must be
derived via computation
• The appropriate implementation of an interface or
abstract class should be selected as the result of
some computation
Chapter 3: Inheritance and Class Hierarchies
56
Object Factories (continued)
Chapter 3: Inheritance and Class Hierarchies
57
Chapter Review
• Inheritance and class hierarchies to capture the idea that
one thing may be a refinement or extension of another
• Encapsulation and inheritance impose structure on
object abstractions
• The keyword interface defines an interface
• The keyword abstract defines an abstract class or
method
• Delegation gains some of the advantages of multiple
inheritance
• Visibility is influenced by the package in which a class is
declared
Chapter 3: Inheritance and Class Hierarchies
58