Inheritance in Java

RHS – SOC 2 What is inheritance (in Java)? Inheritance is a mechanism for enhancing existing classes What does that mean…? Defining new classes, which build on the function- ality of existing classes

RHS – SOC 3 What is inheritance (in Java)? Suppose we have a BankAccount class, which provides basic functionality common for all types of bank accounts –Depositing money –Withdrawing money –Retrieving the balance But most bank accounts have more functionality that just this…

RHS – SOC 4 What is inheritance (in Java)? Bank Account Checking Account Monthly fee Transaction fee Savings Account Monthly interest Upper balance limit

RHS – SOC 5 What is inheritance (in Java)? BankAccount - balance + deposit + withdraw + getBalance() CheckingAccount - chargeMonthlyFee() - chargeTransFee() SavingsAccount - rate - depositInterest() - checkBalanceLimit()

RHS – SOC 6 Inheritance in code public class SavingsAccount extends BankAccount { private double rate; public SavingsAccount(double rate) {...} public void depositInterest() {...} public bool checkBalanceLimit() {...} }

RHS – SOC 7 Inheritance We only need to define the new methods and instance fields for SavingsAccount Methods and instance fields from BankAccount are inherited We extend the BankAccount class without touching it (code reuse) ”Closed for modification, open for extension”

RHS – SOC 8 Inheritance BankAccount - balance + deposit + withdraw + getBalance() SavingsAccount - rate - depositInterest() - checkBalanceLimit() Superclass Subclass

RHS – SOC 9 Inheritance Why is the class with most functionality called the subclass? Terminology from set theory BankAccount Savings Account Checking Account

RHS – SOC 10 Inheritance vs. Interfaces Related, but not the same If you must implement an interface, you are ”ordered” to implement a set of certain methods If you extend a class, you get something ”for free”

RHS – SOC 11 Inheritance vs. Interfaces One quite important difference between inheritance and interfaces: –A class can implement multiple interfaces –A class can only extend one class –There is no such thing as multiple inheritance in Java… –Multiple inheritance has issues, taken out of Java to keep things simple

RHS – SOC 12 Inheriting methods A subclass has three options when defining methods: –Inherit methods as-is –Override methods –Define new methods (just as we are used to)

RHS – SOC 13 Inheriting methods Inherit methods as-is Just as it sounds – the method will work exactly as it works in the superclass Methods can (still) be applied to objects of the superclass, and also to objects of the subclass

RHS – SOC 14 Inheriting methods Override methods We can actually provide a different imple- mentation of a method from the superclass Superclass may provide a reasonable default implementation Subclasses may substitute it for a more useful implementation

RHS – SOC 15 Inheriting methods public class DefaultShape { public void draw() { // do nothing } public double getArea() { return 0.0;} }

RHS – SOC 16 Inheriting methods public class Circle extends DefaultShape { // new instance fields, etc. public void draw() // Override { // code for drawing a Circle } public double getArea() // Override { return (radius*radius*Math.PI); }

RHS – SOC 17 Inheriting methods public class Point extends DefaultShape { // new instance fields, etc. public void draw() // Override { // code for drawing a Point } // However, I keep implementation of getArea }

RHS – SOC 18 Inheriting methods DefaultShape ds = new DefaultShape(); double area1 = ds.getArea(); Circle c = new Circle(1,1,1); double area2 = c.getArea(); Point p = new Point(1,1); double area3 = p.getArea(); DefaultShape dsc = new Circle(2,2,2); double area4 = ds.getArea();

RHS – SOC 19 Inheriting methods ”In Java, method calls are always determined by the type of the actual object, not the type of the object reference” This is polymorphism

RHS – SOC 20 Inheriting methods What if we want to ”supple- ment” a method, not override it completely Do we need to implement all of the code in the super- class again? No – and it would break encapsulation!

RHS – SOC 21 Inheriting methods // Original method from BankAccount public void deposit(double amount) { balance = balance + amount; } // Overridden method in CheckingAccount public void deposit(double amount) { balance = balance + amount; transactionCount++; } Ooops!

RHS – SOC 22 Inheriting methods // Overridden method in CheckingAccount public void deposit(double amount) { super.deposit(amount); transactionCount++; } ”Do what the superclass does in deposit, then do my stuff” New keyword!

RHS – SOC 23 Inheriting methods We can also do this for constructors! // Constructor for subclass public CheckingAccount(double initialBalance) { super(initialBalance); // Now do initialisation specific for // the CheckingAccount class transactionCount = 0; }

RHS – SOC 24 Conversions Rules for conversion between super- and sub-class are similar to conversion rules between interfaces and implementation class –Always legal to convert to a superclass –Legal – but risky – to cast from superclass to subclass

RHS – SOC 25 Conversions In other words: DefaultShape s1 = new Square(10,10,10); // OK DefaultShape s2 = new Point(20,20);// OK Circle c = new Circle(5,10,20);// OK DefaultShape s = new DefaultShape(); // OK (!) Circle c = new DefaultShape();// NO! Square sq = new Circle(5,20,40);// NO!

RHS – SOC 26 Conversions And this is still dangerous! public void enlarge(DefaultShape s) { Circle c = (Circle)s; double r = c.getRadius(); c.setRadius(2*r); } OK – if s is a Circle!

RHS – SOC 27 Exercises Self-check: 1, 3, 10, 11 Review: R10.3, R 10.7 Programming: P10.4