09 Inheritance

2 Contents Defining Inheritance Relationships of Inheritance Rules of Inheritance super and this references super() and this() methods Constructor Chaining Casting

3 Objectives Define inheritance Identify relationships of inheritance Describe the rules of inheritance Describe the difference between this and super references Describe the difference between this() and super() methods Describe how to create constructors Describe the steps in constructor chaining Describe how to convert data types using casting

4 Defining Inheritance Inheritance is the ability to derive new classes from existing ones. A derived class ("subclass") inherits the instance variables and methods of the base class ("superclass"), and may add new instance variables and methods. Inheritance defines a hierarchical relationship among classes wherein one class shares the attributes and methods defined in one or more classes. Inheritance is a relationship among classes in which one class shares the structure and behavior of another. A subclass inherits from a superclass.

5 Relationships of Inheritance “is-a” relationship a subclass can be used wherever a superclass can be used implemented in Java by extending a class “has-a” relationship a whole-class relationship between a class and its parts also known as composition or aggregation implemented in Java by instantiating an object inside a class Car Engine Wheel “has-a” relationship “is-a” relationship Vehicle Car Bus

6 Rules of Inheritance A class can only inherit from one class (known as single inheritance). A subclass is guaranteed to do everything the superclass can do. A subclass inherits members from its superclass and can modify or add to its behavior and properties. A subclass can define members of the same name in the superclass, thus hiding the superclass members. Inheritance is transitive (i.e., class A inherits from class B, including what B inherited from class C). All classes inherit from the Object class - the highest in the inheritance hierarchy. private members, hidden members, and constructors are not inherited by subclasses.

7 Inheritance Hierarchy Object SystemMathVehicle CarBoat Person EmployeeDoctor

8 Implementing Inheritance Inheritance is implemented in Java by the extends keyword class Student extends Person { String course; double grade; /* * other members of Person class * can be accessed here */ } public static void main(String[] args) { Student junior = new Student(); // access current class members junior.course = "Computer Science"; junior.grade = 1.5; // access superclass members junior.setName("Andrew"); junior.setAge(21); junior.setSex('M'); } class Person { // set variables to private private static int maleCount; private static int femaleCount; private String name; private char sex; private int age; /* * setters & getters, set to public */ public int getAge() { return age;} public void setAge(int a) { age = a;} public String getName() { return name;} public void setName(String n) { name = n;} public char getSex() { return sex;} public void setSex(char s) { sex = s;} /* * other methods here */ }

9 this and super this is a reference to the object of the current class It can be used to distinguish instance variables from local variables It can be assigned to other references, or passed as a parameter, or cast to other types It cannot be used in a static context super is a reference to the object of a superclass Used to access hidden members of the superclass It cannot be assigned to other references, nor passed as a parameter, nor cast to other types It cannot be used in a static context

10 Using this and super class Student extends Person { private String course; private double grade; static int studentCount; // setters & getters public String getCourse(){return course;} public void setCourse(String course) { this.course = course; } public double getGrade(){return grade;} public void setGrade(double grade) { this.grade = grade; } // access superclass members public void printInfo() { System.out.println(super.getName()); System.out.println(super.getSex()); System.out.println(super.getAge()); } class Person { // set variables to private private static int maleCount; private static int femaleCount; private String name; private char sex; private int age; /* * setters & getters, set to public */ public int getAge() { return age;} public void setAge(int a) { age = a;} public String getName() { return name;} public void setName(String n) { name = n;} public char getSex() { return sex;} public void setSex(char s) { sex = s;} /* * other methods here */ }

11 Constructor Chaining Constructor chaining is invoking all the constructors in the inheritance hierarchy. Constructor chaining guarantees that all superclass constructors are called. Constructors are invoked starting with the current class up to the Object class, then they are executed in reverse order.

12 this() and super() this( ) used to call constructors within the same class used to implement local chaining of constructors must be the first statement in a constructor and can only be used in a constructor super( ) used to invoke constructors in the immediate superclass used to implement chaining of subclass-to-superclass constructors must be the first statement in a constructor and can only be used in a constructor

13 Implementing Constructor Chaining class Person { private String name; private char sex; private int age; Person() {// default constructor sex = 'M'; age = 0; } } class Student extends Person { String course; double grade; static int studentCount; Student() {// default constructor super(); // chain to superclass studentCount++; } Student(String n) {// overloaded constructor (non-default) this();// local chain super.setName(n); } } public static void main(String[] args) { Student junior = new Student("Andrew"); }

14 Casting Casting is converting from one data type to another Implicit casting is an implied casting operation Explicit casting is a required casting operation Primitive casting is converting a primitive data type to another data type Widening conversion is casting a narrower data type to a broader data type Narrowing conversion is casting a broader data type to a narrower data type Reference casting is converting a reference data type to another Upcasting is conversion up the inheritance hierarchy Downcasting is conversion down the inheritance hierarchy Casting between primitive and reference type is not allowed In Java, casting is implemented using () operator

15 Reference Casting Flow Vehicle Car Boat Plane “Upcasting” Vehicle Car BoatPlane Imagine it as a container! “Downcasting”

16 Reference Casting Rule OperationConversion Type string concatenationimplicit upcasting parameter passingimplicit upcasting (if formal parameter is a superclass) (all others)explicit casting (downcasting or upcasting )

17 Implementing Reference Casting public class Vehicle {} public class Car extends Vehicle {} public class Boat extends Vehicle {} public class Plane extends Vehicle {} public static void main(String args[]) { Vehicle v = new Vehicle(); Car c = new Car(); Boat b = new Boat(); Plane p = new Plane(); Vehicle vc = new Car(); v = c; // This will compile. c = v; // This will not compile!!! b = p; // will this compile? b = (Boat) v; // will this compile? c = (Car) vc; // will this compile? }

18 Key Points Inheritance is deriving a new class (subclass) from an existing class (superclass) Inheritance can exhibit an “is-a” or “has-a” relationship In Java, a class can only inherit from a single class All classes inherit from Object class – the highest in the inheritance hierarchy In Java, inheritance is implemented by the extends keyword this is a reference to the object of the current class super is a reference to the object of a superclass this() is used to call constructors within the same class super() is used to invoke constructors in the immediate superclass Casting is converting from one data type to another