{"id":13640,"date":"2020-03-21T14:20:40","date_gmt":"2020-03-21T21:20:40","guid":{"rendered":"https:\/\/careerkarma.com\/blog\/?p=13640"},"modified":"2023-12-01T02:35:18","modified_gmt":"2023-12-01T10:35:18","slug":"java-inheritance","status":"publish","type":"post","link":"https:\/\/careerkarma.com\/blog\/java-inheritance\/","title":{"rendered":"Java Inheritance"},"content":{"rendered":"\n

Object-oriented programming includes a number of features that help prevent repetitive code. One of these features is inheritance.<\/p>\n\n\n\n

This tutorial will discuss, using examples, the basics of inheritance in Java. We will explore how inheritance works, why it is important, method overriding, and how to use the super<\/code> keyword.<\/p>\n\n\n\n

Java Inheritance<\/h2>\n\n\n\n

Inheritance is one of the most important features of object-oriented programming. Class inheritance refers to a process whereby you can define a new class based on an existing class.<\/p>\n\n\n\n

Through inheritance, subclasses<\/code> can inherit values from parent classes<\/code>, similar to the way children inherit physical traits from parents. We define these two types of classes and their alternative (and interchangeable) names in the table below.<\/p>\n\n\n\n

Class Type<\/strong><\/td>Alternative Name(s)<\/strong><\/td>Description [or Definition]<\/strong><\/td><\/tr>
parent class<\/td>base class, superclass<\/td>A parent class is a class from which child classes can be derived.<\/td><\/tr>
subclass<\/td>child class<\/td>A subclass is a class which inherits its values from a parent class.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

<\/p>\n\n\n\n

Inheritance is important because it allows you to reuse code. If you write code in a parent class, you usually don\u2019t need to write it again in associated child classes; doing so would be inefficient and would make a program more difficult to read.<\/p>\n\n\n\n

For example, suppose you are creating a program that stores bank account information for a bank. You may want to have one class that stores regular bank accounts and another class that stores bank accounts for customers who are under 18 years of age (minors<\/code>).<\/p>\n\n\n\n

The bank accounts for minors will have many similarities to regular bank accounts\u2014both types of accounts will store names and balances, for example. Therefore, you may decide to make accounts for minors a subclass of a parent bank account class to prevent you from having to repeat code.<\/p>\n\n\n\n

In Java, programmers use the extends<\/code> keyword to inherit characteristics from a class. Here\u2019s an example of the extends keyword in action:<\/p>\n\n\n\n

class BankAccount {\n\t\/\/ Code here\n}\nclass ChildAccount extends BankAccount {\n\t\/\/ Code here\n}<\/pre><\/div>\n\n\n\n
In this example, BankAccount is the parent class, and ChildAccount is the subclass. Subclasses inherit all the methods and fields of parent classes.<\/p>\n\n\n\n
Java Inheritance Example<\/h2>\n\n\n\n
You should use inheritance in Java if there is an is-a<\/code> relationship between two classes. Consider the following two examples:<\/p>\n\n\n\n
Example 1<\/strong>. In the above section, we talked about bank accounts for minors and regular bank accounts (the ones owned by people aged 18 or over, without restrictions). A bank account for a minor is a type of bank account, and so it can inherit values from the bank account class. <\/p>\n\n\n\n
Example 2<\/strong>. Another example would be an iPhone and a phone. The parent class would be called phone<\/code>, and the child class would be called iPhone<\/code>. An iPhone is a phone, and so it could inherit characteristics from the phone<\/code> parent class.<\/p>\n\n\n\n
Let\u2019s walk through an example to demonstrate how inheritance works in Java. We\u2019ll return to the bank account example from earlier.<\/p>\n\n\n\n
Suppose we want to create a program that stores banking information for bank customers. The bank for which we are creating this program allows customers to have one of two account types: a regular account (for someone aged 18 or over, which has no restrictions) or an account for a minor. Regular accounts are for customers over the age of 18. Accounts for minors are for customers under the age of 18. Accounts for minors have a few restrictions.<\/p>\n\n\n\n
Because an account for a minor has many similarities to a bank account\u2014an account for a minor is a bank account\u2014we can use inheritance. Here\u2019s an example of inheritance in use in the program we just described:<\/p>\n\n\n\n
class BankAccount {\n\tpublic void checkBalance() {\n\t\tSystem.out.println(\"Your balance is: $X\");\n\t}\n\tpublic void viewDetails() {\n\t\tSystem.out.println(\"Name: Helen Clarkson\");\n\t\tSystem.out.println(\"Address: 123 Main Street\");\n\t\tSystem.out.println(\"Overdraft Limit: $0\");\n\t}\n}\nclass ChildAccount extends BankAccount {\n\tpublic void setSavingsAmount() {\n\t\tSystem.out.println(\"Savings amount set to $Y.\");\n\t}\n}\nclass Main {\n\tpublic static void main(String[] args) {\n\t\tChildAccount helen = new ChildAccount();\n\t\thelen.checkBalance();\n\t\thelen.viewDetails();\n\t\thelen.setSavingsAmount();\n\t}\n}<\/pre><\/div>\n\n\n\n
Our code returns: <\/p>\n\n\n\n
Your balance is: $X\nName: Helen Clarkson\nAddress: 123 Main Street\nOverdraft Limit: $0\nSavings amount set to $Y.<\/pre><\/div>\n\n\n\n
In this example, we defined three classes. They are:<\/p>\n\n\n\n
    \n
  1. BankAccount<\/strong>. BankAccount is a parent class. This class has two methods: checkBalance()<\/code> and viewDetails()<\/code>.<\/li>\n\n\n\n
  2. ChildAccount<\/strong>. ChildAccount is a class of BankAccount for minors and inherits the methods checkBalance()<\/code> and viewDetails()<\/code> from the BankAccount class. In addition, ChildAccount has its own method: setSavingsAmount()<\/code>.<\/li>\n\n\n\n
  3. Main<\/strong>. We also declare a class called Main in which the code for our main program is stored. <\/li>\n<\/ol>\n\n\n\n
    In the main program, we create an instance of the ChildAccount class and call it helen. Helen is the name of our customer. Then, we invoke each method available to the child class.<\/p>\n\n\n\n
    As you can see in the code above, the helen variable can access both checkBalance()<\/code> and viewDetails()<\/code>, which are part of the BankAccount parent class, as well as the setSavingsAmount()<\/code> method, which is part of the ChildAccount child class.<\/p>\n\n\n\n
    Java Method Overriding<\/h2>\n\n\n\n
    In the above example, we talked about how a subclass inherits the values of its parent class. But what happens if the same method is defined in both a subclass and its parent class?<\/p>\n\n\n\n
    In this case, the subclass will override the method in the superclass. For instance, suppose we wanted the viewDetails()<\/code> method to be different for a ChildAccount. Regular BankAccounts can access overdrafts, and perhaps we don\u2019t want any ChildAccount to be able to see an overdraft limit since they are not eligible for this service.<\/p>\n\n\n\n
    We could use the following code to override the viewDetails()<\/code> method in the child class: <\/p>\n\n\n\n
    class BankAccount {\n\tpublic void checkBalance() {\n\t\tSystem.out.println(\"Your balance is: $X\");\n\t}\n\tpublic void viewDetails() {\n\t\tSystem.out.println(\"Name: Helen Clarkson\");\n\t\tSystem.out.println(\"Address: 123 Main Street\");\n\t\tSystem.out.println(\"Overdraft Limit: $0\");\n\t}\n}\nclass ChildAccount extends BankAccount {\n\tpublic void setSavingsAmount() {\n\t\tSystem.out.println(\"Savings amount set to $Y.\");\n\t}\n\t@Override\n\tpublic void viewDetails() {\n\t\tSystem.out.println(\"Name: Helen Clarkson\");\n\t\tSystem.out.println(\"Address: 123 Main Street\");\n\t}\n}\nclass Main {\n\tpublic static void main(String[] args) {\n\t\tChildAccount helen = new ChildAccount();\n\t\thelen.checkBalance();\n\t\thelen.viewDetails();\n\t\thelen.setSavingsAmount();\n\t}\n}<\/pre><\/div>\n\n\n\n
    When we run our code, our program returns the following response:<\/p>\n\n\n\n
    Your balance is: $X\nName: Helen Clarkson\nAddress: 123 Main Street\nSavings amount set to $Y.<\/pre><\/div>\n\n\n\n
    The response is the same as the one in our first example except for one difference: the console does not print the customer\u2019s overdraft limit.<\/p>\n\n\n\n
    In this example, viewDetails()<\/code> is declared in both the subclass ChildAccount and the superclass BankAccount.<\/p>\n\n\n\n
    When we declared viewDetails()<\/code> in the ChildAccount, we used the @Override statement, which tells the program to override the superclass\u2019 method. So, this means that when we reference the viewDetails()<\/code> method for Helen\u2019s account, the program references the viewDetails()<\/code> method in the ChildAccount class instead of the viewDetails()<\/code> method in the BankAccount class.<\/p>\n\n\n\n
    Java Super Keyword<\/h2>\n\n\n\n
    In Java, the super keyword is used to access an overwritten parent class method.<\/p>\n\n\n\n
    Let\u2019s return to the bank account example. Suppose we decide that, instead of hiding the overdraft limit statement from customers who are minors, we want to show it and print a message to the user, telling them: You are not eligible for an overdraft until you reach the age of 18.<\/code><\/p>\n\n\n\n
    If this is the case, we will still want to access the code in the viewDetails()<\/code> method of the BankAccount class, but we want to add an extra message that only appears in instances of the ChildAccount class. We could do so using this code: <\/p>\n\n\n\n
    class BankAccount {\n\t\/\/ Code here\n}\nclass ChildAccount extends BankAccount {\n\t\/\/ Code here\n\t@Override\n\tpublic void viewDetails() {\n\t\tsuper.viewDetails();\n\t\tSystem.out.println(\"You are not eligible for an overdraft until you reach the age of 18.\");\n\t}\n}\nclass Main {\n\tpublic static void main(String[] args) {\n\t\tChildAccount helen = new ChildAccount();\n\t\thelen.checkBalance();\n\t\thelen.viewDetails();\n\t\thelen.setSavingsAmount();\n\t}\n}<\/pre><\/div>\n\n\n\n
    Our code returns: <\/p>\n\n\n\n
    Your balance is: $X\nName: Helen Clarkson\nAddress: 123 Main Street\nOverdraft Limit: $0\nYou are not eligible for an overdraft until you reach the age of 18.\nSavings amount set to $Y.<\/pre><\/div>\n\n\n\n
    In this example, we used the super keyword to execute the viewDetails()<\/code> method from the BankAccount class, but from within the ChildAccount class.<\/p>\n\n\n\n
    So, when we execute helen.viewDetails()<\/code> to view Helen\u2019s account details, the ChildAccount viewDetails()<\/code> method executes. In the ChildAccount viewDetails()<\/code> method, we use the super keyword, which causes the BankAccount viewDetails()<\/code> method to be run. This returns the following:<\/p>\n\n\n\n
    Name: Helen Clarkson\nAddress: 123 Main Street\nOverdraft Limit: $0<\/pre><\/div>\n\n\n\n
    Then, after the BankAccount viewDetails()<\/code> method is executed, the program continues to execute the ChildAccount viewDetails()<\/code> method. This results in the console printing the following message:<\/p>\n\n\n\n
    You are not eligible for an overdraft until you reach the age of 18.<\/p>\n\n\n\n
    After the viewDetails()<\/code> method in the ChildAccount class executes, our program continues to run.<\/p>\n\n\n\n