1 / 34

Inheritance and Polymorphism in Java

This lecture discusses the concept of inheritance in Java, including the "is-a" relationship, keyword extends, and the use of private, public, and protected access modifiers. It also covers polymorphism, method overloading and overriding, abstract classes, interfaces, and wrappers and casting.

cschubert
Download Presentation

Inheritance and Polymorphism in Java

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. Lec.8(Chapter 7) Inheritance Jiang (Jen) ZHENG June 6th, 2005

  2. Outline • Inheritance • “is a” relationship • extends keyword • private, public and protected • Polymorphism • Method overloading • Method overriding • Object, Method and instance variable access • Abstract Classes • Interfaces • Wrappers & Casting CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  3. Inheritance • Sometimes we want to build a new class that is largely like one we already have • Much of the functionality we need is already there, but some things need to be added or changed • We can achieve this in object-oriented languages using inheritance • Attributes of a base class, or superclass are passed on to a subclass CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  4. Inheritance and “is a” • We can understand this better by considering the “is a” idea • A subclass object “is a” superclass object • However, some extra instance variables and methods may have been added and some other methods may have been changed • Note that “is a” is a one way operation • Subclass “is a” superclass • With modifications • Superclass is NOT a subclass • Missing some properties • Ex: Button “is a” Component CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  5. Inheritance and “is a” • Button, Label and Checkbox are all Components • However, a Component is not necessarily a Button, Label or Checkbox Component is a is a is a Checkbox Button Label CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  6. Extending Classes • Inheritance in Java is implemented by extending a class public class NewClass extends OldClass { … • We then continue the definition of NewClass as normal • However, implicit in NewClass are all data and operations associated with OldClass • Even though we don’t see them in the definition CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  7. private, public and protected • We already know what public and private declarations mean • The protected declaration is between public and private • Protected data and methods are directly accessible in the base class and in any subclasses • However, they are not directly accessible anywhere else • Note that private declarations are STILL PART of subclasses, but they are not directly accessible from the subclass’ point of view • See SuperClass.java, SubClass.java and ex11.java CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  8. Inheritance Example • As another example • Compare MixedNumber class and MixedNumber2 class • Both have the same functionality, but MixedNumber uses composition and MixedNumber2 uses inheritance • Note simplicity of MixedNumber2 methods CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  9. Java Class Hierarchy • In Java, class Object is the base class to all other classes • If we do not explicitly say extends in a new class definition, it implicitly extends Object • The tree of classes that extend from Object and all of its subclasses are is called the class hierarchy • All classes eventually lead back up to Object • This will enable consistent access of objects of different classes, as we shall see shortly CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  10. Polymorphism • Idea of polymorphism • See internet definition: • On Google type “definition polymorphism” and see the results • This search works for many CS terms that you may be curious about • http://www.wordiq.com/definition/Polymorphism_%28computer_science%29 • Generally, it allows us to mix methods and objects of different types in a consistent way • In Chapter 4, one type of polymorphism was already introduced (but we did not discuss it in lecture) (see Section 4.12) CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  11. Method Overloading • This is called ad hoc polymorphism, or method overloading • In this case different methods within the same class or in a common hierarchy share the same name but have different method signatures (name + parameters + return types) public static float max(float a, float b) public static float max(float a, float b, float c) public static int max(int a, int b) • When a method is called, the call signature is matched to the correct method version • Note: This is done during program COMPILATION CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  12. Method Overloading • If an exact signature match is not possible, the one that is closest via “widening” of the values is used • “Widening” means that values of “smaller” types are cast into values of “larger” types • Ex: int to long int to float float to double • If two or more versions of the method are possible with the same amount of “widening”, the call is ambiguous, and a compilation error will result • See ex13.java • Note: This type of polymorphism is not necessarily object-oriented – can be done in non-object-oriented languages CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  13. Polymorphism • Subclassing Polymorphism • Sometimes called “true polymorphism” • Consists basically of two ideas: • Method overriding • A method defined in a superclass is redefined in a subclass with an identical method signature • Since the signatures are identical, rather than overloading the method, it is instead overriding the method • For subclass objects, the definition in the subclass replaces the version in the superclass CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  14. Polymorphism • Dynamic (or late) binding • The code executed for a method call is associated with the call during run-time • The actual method executed is determined by the type of the object, not the type of the reference • Allows superclass and subclass objects to be accessed in a regular, consistent way • Array or collection of superclass references can be used to access a mixture of superclass and subclass objects • This is very useful if we want access collections of mixed data types (ex: draw different graphical objects using the same draw() method call for each) CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  15. Polymorphism Animal • Ex. Each subclass overrides the move() method in its own way Animal [] A = new Animal[3]; A[0] = new Bird(); A[1] = new Person(); A[2] = new Fish(); for (int i = 0; i < A.length; i++) A[i].move(); move() move() • References are all the same, but objects are not • Method invoked is that associated with the OBJECT, NOT with the reference move() CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  16. Object, Method and Instance Variable Access • When mixing objects of difference classes, some access rules are important to know: • Superclassreferences can always be used to access subclass objects, but NOT vice versa Animal A = new Bird(); // this is ok Bird B = new Animal(); // this is an ERROR • Given a reference R of class C, only methods and instance variables that are defined (initially) in class C or ABOVE in the class hierarchy can be accessed through R • They still exist if defined in a subclass, but they are not accessible through R CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  17. Object, Method and Instance Variable Access • Ex: • Suppose class Fish contains a new instance variable waterType and a new method getWaterType() Fish F = new Fish(); Animal A = new Fish(); System.out.println(F.getWaterType()); // ok System.out.println(A.getWaterType()); • The above is NOT legal, even though the method exists for class Fish. The reason is that the method is not visible from the reference’s point of view (A is an Animal reference so it can only “see” the data and methods defined in class Animal) System.out.println(((Fish) A).getWaterType()); • This is ok, since we have now cast the reference to the Fish type, which CAN access the method CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  18. Object, Method and Instance Variable Access • Note that we can access these methods or instance variables INDIRECTLY if an overridden method accesses them • So, for example, if the move() method as defined in class Fish called the getWaterType() method, and we called A.move(); • It would work fine • See ex14.java for an example CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  19. Abstract Classes • Abstract classes • Sometimes in a class hierarchy, a class may be defined simply to give cohesion to its subclasses • No objects of that class will ever be defined • But instance data and methods will still be inherited by all subclasses • This is an abstract class • Keyword abstract used in declaration • One or more methods declared to be abstract and are thus not implemented • No objects may be instantiated CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  20. Abstract Classes • Subclasses of an abstract class must implement all abstract methods, or they too must be declared to be abstract • Advantages • Can still use superclass reference to access all subclass objects in polymorphic way • However, we need to declare the methods we will need in the superclass, even if they are abstract • No need to specifically define common data and methods for each subclass - it is inherited • Helps to organize class hierarchy • See ex15.java CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  21. Interfaces • Java allows only single inheritance • A new class can be a subclass of only one parent (super) class • There are several reasons for this, from both the implementation (i.e. how to do it in the compiler and interpreter) point of view and the programmer (i.e. how to use it effectively) point of view • However, it is sometimes useful to be able to access an object through more than one superclass reference CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  22. Interfaces • Interfaces allow us to do this: • A Java interface is a named set of methods • Think of it as an abstract class with no instance data • Static constants are allowed • No static methods are allowed • Any Java class (no matter what its inheritance) can implement an interface by implementing the methods defined in it • A given class can implement any number of interfaces CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  23. Interfaces • Ex: public interface Laughable { public void laugh(); } public interface Booable { public void boo(); } • Any Java class can implement Laughable by implementing the method laugh() • Any Java class can implement Booable by implementing the method boo() CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  24. Interfaces • Ex: public class Comedian implements Laughable, Booable { // various methods here (constructor, etc.) public void laugh() { System.out.println(“Ha ha ha”); } public void boo() { System.out.println(“You stink!”); } } CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  25. Interfaces • Recall our previous discussion of polymorphism • This behavior also applies to interfaces – the interface acts as a superclass and the implementing classes implement the actual methods however they want • An interface variable can be used to reference any object that implements that interface • However, only the interface methods are accessible through the interface reference • Ex: Laughable [] funny = new Laughable[3]; funny[0] = new Comedian(); funny[1] = new SitCom(); // implements Laughable funny[2] = new Clown(); // implements Laughable for (int i = 0; i < funny.length; i++) funny[i].laugh(); • See ex16.java CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  26. Wrappers • Much useful Java functionality relies on classes / objects • Inheritance • Polymorphic access • Interfaces • Unfortunately, the Java primitive types are NOT classes, and thus cannot be used in this way • Ex: What if I want to store some collection of mixed objects CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  27. Wrappers • I could make an array of Object, since Object is the superclass of all other Java classes Object [] data = new Object[size]; • However, I cannot store in here any of my primitive types, since they are not Objects • Wrapper classes allow us to get around this problem • Wrappers are classes that “wrap” objects around primitive values, thus making them compatible with other Java classes • Each Java primitive type has a corresponding wrapper • Ex: Integer, Float, Double, Boolean CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  28. Wrappers • The wrapper classes also provide extra useful functionality for these types • Ex: Integer.parseInt() is a static method that enables us to convert from a String into an int • Ex: Character.isLetter() is a static method that tests if a letter is a character or not • See more in API Integer int Double double CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  29. Wrappers and Casting • Ex: Object [] A = new Object[10]; // A[0] = 50; // This is illegal, since 50 is not // an Object A[0] = new Integer(50); // This is fine A[1] = new Integer(30); • Note that an array of Object can store any Java class (including any wrapper class) • However, because the reference is Object, we are restricted in the methods that we can use • Recall from our discussion of polymorphism that the superclass reference cannot “see down” into the subclass details CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  30. Wrappers and Casting • Thus, if we want to access anything specific to our wrapper class, we must first cast the reference: Integer i = (Integer) A[0]; Integer j = (Integer) A[1]; if (i.compareTo(j) == 0) System.out.println(i + “ == “ + j); • We would get an error if we tried if (A[i].compareTo(A[j])) • Also note that if we want to do any “math” with our wrappers, we need to get the underlying primitive values CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  31. “Operations” with Wrappers // Integer k = i + j; // This is illegal • The actual computation is actually quite roundabout: Integer k = new Integer(i.intValue() + j.intValue()); • In words: Get the primitive value of each Integer object, add them, then create a new Integer object with the result • This leads back to the question: • Why do we want to bother with this? • Aren’t we better off just using int values instead of these wrappers? • There are definite benefits to having the data represented in a class • Let’s see what they are CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  32. “Generic” Operations • Let’s look at a simple example that should already be familiar to you: Sorting • Earlier in the term we looked at SelectionSort • See Slides 88-89 • The code was written to specifically sort ints: static void sort(int[] data) • What if we want to sort floats, or doubles, or Strings, or any other Java type? • We need to write a new method for each one!!! • The argument array must match the parameter array • Or do we?? • Can we write a single method that can sort anything? • Discuss CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  33. “Generic” Operations • Consider the Comparable interface: • It contains one method: int compareTo(Object r); • Returns a negative number if the current object is less than r, 0 if the current object equals r and a positive number if the current object is greater than r • Look at Comparable in the API • Consider what we need to know to sort data: • is A[i] less than, equal to or greater than A[j] • Thus, we can sort Comparable data without knowing anything else about it • Awesome! • Polymorphism allows this to work CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

  34. “Generic” Operations • Think of the objects we want to sort as “black boxes” • We know we can compare them because they implement Comparable • We don’t know (or need to know) anything else about them • Show on board • Thus, a single sort method will work for an array of any Comparable class • Let’s write it now, altering the code we already know from our simple sort method • See Sorting.java and ex17.java CS401/COE401 Summer 2005.Department of Computer Science.University of Pittsburgh.Lecture 8

More Related