Inheritance in Java - BunksAllowed

BunksAllowed

BunksAllowed is an effort to facilitate Self Learning process through the provision of quality tutorials.

Community

Join WhatsApp Grpup using https://chat.whatsapp.com/EAcqRurEOXb52Ax7Tlmj9I

  • Home
    • demo-image
    Home Java Programming Language Technology Inheritance in Java

    Inheritance in Java

    Share This

    In object-oriented programming, inheritance is a very important feature. Inheritance is a technique by which properties of one class is inherited in another class. A class which inherits the property is known as sub-class and the class from which the property is inherited is known as super-class. Let us discuss with a sample example.

    In this example, we have defined two classes, A and B. in class A, two variables x and y are declared. Here, class B inherits A. In class B variable z is declared. In class B we can access x and y because the variables are inherited from class A.

    A.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class A {
    int x;
    int y;
    public A(int x, int y) {
    this.x = x;
    this.y = y;
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    B.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class B extends A {
    int z;
    public B(int x, int y, int z) {
    super(x, y);
    this.z = z;
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    TestMain.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class TestMain {
    public static void main(String[] args) {
    A a = new A(10, 5);
    System.out.println(a.x + " " + a.y);
    B b = new B(10, 4, 7);
    System.out.println(b.x + " " + b.y + " " + b.z);
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    In the above class TestMain, object of B class is created and the instance variables, x, y and z are printed by the reference b. Though, x and y are declared in class A, the variables are being used in a similar way as instance variables are used.

     

    Look at the constructor of B class carefully. Within this constructor, super is written as the first line.

     

    When we initiate object creation of a class, first the constructor of the sub-class calls the constructor of the super class. If super class contains a parameterized constructor, the required parameters are to be passed in the super-class constructor. The super is used to call the super-class constructor. If the super-class does not have any constructor or it has a constructor with no parameters, then use of super is not mandatory.

    Accessing object of one class by reference of other class

    In Java, an object of one class can be accessed if there exists a sub-class and super-class relationship (inheritance).

     

    Object of sub-class can be accessed by super-class reference, but not vice-versa, as shown in the following example.

     

    Here, the object of class B is accessed using a reference of class A, but remember that all the methods and instance variables of class B can not be accessed by reference to class A. Only the variables and methods, which are declared and inherited in class A, are accessible by the reference of class A 

    A.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class A {
    int x = 10;
    void showA() {
    System.out.println(x);
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    B.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class B extends A {
    int y = 5;
    void showB() {
    System.out.println(x + " " + y);
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    TestMain.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class TestMain {
    public static void main(String[] args) {
    A a = new A();
    a.showA(); // own method
    B b = new B();
    b.showB(); // own method
    b.showA(); // inherited method
    A a1 = new B(); // object of sub-class can be accessed by super-class reference
    a1.showA();
    // a1.showB(); // not accessible
    // B b1 = new A(); // object of the super class can not be accessed by sub-class reference
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Case Study

    Let us explain with an example. We want to design a banking system. So, we have to manage different types of accounts of the customers, such as savings, salary, term deposits, loans, etc. If you define the classes, you will see that there are many common attributes in the classes. But those are added in every class. In this context, the solution is inheritance.

    If you create a class Account, in which all the common attributes are written, the attributes of the class can be inherited in other classes. Thus the Account class will be known as the super (parent) class and the classes which will inherit this class will be known as sub-classes.

    Here, the advantage is you don't need to write a common set of attributes as well as methods in all the sub-classes.

    Let us define the class as follow.

    Account.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    public class Account {
    private int _accountNo;
    private String _customerName;
    private String _customerAddress;
    private String _branchName;
    private String _branchAddress;
    private float _amount;
    private float _rateOfInterest;
    public int get_accountNo() {
    return _accountNo;
    }
    public void set_accountNo(int _accountNo) {
    this._accountNo = _accountNo;
    }
    public String get_customerName() {
    return _customerName;
    }
    public void set_customerName(String _customerName) {
    this._customerName = _customerName;
    }
    public String get_customerAddress() {
    return _customerAddress;
    }
    public void set_customerAddress(String _customerAddress) {
    this._customerAddress = _customerAddress;
    }
    public String get_branchName() {
    return _branchName;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Now we will design another class SavingsAccount, which will inherit the properties of Account class. There are some properties in SavingsAccount class which are not the properties of other classes like loan accounts. Thus those methods are defined in SavingsAccount class as shown below.

    SavingsAccount.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public class SavingsAccount extends Account {
    public void payAnnualInterest() {
    set_amount(get_amount() + get_amount() * get_rateOfInterest() / 100);
    }
    public void deposit(float amount) {
    set_amount(get_amount() + amount);
    }
    public void withdrawl(float amount) {
    set_amount(get_amount() - amount);
    }
    public float getAccountBalance() {
    return get_amount();
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    In this context, you will understand that every type of loan account should inherit the properties of the Account class. Now, try to think in detail. All the loan accounts have some common properties. Thus, here we want to define another class LoanAccount, which inherits the properties of the Account class. So, LoanAccount class is defined as below.

    LoanAccount.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class LoanAccount extends Account {
    public float getRemainingLoanAmount() {
    return get_amount();
    }
    public void rePayment(float amount) {
    set_amount(get_amount() - amount);
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Using the same concept, HomeLoanAccount and EducationLoanAccount classes are designed. Two different classes are defined because logic of interest calculation is different.

    LoanAccount.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class HomeLoanAccount extends LoanAccount {
    // update loan amount based on compound interest
    public void updateLoanAmountOnInterest(int noOfYear) {
    set_amount(get_amount() + get_amount() * (float) Math.pow(get_rateOfInterest() / 100, noOfYear));
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    EducationLoanAccount.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class EducationLoanAccount extends LoanAccount {
    // update loan amount based on simple interest
    public void updateLoanAmountOnInterest(int noOfYear) {
    set_amount(get_amount() + get_amount() * get_rateOfInterest() * noOfYear / 100);
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Happy Exploring!

    Tags
    Share This
    bunksAllowed

    About BunksAllowed

    Newer Article Method Overriding in Java Older Article Method Overloading in Java
    By on
    Labels: ,
    Subscribe to: Post Comments (Atom)
    Comment Using!!

    No comments:

    Post a Comment

    Note: Only a member of this blog may post a comment.

    About BunksAllowed