Chapter 3 Inheritance and Polymorphism Goals: 1.Superclasses and subclasses 2.Inheritance Hierarchy 3.Polymorphism 4.Type Compatibility 5.Abstract Classes 6.Interfaces 7.The Comparable Interface

Inheritance Superclasses and Subclass – Inheritance defines a relationship between objects that share characteristics. Subclass – is created from an existing superclass. Subclass inherits charatceristics of its superclass. Subclass is bigger than a superclass – it contains more data and more methods. Allows you to reuse code over and over gain.

Inheritance Hierarchy Inheritance hierarchy – when a subclass itself is a superclass for another subclass. ***Note Arrow points to its superclass Person StudentEmployee GradStudentUnderGrad

Is-a Relationship Arrow designates an is-a relationship. There needs to be an is-a relationship when working with inheritance. Example: – An Employee is-a Person – Student is-a Person – GradStudent is-a Student Opposite is not true – Person doesn’t always have to be an Employee The subclass inherits all public variables and methods of the superclass, but does not inherit the constructors even though they are public.

Method Overriding When the subclass and superclass has the exact same method in each of their class. The subclass method will override the superclass method. To run the superclass method, you must use the keyword super which will be discussed later.

extends Keyword In the subclass, you must use the extends keyword to inherit the superclass methods and variables. – Example: public class Subclass extends Superclass { } You can only extend one class at a time A Parent class (superclass) can have multiple children classes (subclasses) but a child class can only have one parent class.

Protected There is a protected specifier along with public and private Not part of the AP Subset All protected variables and methods are inherited.

Super keyword Subclass methods overrides superclass methods with the same method heading signatures. Super allows you to undo the override. By using super.methodName() allows you to run the method of the superclass over its subclass method.

Super & Constructors Constructors are never inherited Be sure to provide at least one constructor when you write a subclass. Constructors are never inherited from the superclass. If the superclass does not have a default constructor but does have a constructor with parameters, creating a subclass without constructors will cause an error. To run the constructor of the superclass, just use super() by itself.

Super examples public GradStudent() { super(); myGradId = 12345; } Example public GradStudent(String name,String grade, int id) { super(name,grade); myGradId = id; } If super is used in the implementation of a subclass constructor, it must be used in the first line of the constructor body. If no constructor is provided in a subclass, the compiler provides the following default constructor public Subclass() { super(); }

Rules for Subclasses A subclass can add new private instance variables A subclass can add new public, private, and static methods A subclass can override inherited methods A subclass may not redefine a public methods of the superclass. A subclass should define its own constructors A subclass cannot directly access the private members of its superclass. It must use accessor or mutator methods.

Declaring Subclass Objects When a variable of a superclass is declared in a client program, that reference can refer not only to an object of the superclass, but also to objects of any of its subclasses. – Example: Student s = new Student(); Student g = new GradStudent(); Student u = new UnderGrad(); This works because a GradStudent is-a Student, and an UnderGrad is-a Student.

Not Valid Note that since a Student is not necessarily a GradStudent nor an UnderGrad, the following declarations are not valid: – GradStudent g = new Student(); – UnderGrad u = new Student();

Example Student s = new Student(); Student g = new GradStudent(); Student u = new UnderGrad(); Suppose a method called setGrade() is in the Student class. s.setGrade(“pass”); will work because it is in the Student class. g.setGrade(“pass”); & u.setGrade(“pass”); will work because inheritance.

Bad calls Suppose getID() is in the GradStudent class. int studnum = s.getId(); int unstudnum = u.getId(); Neither Student s nor UnderGrad u inherit the getID() method from the GradStudent class. A superclass does not inherit from the subclass.

Polymorphism Student s = new Student(); Student g = new GradStudent(); Student u = new UnderGrad(); The method computeGrade() is all classes (Student, GradStudent, UnderGrad) The following are legal because they all have been declared Student. s.computeGrade(); g.computeGrade(); u.computeGrade(); The question is which computeGrade() method will run.

Polymorphism A method that has been overridden in at least one subclass is said to be polymorphic. Polymorphism is the mechanism of selecting the appropriate method for a particular object in a class hierarchy. Selected during runtime. The correct method is chosen because, in Java, method calls are always determined by the type of the actual object (GradStudent or UnderGrad), not the type of the object reference (Student). The previous slide computeGrade() will all perform the correct operations for their particular instances(Student, GradStudent, & UnderGrad objects s,g,u).

Dynamic Binding (Late Binding) Making a runtime decision about which instance method to call is known as dynamic binding or late binding (method overriding). Static binding or early binding is done at compile time. (method overloading) compares method signatures. In polymorphism, the actual method that will be called is not determined by the compiler. Example: – The compiler determines if a method can be called(is it legal?). While the run-time environment determines how it will be called(which overridden form should be used?). Polymorphism applies only to overridden methods in subclasses.

Type Compatibility Suppose method getId() only exist in the GradStudent class. Student s = new GradStudent(); GradStudent g = new GradStudent(); int x = s.getId(); //ERROR int y = g.getId(); //Legal Both s and g represent GradStudent objects, so why does s.getId() cause an error?? The reason is that s is of type Student, and the Student class doesn’t have a getId() method. Remember getId() method is only in UnderGrad and not Student so this is not Polymorphism because no method is being overridden.

Downcasting You can fix the other slide problem by Downcasting. int x =((GradStudent)s).getId(); Since s (of type Student) is actually representing a GradStudent object, such as a cast can be carried out. Casting a superclass to a subclass type is called Downcasting. Notice the parenthesis are necessary around the s. An Error would occur if lefty out. Dot operator has a higher precedence than a cast.

Rules for Polymorphic Method Calls a.method(b) For a declaration like: Superclass a = new Subclass(): The type of a at compile tie is Superclass; at run time it is Subclass At compile time, method must be found in the class of a, that is, in Superclass. (this is true whether the method is polymorphic or not) If method cannot be found in the class of a, you need to do an explicit cast on a to its actual type. For a polymorphic method, at run time the actual type of a is determined – Subclass in this example – and method is selected from Subclass. This could be an inherited method if there is no overriding method. The type of parameter b is checked at compile time. You may need to do an explicit cast to the subclass type to make this correct. Method selected by type of “a” at run time Parameter b must be of correct type at compile type

The ClassCastException The ClassCastException is a run-time exception thrown to signal an attempt to cast an object to a class of which it is not an instance. Examples: Student u = new UnderGrad(); System.out.println((String)u); //ClassCastException u is not a String int x = ((GradStudent)u).getID();// ClassCastException u is not an //instance of GradStudent

Abstract Classes Abstract class are declared with keyword abstract in the header. An abstract class is a superclass that represents an abstract concept, and therefore should not be instantiated. An abstract class may contain abstract methods. – An abstract method has no implementation code, just a header and ends with a semicolon “;” – Every subclass will need to override the abstract method of the Superclass. If a class contains any abstract methods, it must be declared an abstract class.

Abstract Classes If a subclass of an abstract class does not provide implementation code for all the abstract methods of its superclass, it too becomes an abstract class and must be declared as such to avoid a compile-time error. An abstract class can have both abstract methods and concrete methods (nonabstract methods) It is possible for an abstract class to have no abstract methods Abstract class may or may not have constructors You can not create an instance of an abstract class Polymorphism works with abstract classes as it does with concrete classes. (non abstract class)

Interfaces An interface is a collection of related methods whose headers are provided without implementations. (simply put a class of all abstract methods) All of the methods are public and abstract – there is no need to explicitly include public and abstract keywords. Classes can implement the interface by using the keyword “implements” Example of interface class: public interface FlyingObjetcs { void fly(); Boolean isFlying(); } Example on a class implementing an Interface public class Bird implements FlyingObject ***Note: Class Bird must have the code for methods fly() & isFlying()

implements Keyword You can implement an Interface and extend a class at the same time. Example: Public class Mosquito extends Insect implements FlyingObject Notes: – The extends clause must precede the implements clause. – A class can have just one superclass, but it can implement any number of interfaces: public class Subclass extends Superclass implements Interface1, Interface2 …

Comparable Interface java.lang package contains the Comparable interface, which provides a useful method for comparing objects. Classes written for objects that need to be compared should implement Comparable. – Example: public interface Comparable { int compareTo(Object obj); } ***Note any class that implements Comparable must provide a compareTo method that returns a 0, negative or positive. If the objects being compared are not type compatible, a ClassCastException is thrown by the method

Abstract Class vs Interface Use an abstract class for an object that is application specific, but incomplete without its subclasses. Consider using an interface when its methods are suitable for your program, but could be equally applicable in a variety of programs An interface cannot contain instance variables, whereas an abstract class can. An interface and an abstract class can both declare constants. It is not possible to create an instance of an interface object or an abstract class object