MIT AITI 2003 – Lecture 12

Inheritance

What is Inheritance? Real World Example: We inherit traits from our

mother and father. We also inherit traits from our grandmother, grandfather, and ancestors. We might have similar eyes, the same smile, a different height….but we are essentially “derived” from our parents.

In Software, object inheritance is more well defined! Object types that are derived from other object types “resemble” their parent classes by inheriting/copying both state/variables and behavior/methods.

Picture Representation

FOOD

FRUIT

APPLE

String namevoid eat()

String namevoid eat()int juiceLevel

String nameint juiceLevel void eat()void slice()

Both variables and methodsare inherited

inherited

inherited

Inheritance All Java classes inherit implicitly from Object Classes that inherit from other classes can

call methods from those classes, and can access their data members and methods (except for those that are private)

Inheritance is useful because it allows you to reuse functionality and to manage complexity

Inheritance Example

class A { int x;}class B extends A { int y;}class C extends B { int z;}

A

Object

B

C

Inheritance Example

xy

x

z

y

x

Instance of A has just A's fields. Its type is A (and Object).

Instance of B has fields from A and B. Its type is A and B (and Object).

Instance of C has fields from A, B and C. Its type is A, B and C (and Object).

Inheritance Examplestatic public void main(String[] args) { A aa = new A(); A ab = new B(); /* a B is also an A */ A ac = new C(); /* a C is also an A */ B bb = new B(); B bc = new C(); C cc = new C(); /* not legal -> an A is not a B! */ // B ba = new A(); /* compile error */}

Advantages of Inheritance Complex classes and data types are already

provided in java packages / libraries. We want to reuse these classes, and modify to our requirements:

java.io input/ouput operations java.swing GUI components java.awt.geom 2D geometric objects java.applet Applets embedded in web pages java.util Data Structures – collection classes (Set, List,Tree, Vector) java.sql Supports Database access

Also – we want to write very abstract classes and then specialize (abstract classes). Example: We write an abstract shape class, and then keep on adding new shapes (next lecture).

Type HierarchyObject-oriented systems allow classes to be defined in

terms of other classes. For example, a square, triangle, and circle are all shapes. In object-oriented terminology, a square/triangle/circle are subclasses of the shape class. Similarly, the shape class is the superclass of all shape objects. Shape objects are also Objects.

Object

Shape

Circle Triangle Square

Class/Type HierarchyInheritState andBehavior

Specialize

Point

Pixel

Reusing Classes We wrote a Point class. Now we want a ColorPoint

class or a GraphicsPixelPoint class. We can just use existing variables/methods in the Point

class (inherit these) and then write more code to add new functionality (extend the base class). We simply add a color field to our Point, or other graphics information for a pixel point.

We can use 2D geometry package classes already in java.awt.geom, and extend these classes to have specialized behavior. (Don’t need to reinvent Line, Circle, Rectangle classes.)

Less Elegant Way of “reuse”public class ColorPoint {

private Point point; private Color color; // We wrap a color field around a Point object. public ColorPoint(Point p, Color color) { point = p; this.color = color; } }

DELEGATION

Extending the Point Class/Typepublic class ColorPoint extends Point { private Color color; public ColorPoint(double x, double y, Color color) { super(x, y); // Make into a Point first. this.color = color; // Add info for new ColorPoint. }

}

INHERITANCE

Constructors… Example Ipublic class Shape {

Shape() { System.out.println(“I am a Shape”); }

}

public class RoundShape extends Shape {

RoundShape() { System.out.println(“I am a Round Shape”); }

}

public class Circle extends RoundShape {

Circle() { System.out.println(“I am a Circle”); }

public static void main(String[] args) {

Circle x = new Circle();

}

}

Output of ProgramI am a Shape

I am a Round Shape

I am a Circle

Default Constructors for superclasses called.

When we construct a Circle, we are first making it a Shape, then a RoundShape, and finally a Circle.

Constructor Example II

class Plant { private String kingdom; private String genus; private String species; private boolean poisonous; public Plant(String g, String s, boolean p) { kingdom= "Plantae"; genus= g; species= s; poisonous= p; } }

We write a base Plant class. All Plants are kingdom Plantae.Specific objects of the Plant type have a genus and species.

continued…

class Tree extends Plant { private double crownSize; private double trunkSize; public Tree(String g, String s, double cs, double ts) { super(g, s, false); crownSize= cs; trunkSize= ts; }}

An object of Type Tree is also a Plant. Hence, it is of kingdom Plantae. We first call the super class constructor to make our object a Plant. Then we add crownSize and trunkSize modifications to make our object a Tree.

Hiding fields

class SuperClass { int inheritData; double data;}class SubClass extends SuperClass { float data;}

SubClass inherits inheritData. However, data is defined twice.

In SubClass, we now have two data fields (one hidden)float data is newly defined.super.data can also be accessed in subclass.

Overriding Methods

class SuperClass { … boolean isTrue() { } int totalSum(int x, int y) { }}

class SubClass extends SuperClass { … // OVERRIDE totalSum method above, and add something. int totalSum(int x, int y) { super.totalSum(x, y); // Can Call Superclass method.

// Do something more now, MODIFY System.out.println(“I can now add modifications.”); }}

Access: Private,Public,Protected,no access specified (package)

• Super Class may contain members (methods or data) of type:– Private:

• Know About This: Access only internally in class.

– Protected (a little unsafe, tricky, so avoided)• Access:

– To Methods of all Subclasses.– To all Classes in same package

– Package (no access specified)• Access by methods of classes in same package

– Public:• Know about this: Access to all classes everywhere.

Final and Static• In SuperClass, can define a variable or

method as final and static:

Static: If subclass has access, then it will inherit the static variable or static method and it will be shared between all objects of a derived class AND base class.

Final: If a variable, method, or class is defined as FINAL, then it cannot be overriden in a subclass.

Casting ObjectsFrom the inheritance concept, we now also can CAST objects into

different types.OBJECT POINT COLORPOINT

// Don’t need Cast if assigning a superclass type.Point p = new Point(4.4, 5.6);Object pHolder = (Object)p;Object pHolder = p; // Could just write this statement.

// Need Casting if assigning a subclass type.Object x = new Point(3.0, 4.4);Point xPoint = (Point) x;

When Casting is NeededOBJECT POINT COLORPOINT

In general, don’t need to cast unless we need methods of the subclass type.

Object o = new ColorPoint(4.4, 3.4, new Color(“red”));Can use: o.toString() and will get appropriate method.Can’t use: o.getX() since o has object type, not point.

So cast to use getX() method.

Continued…

OBJECT POINT COLORPOINT

Object o = new ColorPoint(4.4, 3.4, new Color(“red”));Can’t use: o.getX();

Using Casting to Point:Now Can Use: ( ( Point ) o ).getX();

OR can use ColorPoint cast to use very specific methods:

((ColorPoint) o).getColor();

Casting Example

Vector v = new Vector();

v.addElement(new Rectangle(…..));v.addElement(new Square(……));v.addElement(new Circle(……));

for (int k = 0; k < v.size(); k++) { v.elementAt(k).toString(); ((v.elementAt(k)) Shape).draw(); // Cast needed}

Casting - Summary

In general casting is not encouraged – becomes too confusing. A programmer should design superclasses properly so we don’t need to call specific methods all the time.

But, many advantages (previous Vector exercise):We can draw all types of different shapes just by

using a general draw method. We don’t have to call each rectangle, circle, square draw method separately.

Programming Example A Company has a list of Employees. It asks you

to provide a payroll sheet for all employees. Has extensive data (name, department, pay amount,

…) for all employees. Different types of employees – manager, engineer,

software engineer. You have an old Employee class but need to add very

different data and methods for managers and engineers.

Suppose someone wrote a name system, and already provided a legacy Employee class. The old Employee class had a printData() method for each Employee that only printed the name. We want to reuse it, and print pay info.

Borrowed with permission from Course 1.00 Notes

public … Main(…){Employee e1…(“Mary”,“Wang”);...e1.printData();// Prints Employee names....}

Employee e1

lastNamefirstName

printData

Encapsulation Message passing “Main event loop”

private:

REVIEW PICTURE

Employee classclass Employee { // Data private String firstName, lastName; // Constructor public Employee(String fName, String lName) { firstName= fName; lastName= lName; } // Method public void printData() { System.out.println(firstName + " " + lastName);}}

This is a simple super or base class.

InheritanceClass Employee

firstNamelastName

printData()

Class Manager

salary

firstNamelastName

Class Engineer

hoursWorkedwages

firstNamelastName

printData()getPay()

is-a

printData()getPay()

Already written:

is-a

You next write:

Engineer class

Class Engineer extends Employee { private double wage; private double hoursWorked; public Employee(String fName, String lName, double rate, double hours) { super(fName, lName); wage = rate; hoursWorked = hours; }

public double getPay() { return wage * hoursWorked; }

public void printData() { super.printData(); // PRINT NAME System.out.println("Weekly pay: $" + Wage*

hoursWorked); }}

Subclass or (directly) derived class

Manager class

class Manager extends Employee { private double salary;

public Manager(String fName, String lName, double sal){ super(fName, lName); salary = sal; }

public double getPay() { return salary; }

public void printData() { super.printData(); System.out.println("Monthly salary: $“ + salary);}}

Subclass or (directly) derived class

Inheritance…

Class Manager

Salary

firstNamelastName

printDatagetPay

Class SalesManagerfirstNamelastName

printDatagetPay

Salary

salesBonus

is-a

SalesManager Class

class SalesManager extends Manager { private double bonus; // Bonus Possible as commission.

// A SalesManager gets a constant salary of $1250.0 public SalesManager(String fName, String lName, double b) { super(fName, lName, 1250.0); bonus = b; }

public double getPay() { return 1250.0; }

public void printData() { super.printData(); System.out.println(“Bonus Pay: $" + bonus; } }

Derived class from derived class

Main methodpublic class PayRoll { public static void main(String[] args) { // Could get Data from tables in a Database. Engineer fred = new Engineer(“Fred", "Smith", 12.0, 8.0); Manager ann = new Manager("Ann", "Brown", 1500.0); SalesManager mary= new SalesManager("Mary", “Kate", 2000.0);

// Polymorphism, or late binding Employee[] employees = new Employee[3]; employees[0]= fred; employees[1]= ann; employees[2]= mary; for (int i=0; i < 3; i++) employees[i].printData(); }}

Java knows theobject type andchooses the appropriate methodat run time

Output from main method

Fred SmithWeekly pay: $96.0Ann BrownMonthly salary: $1500.0Mary BarrettMonthly salary: $1250.0Bonus: $2000.0

Note that we could not write:employees[i].getPay();

because getPay() is not a method of the superclass Employee. In contrast, printData() is a method of Student, so Java can find the appropriate version.