Inheritance in Java

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 DCS – SWC

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… DCS – SWC

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

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

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

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” DCS – SWC

Inheritance Superclass Subclass BankAccount - balance + deposit + withdraw + getBalance() SavingsAccount Subclass - rate - depositInterest() - checkBalanceLimit() DCS – SWC

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

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” DCS – SWC

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 DCS – SWC

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) DCS – SWC

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 DCS – SWC

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 DCS – SWC

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

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); DCS – SWC

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 DCS – SWC

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(); DCS – SWC

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 DCS – SWC

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! DCS – SWC

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

Inheriting methods New keyword! // 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! DCS – SWC

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; } DCS – SWC

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 DCS – SWC

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! DCS – SWC

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! DCS – SWC