1. Inheritance and Class Hierarchies Chapter 3

2. Chapter 3: Inheritance and Class Hierarchies2 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

3. Chapter 3: Inheritance and Class Hierarchies3 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

4. Chapter 3: Inheritance and Class Hierarchies4 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

5. Chapter 3: Inheritance and Class Hierarchies5

6. 6 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

7. Chapter 3: Inheritance and Class Hierarchies7 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

8. Chapter 3: Inheritance and Class Hierarchies8 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

9. Chapter 3: Inheritance and Class Hierarchies9 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

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

11. Chapter 3: Inheritance and Class Hierarchies11 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)

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

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

14. Chapter 3: Inheritance and Class Hierarchies14 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

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

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

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

18. Chapter 3: Inheritance and Class Hierarchies18 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

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

20. Chapter 3: Inheritance and Class Hierarchies20 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

21. Chapter 3: Inheritance and Class Hierarchies21 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

22. Chapter 3: Inheritance and Class Hierarchies22 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

23. Chapter 3: Inheritance and Class Hierarchies23 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”

24. Chapter 3: Inheritance and Class Hierarchies24 The Shallow Copy Problem

25. Chapter 3: Inheritance and Class Hierarchies25 The statement e1.setAddressLine1("Room 224"); creates a new String object that is referenced by e1.address.line1 and e2.address.line1

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

27. Chapter 3: Inheritance and Class Hierarchies27 The Object.clone method (continued) After e1.setAddressLine1("Room 224"); only e1.address.line1 references the new String object.

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

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

30. Chapter 3: Inheritance and Class Hierarchies30 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

31. Chapter 3: Inheritance and Class Hierarchies31 Using Multiple Interfaces to Emulate Multiple Inheritance If we define two interfaces, a class can implement both Multiple interfaces emulate multiple inheritance

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

33. Chapter 3: Inheritance and Class Hierarchies33 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

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

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

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

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

38. Chapter 3: Inheritance and Class Hierarchies38 A Shape Class Hierarchy

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

40. Chapter 3: Inheritance and Class Hierarchies40

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

42. Chapter 3: Inheritance and Class Hierarchies42 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

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

44. Chapter 3: Inheritance and Class Hierarchies44 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