Inheritance in Java

1. Inheritance in Java

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. CheckingAccount SavingsAccount - rate - chargeMonthlyFee() - chargeTransFee() - depositInterest() - checkBalanceLimit() What is inheritance (in Java)? BankAccount - balance + deposit + withdraw + getBalance() RHS – SOC

6. Inheritance in code public class SavingsAccount extends BankAccount { privatedouble rate; public SavingsAccount(double rate) {...} publicvoid depositInterest() {...} publicbool 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 Superclass - balance + deposit + withdraw + getBalance() SavingsAccount Subclass - rate - depositInterest() - checkBalanceLimit() RHS – SOC

9. Inheritance • Why is the class with most functionality called the subclass? • Terminology from set theory BankAccount Checking Account Savings 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 publicvoid deposit(double amount) { balance = balance + amount; } // Overridden method in CheckingAccount publicvoid deposit(double amount) { balance = balance + amount; transactionCount++; } Ooops! RHS – SOC

22. Inheriting methods // Overridden method in CheckingAccount publicvoid 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 RHS – SOC