You are on page 1of 19

Chapter 4-Inheritance

Lecture Notes

Chapter 4-Inheritance Lecture Notes Inheritance 1

Inheritance

Chapter 4-Inheritance Lecture Notes Inheritance 1
Inheritance: Definition
Inheritance: Definition
  • inheritance: a parent-child relationship between classes

  • allows sharing of the behavior of the parent class into its child classes

    • one of the major benefits of object-oriented programming (OOP) is this code sharing between classes through inheritance

  • child class can add new behavior or override existing behavior from parent

Inheritance terms
Inheritance terms
  • superclass, base class, parent class: terms to describe the parent in the relationship, which shares its functionality

  • subclass, derived class, child class: terms to describe the child in the relationship, which accepts functionality from its parent

  • extend, inherit, derive: become a subclass of another class

Cont ...
Cont ...
  • Inheritance is a fundamental Object Oriented concept

  • A class can be defined as a "subclass" of another class.

    • The subclass inherits all data attributes of its superclass

    • The subclass inherits all methods of its superclass

    • The subclass inherits all associations of its superclass

  • The subclass can:

    • Add new functionality

    • Use inherited functionality

    • Override inherited functionality

  • superclass:

    Person

    • - name: String

    • - dob: Date

    subclass:

    Employee

    • - employeeID: int

    • - salary: int

    • - startDate: Date

    What really happens?

    What really happens?
    • When an object is created using new, the system must allocate enough memory to hold all its instance variables.

      • This includes any inherited instance variables

    • In this example, we can say that an Employee "is a kind of" Person.

    An Employee object inherits all of the attributes, methods and associations Person of Person Person name
    An Employee object inherits all of the attributes, methods and
    associations
    Person
    of Person
    Person
    name = "John
    -
    name: String
    Smith"
    -
    dob: Date
    dob = Jan 13, 1954
    Employee
    name = "Sally Halls"
    is a kind of
    Employee
    dob = Mar 15, 1968
    employeeID = 37518
    -
    employeeID: int
    salary = 65000
    -
    salary: int
    startDate = Dec 15,
    -
    startDate: Date
    2000

    Inheritance in Java

    Inheritance in Java
    Inheritance in Java Inheritance is declared using the "extends" keyword If inheritance is not defined, the

    Inheritance is declared using the "extends" keyword

    Inheritance in Java Inheritance is declared using the "extends" keyword If inheritance is not defined, the

    If inheritance is not defined, the class extends a class called Object

    public class Person

    {

    private String name;

    private Date dob; ...

    [

    ]

    public class Employee extends Person { private int employeID;

    private int salary;

    private Date startDate; ...

    [

    ]

    Person

    • - name: String

    - dob: Date Employee
    - dob: Date
    Employee
    • - employeeID: int

    • - salary: int

    • - startDate: Date

    Employee anEmployee = new Employee();

    Inheritance Hierarchy

    Inheritance Hierarchy
    • Each Java class has one (and only one) superclass.

      • C++ allows for multiple inheritance

    • Inheritance creates a class hierarchy

      • Classes higher in the hierarchy are more general and more abstract

      • Classes lower in the hierarchy are more specific and concrete

    • There is no limit to the number of subclasses a class can have

    • There is no limit to the depth of the class tree.

    Class

    Inheritance Hierarchy Each Java class has one (and only one) superclass. C++ allows for multiple inheritance

    Class

    Class

    Class

    Class Class Class Class Class Class Class
    Class Class Class Class Class Class Class
    Class Class Class Class Class Class Class

    Class

    Class

    Class

    Class

    The class called Object

    The class called Object
    • At the very top of the inheritance tree is a class called Object

    • All Java classes inherit from Object.

      • All objects have a common ancestor

      • This is different from C++

  • The Object class is defined in the java.lang package

    • Examine it in the Java API Specification

  • Object

    Constructors and Initialization

    Constructors and Initialization
    • Classes use constructors to initialize instance variables

      • When a subclass object is created, its constructor is called.

      • It is the responsibility of the subclass constructor to invoke the appropriate superclass constructors so that the instance variables defined in the superclass are properly initialized

  • Superclass constructors can be called using the "super" keyword in a manner similar to "this"

    • It must be the first line of code in the constructor

  • If a call to super is not made, the system will automatically attempt to invoke the no-argument constructor of the superclass.

  • Constructors - Example

    Constructors - Example

    public class BankAccount {

    private String ownersName; private int accountNumber; private float balance;

    public BankAccount(int anAccountNumber, String aName) {

    accountNumber = anAccountNumber; ownersName = aName;

    }

    }

    [

    ...

    ]

    public class OverdraftAccount extends BankAccount {

    private float overdraftLimit;

    public OverdraftAccount(int anAccountNumber, String aName, float aLimit) { super(anAccountNumber, aName); overdraftLimit = aLimit;

    }

    }

    Method Overriding

    Method Overriding
    • Subclasses inherit all methods from their superclass

      • Sometimes, the implementation of the method in the superclass does not provide the functionality required by the subclass.

      • In these cases, the method must be overridden.

  • To override a method, provide an implementation in the subclass.

    • The method in the subclass MUST have same name and type signature as the method it is overriding.

  • Method overriding - Example

    Method overriding - Example

    public class BankAccount {

    private String ownersName; private int accountNumber; protected float balance;

    public void deposit(float anAmount)

    {

     

    if (anAmount>0.0) balance = balance + anAmount;

    }

    public void withdraw(float anAmount)

    {

     

    if ((anAmount>0.0) && (balance>anAmount)) balance = balance - anAmount;

    }

    public float getBalance() {

    return balance;

    }

    }

    Method overriding - Example

    Method overriding - Example

    public class OverdraftAccount extends BankAccount { private float limit;

    public void withdraw(float anAmount)

    {

     

    if ((anAmount>0.0) && (getBalance()+limit>anAmount)) balance = balance - anAmount;

    }

    }

    Composition vs. Inheritance

    "

    "is a" relationship

    Inheritance

    "

    "has a" relationship

    Composition, having other objects as members

    "

    Example

    Employee “is a” BirthDate;

    //Wrong!

    Employee “has a” Birthdate; //Composition

    final Methods and Classes

    "

    Declaring variables final

    Indicates they cannot be modified after declaration Must be initialized when declared

    "

    Declaring methods final

    Cannot be overridden in a subclass static and private methods are implicitly final

    "

    Declaring classes final

    Cannot be a superclass (cannot inherit from it) All methods in class are implicitly final

    15

    "

    When a subclass method overrides an inherited superclass method, the superclass method can be accessed from the subclass by preceding the superclass method name with keyword super and a dot (.) separator.

    Every object of a subclass is also an object of that

    class’s superclass. However, a superclass object

    is not an object of its class’s subclasses.

    "

    The annotation @Override (p. 368) indicates thata methodshould override a superclass method. When the compiler encounters a method declared

    with @Override, it compares the method’s signature with the superclass’s method signatures. If there isn’t an exact match, the compiler issues

    an error message, such as “method does not override or implement a method from a supertype.”

    Second Use for super The second form of super acts somewhat like this, except that it always refers to the superclass of the subclass in which it is used. This usage has the following general form: super.member Here, member can be either a method or an instance variable. This second form of super is most applicable to situations in which member names of a subclass hide members by the same name in the superclass. Consider this simple class hierarchy:

    // Using super to overcome name hiding. class A { int i; }

    class B extends A {

    int i; // this i hides the i in A B(int a, int b) { super.i = a; // i in A i = b; // i in B } void show() {

    System.out.println("i in superclass: " + super.i);

    System.out.println("i in subclass: " + i); } } class UseSuper { public static void main(String args[]) { B subOb = new B(1, 2); subOb.show(); } }

    When Constructors Are Called

    "

    class A { A() { System.out.println("Inside A's constructor."); } }

    // Create a subclass by extending class A.

    class B extends A { B() { System.out.println("Inside B's constructor."); } }

    // Create another subclass by extending B.

    class C extends B {

    C() { System.out.println("Inside C's constructor."); } } class CallingCons {

    public static void main(String args[]) {

    C c = new C();

    }

    }