ppt - Montana State University
Download
Report
Transcript ppt - Montana State University
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 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
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
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
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
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
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
Method Overriding
If a derived class has a method found
within its base class, that method will
override the base class’s 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
Method Overloading
Method overloading: having multiple methods with the
same name but different signatures in a class
Constructors are often overloaded
Example:
MyClass(int inputA, int inputB)
MyClass(int inputA, int inputB, double inputC)
Polymorphism
A variable of a superclass type can reference an object
of a subclass type
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
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 concrete 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
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
Abstract Class Number and the
Java Wrapper Classes
Summary of Features of Actual
Classes, Abstract Classes, and
Interfaces
Class Object, Casting and Cloning
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
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…just not the string you want
or are expecting
Operations Determined by Type of
Reference Variable
A variable can reference an object whose type is a
subclass of the variable type
The type of reference, not the type of the object
referenced, determines what operations can be
performed
Java is a strongly typed language so the compiler always
verifies that the type of the expression being assigned
is compatible with the variable type
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 an anonymous reference to that object
Downcast: cast a higher type to a lower type
The instanceof operator can guard against
ClassCastException errors
You can downcast an interface reference to the specific
implementation type
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
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
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
You can change one object without affecting the other
Will cause both e1.name and e2.name to reference “Jim”
The Shallow Copy Problem
The statement e1.setAddressLine1("Room 224"); creates
a new String object that is referenced by
e1.address.line1 and e2.address.line1
The Object.clone method
Java provides the Object.clone method to help 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
The Object.clone method
(continued)
After e1.setAddressLine1("Room 224"); only e1.address.line1
references the new String object.
Employee.clone()
Address.clone()
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
Using Multiple Interfaces to
Emulate Multiple Inheritance
If we define two interfaces, a class can implement both
Multiple interfaces emulate multiple inheritance
Using Multiple Interfaces to
Emulate Multiple Inheritance
(continued)
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
Packages
The Java API is organized into packages
The package to which a class belongs is declared by the
first statement in the file in which the class is defined
using the keyword package followed by the package name
All classes in the same package are stored in the same
directory or folder
All the classes in one folder must declare themselves to
be in the same package
Classes that are not part of a package may access only
public members of classes in the package
The No-Package-Declared
Environment and Package Visibility
There exists a default package
Files that do 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
Visibility Supports Encapsulation
The rules for visibility control how encapsulation occurs
in a Java program
Private visibility is for members of a class that should
not be accessible to anyone but the class, not even the
classes that extend it
Package visibility allows the developer of a library to
shield classes and class members from classes outside
the package
Use of protected visibility allows the package developer
to give control to other programmers who want to
extend classes in the package
Table 3.3
Private Visibility
Classes : Applicable to inner classes. Accessible only
to members of the class in which it is declared.
Class Members: Visible only within this class.
Default (or package) Visibility
Classes : Visible to classes in this package.
Class Members : Visible to classes in this package.
Protected Visibility
Classes : Applicable to inner classes. Visible to
classes in this package and to classes outside the
package that extend the class in which it is declared.
Class Members : Visible to classes in this package and
to classes outside the package that extend this class.
Public Visibility
Classes: Visible to all classes.
Class Members : Visible to all classes. The class
defining the member must also be public.
Visibility Supports Encapsulation
(continued)
A Shape Class Hierarchy
A Shape Class Hierarchy
(continued)
A Shape Class Hierarchy
(continued)
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
Object Factories (continued)
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