Inheritance Chapter 8

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

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

Polymorphic variables Object variables in Java are polymorphic. (They can hold objects of more than one type.) They can hold objects of the declared type, or of subtypes of the declared type. Shape s1; s1 = new Shape(); s1 = new Circle(); s1 = new Triangle(); s1 is three different types (in the same program), s1 is polymorphic.

Polymorphism: assignment a = b; // all b are a b must be able to "fit into"/be lower than/be a subclass of a b IS-A a (note: backwards of assignment order) does NOT work for a IS-A b (same order as assignment)

Polymorphism: objects & methods obj.method( ) method must be in obj class or obj must be cast to the class where method appears obj can be cast to a LOWER class (subclass), but will get a run-time error if obj is NOT the subclass If method is an super class, ok without casting. that's the point of inheritance.

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 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 8.11: 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 and why? 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 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 code for Shape parent classes are no different from any classes we have written. public class Shape { private String color; private int xPosition; private int yPosition; Shapes() // constructor { // do something constructor-like } // methods

Inheritance code for Circle inheritance is implemented with “extends” Inheritance code for Circle public class Circle extends Shape { private int diameter; Circle() super(); // Shapes ctor // more constructor stuff } // other Circle methods 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.

arrow with open head means inherits from Shapes arrow with open head means inherits from Don't try this at home: Shapes inheritance is natural, but doesn't work well with what we know now. Problem: Circle cannot access private fields of Shape (like xPosition), so cannot draw itself. But Shape doesn't know enough about Circles to draw it. So, draw() can’t be in Circle or Shape, so circles can't be drawn. One solution is to make some parts protected (Chapter 9) or make Shapes an abstract class (Chapter 10).

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

Book Example: DoME "Database of Multimedia Entertainment" stores details about CDs and videos CD: title, artist, # tracks, playing time, got-it, comment Video: title, director, playing time, got-it, comment allows (later) to search for information or print lists database to store details of all CDs and videos I know This and the next 10 slides are from OBWJ instructor web page.

DoME objects one object per CD or video; each object stores details for one item.

DoME classes add the obvious methods (getters and setters); not complete here - just examples add a print method to print out the details

Using inheritance solution: inheritance. make superclass with common attributes, make subclasses

Subclasses public class CD extends Item { private String artist; private int numberOfTracks; // constructors and methods omitted. } we add subclass fields; inherit superclass fields (note extends keyword) subclass objects will have all fields. public class Video extends Item { private String director; // constructors and methods omitted. }

Superclass: Item public class Item { private String title; private int playingTime; private boolean gotIt; private String comment; /** * Initialise the fields of the item. */ public Item(String theTitle, int time) title = theTitle; playingTime = time; gotIt = false; comment = ""; } // methods omitted Superclass: Item how do we initialise the fields? superclass: nothing unusual.

Inheritance and constructors public class CD extends Item { private String artist; private int numberOfTracks; /** * Constructor for objects of class CD */ public CD(String theTitle, String theArtist, int tracks, int time) super(theTitle, time); artist = theArtist; numberOfTracks = tracks; } // methods omitted subclass: must call superclass constructor! Must take values for all fields that we want to initialise.

Database source code Advantage: Uses Item, not CD or Video public class Database { private ArrayList items; /** * Construct an empty Database. */ public Database() items = new ArrayList(); } * Add an item to the database. public void addItem(Item theItem) items.add(theItem); ... Taakes Advantage: Uses Item, not CD or Video note: code duplication in class Database removed as well! only on field, one ArrayList creation, on add method otherwise would have one addItem for CDs, one for videos (that's how original is)

Subtyping and parameter passing public class Database { public void addItem(Item theItem) ... } Video video = new Video(...); CD cd = new CD(...); database.addItem(video); database.addItem(cd); subclass objects may be passed to superclass parameters

Object diagram database object will hold two collections: one for CDs, one for videos

Class diagram without inheritance class diagram is simple (ArrayList not shown in BlueJ)

Class diagram with inheritance Much cleaner. subtyping takes care of different types. class diagram is simple (ArrayList not shown in BlueJ)

Polymorphic variables Object variables in Java are polymorphic. (They can hold objects of more than one type.) They can hold objects of the declared type, or of subtypes of the declared type. Big advantage in many applications

Polymorphic collections All (pre-Java 5)collections are polymorphic. The elements are of type Object. public void add(Object element) public Object get(int index)