Inheritance Chapter 9

Inheritance Superclass subclass of Animal superclass of dog and cat

Superclass has its own fields and methods Subclass inherits all of superclass fields and methods and adds some of its own Subclass has its own fields and methods

Inheritance Advantages One superclass for lots of subclasses Saves code rewriting for client Save code rewriting within class Note: There does not have to be an object of a superclass – there are no “animal” objects, but there may be: (triangle, isosceles triangle, right angle isosceles triangle).

Shapes Example Circle has: Triangle has: Make a parent: Shape color, xPosition, yPosition, Diameter Triangle has: color, xPosition, yPosition, length, height Make a parent: Shape

Assignment Circle c = new Circle ( ); Shape s = new Shape( ); s = c; // ok, a circle IS a shape c = s; // NOT ok. A shape might be something other than a Circle

Assignment a = b; // all b are a b must the same class as a, or a subclass of a b IS-A a (note: backwards of assignment order) dog is a mammal Circle is a Shape does NOT work for a IS-A b (same order as assignment) mammal is not necessarily a dog

Objects & methods obj.method( ) method must be in obj class or a parent class Circle c = new Circle(); c.draw( ); // ok. draw is a Circle method c.changeColor("green"); // ok. changeColor is a Shape method Shape s; s.draw( ) ; // NOT ok. draw is a method of its children s.changeColor("green"); // ok. changeColor is a Shape method If method is in the super class, ok. that's the point of inheritance.

Subtyping Object variables in Java can hold objects of the declared type, or of subtypes of the declared type. Big advantage in many applications

Subtyping Shape s1 = new Shape( ); // ok Circle c = new Circle( ); // ok Triangle t = new Triangle( ); // ok Shape s2 = new Circle( ); //ok. all circles are shapes Circle c2 = new Shape( ); // NOT ok. not all shapes // are circles --------- c.findCircumference ( ); // ok if method exists s2.findCircumference( ); // NOT ok ((Circle)s2).findCircumference( ); // ok s2 is a Circle LHS must be same level or higher than RHS object must be same level or lower than method Casting

Casting Turn one type into another (when it’s ok) double sphere = 4 / 3 * Math.PI * r * r * r; fix: double sphere = (double) 4 / 3 * Math.PI * r * r * r; 4.0 / 3 = double/ int = double / double = 1.333… 4 / 3 = 1 Creates a new value, 4.0 (double) from 4 3 is automatically coerced into a double. Casting does it explicitly, and is programmer controlled

Casting and Inheritance Practice A. Ok B. Not OK int y=3; double g=3; int x = (double) y; double z = (int) g; MyShape s = new Circle( ); Circle c = new Circle( ); s.moveVertical(10); c.moveVertical(10); c.findCircumference( ); s.findCircumference( ); ((Circle) s).findCircumference( ); critical } Also critical }

Methods and Inheritance ok to call method in the class or in a superclass NOT ok to call method of a subclass To do that, object must be cast to the class where method appears ((Circle) s).draw( ); // no syntax error // ok if s is a Circle Will get a run-time error if object is NOT the subclass Shape s = new Square( ) ; // ok ((Circle) s).draw( ); // ok in syntax. run time error

Practice Dog d = new Mammal(); Mammal m = new Dog( ); private final int nbrlegs = 4; private final stuff covering = FUR; ----------- Mammal() { // constructor} FeedsYoung() { nurses();} GivesBirth() { liveyoung(); } Practice A. OK B. NOT OK Dog d = new Mammal(); Mammal m = new Dog( ); StBernard s = new Dog(); m.FeedsYoung( ); d.slobbers(); s.wagstail(); s.FeedsYoung(); Dog // fields for dogs ------- Dog() {// constructor } public void wagstail() { } StBernard // fields for St. Bernards ------ StBernard { /* constructor*/} public void slobbers() { }

Practice: A. OK B. Not OK Assume we have 4 classes: Person, Teacher, Student and PhDStudent. Teacher and Student are both subclasses of Person. PhDStudent is a subclass of Student. Which of the following are legal? Person p1 = new Student( ); Person p2 = new PhDStudent( ); PhDStudent phd1 = new Student ( ); Teacher t1 = new Person( ); Student s1 = new PhDStudent( ); s1 = p1; s1 = p2; p1 = s1; t1 = s1; s1 = phd1; phd1 = s1;

Practice 2: do on the board 8.17 Look at the code below. You have four classes (O, X, T and M) and a variable of each of these. O o; X x; T t; M m; The following assignments are all legal: m = t; m = x; o = t; The following assignment are all illegal: o = m; o = x; x = o; What can you say about the relationships of these classes?

Inheritance Syntax public class Superclass { } public class Subclass extends Superclass

Inheritance code for Person public class Person { private String name; public Person() // constructor { // do constructor-like stuff } public Person(String n) { name = n; } public void getName( ) { return name; } // other methods } parent classes are no different from any classes we have written.

Code for Student public class Student extends Person inheritance is implemented with “extends” Code for Student public class Student extends Person { private String school; public Student( ) { super( ); school = "Christopher Newport University"; } public Student(String name, String school) { super(name); this.school = school; } public void getSchool( ) { return school; } } Must call parent constructor as first line of subclass constructor Must call parent constructor as first line of subclass constructor

Superclass constructor call Subclass constructors must always contain a 'super' call. If none is written, the compiler inserts one (without parameters) works only, if the superclass has a constructor without parameters Must be the first statement in the subclass constructor.

Client using Person and Student A. OK; B. NOT ok public class MyClient { Person p = new Person( ); Student s = new Student( ); Person r = new Student( ); public MyClient( ) p.getName( ); // 1 s.getSchool( ); // 2 s.getName( ); // 3 r.getSchool( ); // 4 }

Inheritance: what do we know? extends // used in subclass superclass has no indication inheritance is being used super() // calls constructor of superclass must be first statement of subclass