Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
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