Inheritance and Class Hierarchies Chapter 3 Inheritance and

Inheritance and Class Hierarchies Chapter 3: Inheritance and Class Hierarchies

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

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 8

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 9

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 Chapter 3: Inheritance and Class Hierarchies 10

Method Overloading • Method overloading: having multiple methods with the same name but different signatures in a class • Constructors are often overloaded • Example: • My. Class(int input. A, int input. B) • My. Class(int input. A, int input. B, double input. C) Chapter 3: Inheritance and Class Hierarchies 11

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 Chapter 3: Inheritance and Class Hierarchies 12

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 Chapter 3: Inheritance and Class Hierarchies 13

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 14

Abstract Class Number and the Java Wrapper Classes Chapter 3: Inheritance and Class Hierarchies 15

Summary of Features of Actual Classes, Abstract Classes, and Interfaces Chapter 3: Inheritance and Class Hierarchies 16

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 Chapter 3: Inheritance and Class Hierarchies 17

The Method to. String • You should always override the to. String method if you want to represent an object’s state • If you do not override it, the to. String method for class Object will return a string…just not the string you want or are expecting Chapter 3: Inheritance and Class Hierarchies 18

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 Chapter 3: Inheritance and Class Hierarchies 19

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 Class. Cast. Exception errors • You can downcast an interface reference to the specific implementation type Chapter 3: Inheritance and Class Hierarchies 20

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 21

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 22

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 e 1. name and e 2. name to reference “Jim” Chapter 3: Inheritance and Class Hierarchies 23

The Shallow Copy Problem Chapter 3: Inheritance and Class Hierarchies 24

• The statement e 1. set. Address. Line 1("Room 224"); creates a new String object that is referenced by e 1. address. line 1 and e 2. address. line 1 Chapter 3: Inheritance and Class Hierarchies 25

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 Chapter 3: Inheritance and Class Hierarchies 26

The Object. clone method (continued) • After e 1. set. Address. Line 1("Room 224"); only e 1. address. line 1 references the new String object. Chapter 3: Inheritance and Class Hierarchies 27

Employee. clone() Chapter 3: Inheritance and Class Hierarchies 28

Address. clone() Chapter 3: Inheritance and Class Hierarchies 29

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 30

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 31

Using Multiple Interfaces to Emulate Multiple Inheritance (continued) Chapter 3: Inheritance and Class Hierarchies 32

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 33

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 Chapter 3: Inheritance and Class Hierarchies 34

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 Chapter 3: Inheritance and Class Hierarchies 35

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 Chapter 3: Inheritance and Class Hierarchies 36

Visibility Supports Encapsulation (continued) Chapter 3: Inheritance and Class Hierarchies 37

A Shape Class Hierarchy Chapter 3: Inheritance and Class Hierarchies 38

A Shape Class Hierarchy (continued) Chapter 3: Inheritance and Class Hierarchies 39

Chapter 3: Inheritance and Class Hierarchies 40

A Shape Class Hierarchy (continued) Chapter 3: Inheritance and Class Hierarchies 41

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 42

Object Factories (continued) Chapter 3: Inheritance and Class Hierarchies 43

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 44

Screenshots and code –one of the Drawable. Shape classes public class Drawable. Triangle extends Drawable. Shape { public Drawable. Triangle(int bas, int hei, Point poi, Color border, Color inter) { super(poi, border, inter, new Rt. Triangle(bas, hei)); } // Methods /** Draw the triangle using the given graphics context. @param g The graphics context */ public void draw. Me(Graphics g) { Polygon rt. Tri = new Polygon(); Rt. Triangle triangle = (Rt. Triangle) the. Shape; rt. Tri. add. Point(pos. x, pos. y); rt. Tri. add. Point(pos. x, pos. y - triangle. get. Height()); rt. Tri. add. Point(pos. x + triangle. get. Base(), pos. y); g. set. Color(interior. Color); g. fill. Polygon(rt. Tri); g. set. Color(border. Color); g. draw. Polygon(rt. Tri); } /** Return a string representation of the triangle. @return A string representation of the triangle */ public String to. String() { return "Drawable " + the. Shape + super. to. String(); }} Chapter 3: Inheritance and Class Hierarchies 45

The test program opens a frame and draws on a panel Chapter 3: Inheritance and Class Hierarchies 46