1. Introduction to Java 2 Programming Lecture 5 Inheritance

2. Overview • Inheritance • …and Encapsulation • …and Constructors • …and Methods • Including overriding and overloading • Controlling Inheritance

3. Quick Recap • Inheritance defines parent-child relationships • Base (or super) class, and derived (or sub-) class • Child inherits all functionality of its parent • Typically add new methods and member variables • One of the basic features of all OO languages • Already encountered it in Robocode • All your robots extend a provided Robot base class • All robocode events extend an Event base class • You can extend almost any object • With a couple of extensions as we’ll see…

4. Using Inheritance • Use the extends keyword in the class definition: public class MyRobot extends Robot { } • A class can only extend one base class • Unlike C++ Java doesn’t allow multiple inheritance • All Java classes extend a common base class (java.lang.Object) • Automatically assumed by the compiler, unless you say otherwise • Provides some basic functionality, e.g. toString() and equals() public class Calculator extends Object { }

5. Inheritance and Encapsulation • Sub-classes inherit all their superclass member variables • But may not be able to access them directly! • The visibility modifiers, public, protected, and private apply • Only public and protected are accessible • Private member variables of a base class cannot be altered by a sub-class (except via a method) • Tip: Try to avoid breaking encapsulation by making variables private, unless you’re expecting the class to “have children”

6. Inheritance and Encapsulation public class Person { private String _name; private String _email; //can be access by sub-classes protected int _salary; public String getName() {…} public String setName() {…} }

7. Constructors Revisited • Constructors can call one another • Allows initialisation code to be kept in one place (not duplicated between constructors) • Use the this keyword to call another constructor in the same class • Must be first line in the constructor public class Bookmark { public Bookmark(String url) { this( new URL(url) ); } public Bookmark(URL url) { //other initialisation code } }

8. Inheritance and Constructors • An class must ensure that its parent is properly initialised, by calling one of its constructors • Use the super keyword • Even if a constructor isn’t explicitly called a call to the default constructor is added by compiler • Base class constructors are called first • Inheritance happens from the top down • …ancestors, parent, child…

9. Constructors public class Parent { private String msg; public Parent() {} public Parent(String message) { msg = message; } } public class Child extends Parent {   public Child()  {    super("Parent message");  } } public class OtherChild extends Parent { }

10. Method Overloading • A Java class can define several methods with the same name, so long as • the parameters are different, the return type is the same public int doSomething(String s, String s2); public int doSomething(String s); public int doSomething(int x, int y); • Java determines the correct method to call by checking the parameters • Useful to provide variants of a method that work on different types of object • Typically one method does all the work, and the others call it • As with constructors, this collects common code into a single method

11. Method Overriding • A sub-class can define a method with the same name and parameters as as base class • Known as overriding • Useful when some aspect of the base class behaviour must be altered • To completely change the implementation, just define a new version (in the child) • To partially change the implementation use the super keyword to refer to the parents original implementation

12. Inheritance and Methods • What happens when we call a method? • The JVM tries to find the implementation of that method and then execute the code • Starts searching with the objects class, then works upward to its parent…its parent’s parent…etc, etc. • Searching for methods works from the bottom-up • Reverse of how constructors are called • Also explains how a sub-class can substitute its own behaviour for a base class • JVM finds that first.

13. Worked Example • In an E-Commerce system we might have a class responsible for calculating prices e.g: public class Pricer { public float calculatePrice(Product p) {  //implementation details irrelevant for example } } • The Product parameter lets the Pricer calculate the price

14. Worked Example • Assume we want to extend this functionality so that the calculation also includes tax (i.e. adding on VAT). • US purchases don't include tax, but UK ones do, so we can't just rewrite the original method. • Instead we create a subclass, called UKPricer that does the extra work. public class UKPricer extends Pricer { public float calculatePrice(Product p) {  //this implementation will also add on VAT… } }

15. Worked Example • Ideally we want to reuse the code in the base class, as all we need to do is add on the extra 17.5% to the final price. • We can do better than copy-and-paste using super… public class UKPricer extends Pricer { public float calculatePrice(Product p) {    //call the superclass method   float withoutTax = super.calculatePrice(p);   float tax = withoutTax * 17.5 / 100;  return withoutTax + tax; } }

16. Controlling Inheritance – Restricting • Inheritance can be restricted using the final keyword • Applies to both methods and classes • A final class cannot be extended • A final method cannot be overridden public final class MyClass { } public class OtherClass { public final int aMethod() { … } }

17. Controlling Inheritance – Enforcing • Inheritance can be forced by using the abstract keyword • Again applies to both methods and classes • An abstract class must be extended, cannot be used to create objects • An abstract method must be overrided by a sub-class • A class with at least one abstract method must be declared abstract public abstract class SomeOtherClass { public int aMethod() { … } public abstract void otherMethod(); }