Inheritance in Java, Half 1: The extends key phrase

Java helps class reuse by means of inheritance and composition. This two-part tutorial teaches you easy methods to use inheritance in your Java applications.

What you may be taught on this Java tutorial

The primary half of this introduction to Java inheritance teaches you easy methods to use the extends key phrase to derive a toddler class from a dad or mum class, invoke dad or mum class constructors and strategies, and override strategies:

• What’s inheritance in Java?
• Single inheritance and a number of inheritance
• Learn how to use the extends key phrase in Java
• Understanding Java class hierarchy
• When to make use of methodology overriding vs. methodology overloading

What’s inheritance in Java?

Inheritance is a programming assemble that software program builders use to determine is-a relationships between classes. Inheritance permits us to derive extra particular classes from extra generic ones. The extra particular class is a form of the extra generic class. For instance, a checking account is a form of account during which you may make deposits and withdrawals. Equally, a truck is a form of car used for hauling giant objects.

Inheritance can descend by means of a number of ranges, resulting in ever-more-specific classes. For instance, Determine 1 reveals automobile and truck inheriting from car; station wagon inheriting from automobile; and rubbish truck inheriting from truck. Arrows level from extra particular “baby” classes (decrease down) to much less particular “dad or mum” classes (larger up).

Jeff Friesen

Single inheritance and a number of inheritance

The instance in Determine 1 illustrates single inheritance during which a toddler class inherits state and behaviors from one speedy dad or mum class. In distinction, a number of inheritance permits a toddler class to inherit state and behaviors from two or extra speedy dad or mum classes. The hierarchy in Determine 2 illustrates a number of inheritance.

Jeff Friesen

Classes are described by lessons. Java helps single inheritance by means of class extension, during which one class instantly inherits accessible fields and strategies from one other class by extending that class. Java does not assist a number of inheritance by means of class extension, nevertheless.

When viewing an inheritance hierarchy, you may simply detect a number of inheritance by the presence of a diamond sample. Determine 2 reveals this sample within the context of auto, land car, water car, and hovercraft.

Learn how to use the extends key phrase in Java

Java helps class extension by way of the extends key phrase. When current, extends specifies a parent-child relationship between two lessons. Under I take advantage of extends to determine a relationship between lessons Automobile and Automotive, after which between Account and SavingsAccount:

Itemizing 1. The ‘extends’ key phrase specifies a parent-child relationship

class Automobile
{
   // member declarations
}
class Automotive extends Automobile
{
   // inherit accessible members from Automobile
   // present personal member declarations
}
class Account
{
   // member declarations
}
class SavingsAccount extends Account
{
   // inherit accessible members from Account
   // present personal member declarations
}

The extends key phrase is specified after the category title and earlier than one other class title. The category title earlier than extends identifies the kid and the category title after extends identifies the dad or mum. It is unimaginable to specify a number of class names after extends as a result of Java does not assist class-based a number of inheritance.

These examples codify is-a relationships: Automotive is a specialised Automobile and SavingsAccount is a specialised Account. Automobile and Account are often known as base lessons, dad or mum lessons, or superclasses. Automotive and SavingsAccount are often known as derived lessons, baby lessons, or subclasses.

Baby lessons inherit accessible fields and strategies from their dad or mum lessons and different ancestors. They by no means inherit constructors, nevertheless. As an alternative, baby lessons declare their very own constructors. Moreover, they’ll declare their very own fields and strategies to distinguish them from their dad and mom. Take into account Itemizing 2.

Itemizing 2. An Account dad or mum class

class Account
{
   personal String title;

   personal lengthy quantity;

   Account(String title, lengthy quantity)
   {
      this.title = title;
      setAmount(quantity);
   }

   void deposit(lengthy quantity)
   {
      this.quantity += quantity;
   }

   String getName()
   {
      return title;
   }

   lengthy getAmount()
   {
      return quantity;
   }

   void setAmount(lengthy quantity)
   {
      this.quantity = quantity;
   }
}

Itemizing 2 describes a generic checking account class that has a reputation and an preliminary quantity, that are each set within the constructor. Additionally, it lets customers make deposits. (You may make withdrawals by depositing unfavourable quantities of cash however we’ll ignore this risk.) Notice that the account title have to be set when an account is created.

Itemizing 3 presents a SavingsAccount baby class that extends its Account dad or mum class.

Itemizing 3. A SavingsAccount baby class extends its Account dad or mum class

class SavingsAccount extends Account
{
   SavingsAccount(lengthy quantity)
   {
      tremendous("financial savings", quantity);
   }
}

The SavingsAccount class is trivial as a result of it does not must declare further fields or strategies. It does, nevertheless, declare a constructor that initializes the fields in its Account superclass. Initialization occurs when Account‘s constructor is known as by way of Java’s tremendous key phrase, adopted by a parenthesized argument checklist.

Itemizing 4 additional extends Account with a CheckingAccount class.

Itemizing 4. A CheckingAccount baby class extends its Account dad or mum class

class CheckingAccount extends Account
{
   CheckingAccount(lengthy quantity)
   {
      tremendous("checking", quantity);
   }

   void withdraw(lengthy quantity)
   {
      setAmount(getAmount() - quantity);
   }
}

CheckingAccount is a bit more substantial than SavingsAccount as a result of it declares a withdraw() methodology. Discover this methodology’s calls to setAmount() and getAmount(), which CheckingAccount inherits from Account. You can not instantly entry the quantity subject in Account as a result of this subject is asserted personal (see Itemizing 2).

Understanding Java class hierarchy

I’ve created an AccountDemo utility class that permits you to check out the Account class hierarchy. First, check out AccountDemo‘s supply code.

Itemizing 5. AccountDemo demonstrates the account class hierarchy

class AccountDemo
{
   public static void major(String[] args)
   {
      SavingsAccount sa = new SavingsAccount(10000);
      System.out.println("account title: " + sa.getName());
      System.out.println("preliminary quantity: " + sa.getAmount());
      sa.deposit(5000);
      System.out.println("new quantity after deposit: " + sa.getAmount());

      CheckingAccount ca = new CheckingAccount(20000);
      System.out.println("account title: " + ca.getName());
      System.out.println("preliminary quantity: " + ca.getAmount());
      ca.deposit(6000);
      System.out.println("new quantity after deposit: " + ca.getAmount());
      ca.withdraw(3000);
      System.out.println("new quantity after withdrawal: " + ca.getAmount());
   }
}

The major() methodology in Itemizing 5 first demonstrates SavingsAccount, then CheckingAccount. Assuming Account.java, SavingsAccount.java, CheckingAccount.java, and AccountDemo.java supply information are in the identical listing, execute both of the next instructions to compile all of those supply information:

javac AccountDemo.java
javac *.java

Execute the next command to run the appliance:

java AccountDemo

You need to observe the next output:

account title: financial savings
preliminary quantity: 10000
new quantity after deposit: 15000
account title: checking
preliminary quantity: 20000
new quantity after deposit: 26000
new quantity after withdrawal: 23000

Methodology overriding vs. methodology overloading

A subclass can override (change) an inherited methodology in order that the subclass’s model of the strategy is known as as an alternative. An overriding methodology should specify the identical title, parameter checklist, and return sort as the strategy being overridden. To show, I’ve declared a print() methodology within the Automobile class, proven in Itemizing 6.