1 / 58

Inheritance and Class Hierarchies

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

vlara
Download Presentation

Inheritance and Class Hierarchies

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Inheritance and Class Hierarchies Chapter 3

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

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

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

  5. Chapter 3: Inheritance and Class Hierarchies

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

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

  8. Class Computer and use of this. publicclass Computer { // Data Fields private String manufacturer; private String processor; privateint ramSize; privateint 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

  9. Class Laptop • Laptop “is a” computer • Class Laptop is a subclass of Computer publicclass LapTop extends Computer { // Data Fields privatestaticfinal String DEFAULT_LT_MAN = "MyBrand"; privatedouble screenSize; privatedouble weight; . . . . . • Laptop also inherits data fields from Computer Chapter 3: Inheritance and Class Hierarchies

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

  11. 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 constructor” of superclass invoked by default Chapter 3: Inheritance and Class Hierarchies

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

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

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

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

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

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

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

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

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

  21. Abstract Class Food publicabstractclass Food { // Data Field privatedouble calories; // Abstract Methods publicabstractdouble percentProtein(); publicabstractdouble percentFat(); publicabstractdouble percentCarbohydrates(); // Methods publicdouble getCalories() { return calories; } publicvoid setCalories(double cal) { calories = cal; } } Chapter 3: Inheritance and Class Hierarchies

  22. Abstract Class Food • Actual subclasses must implement the abstract methods publicabstractdouble percentProtein(); publicabstractdouble percentFat(); publicabstractdouble percentCarbohydrates(); • Cannot create type Food objects • But could have, say, Food mySnack = new Vegetable(“carrot”); Chapter 3: Inheritance and Class Hierarchies

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

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

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

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

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

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

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

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

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

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

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

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

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

  36. How Not to Clone Chapter 3: Inheritance and Class Hierarchies

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

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

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

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

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

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

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

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

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

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

  47. Implementing Reuse Through Delegation • For example, can use StudentgetGPA method in StudentWorker • Why is this useful? • If getGPA changes, only need to change in 1 place Chapter 3: Inheritance and Class Hierarchies

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

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

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

More Related