Java Inheritance and the super Keyword | CodeSignal Learn

Java Inheritance and the super Keyword | CodeSignal Learn

Java Inheritance and the super Keyword

Welcome! In this part, we'll focus on inheritance in object-oriented programming (OOP) with Java . Inheritance allows us to share code across classes, thereby enhancing readability and efficiency. In this lesson, we'll clarify attribute and method inheritance in Java through practical examples. Our lesson's outline includes defining inheritance, exploring attribute inheritance, understanding method inheritance, and decoding the super keyword in Java. Ready? Let's get started!

Defining Inheritance

Inheritance in Java involves creating a subclass that inherits attributes and methods from a superclass. In Java, many scenarios allow classes to share common attributes or methods, making inheritance very useful. The extends keyword is used to set up inheritance, allowing one class to inherit properties and methods from another class. Here's an example featuring a superclass named Vehicle and a subclass named Car : Java // Define the superclass 'Vehicle' class Vehicle {// Initialize the Vehicle with color and brand attributes private String color; private String brand; public Vehicle(String color, String brand) {this.color = color; this.brand = brand;} public String getColor() {return color;} public String getBrand() {return brand;}} // Define the subclass 'Car', inheriting from 'Vehicle' class Car extends Vehicle {private int doors; public Car(String color, String brand, int doors) {super(color, brand); this.doors = doors;} public int getDoors() {return doors;}} public class Solution {public static void main(String[] args) {Car myCar = new Car("Red", "Toyota", 4); System.out.println("Color: " + myCar.getColor()); // Output: Color: Red System.out.println("Brand: " + myCar.getBrand()); // Output: Brand: Toyota System.out.println("Doors: " + myCar.getDoors()); // Output: Doors: 4}} In the Car class, the super() constructor within its constructor calls the Vehicle class's constructor, ensuring that inherited properties are initialized correctly. The extends keyword indicates that Car is a subclass of Vehicle . Our focus in this lesson is primarily on single inheritance, where one superclass is extended by a single subclass.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Attribute inheritance allows a subclass to inherit the attributes of its superclass, except for private fields, which are not directly accessible in subclasses. Consider this example featuring a superclass named Artist, and a subclass named Musician : class Artist {private String name; public Artist(String name) {this.name = name;} public String getName() {return name;}} class Musician extends Artist {private String instrument; public Musician(String name, String instrument) {super(name); this.instrument = instrument;} public String getInstrument() {return instrument;}} public class Solution {public static void main(String[] args) {Musician john = new Musician("John Lennon", "Guitar"); System.out.println(john.getName()); // Output: John Lennon System.out.println(john.getInstrument()); // Output: Guitar}} The Musician class inherits the name attribute from the Artist class and adds its own unique attribute, instrument . Access to the name attribute is provided via a getter method since it is private.

Method Inheritance

Similar to attributes, method inheritance allows a subclass to inherit the methods of its superclass. In the example below, the Car class can invoke the start method from the Vehicle class: class Vehicle {private String brand; public Vehicle(String brand) {this.brand = brand;} public void start() {System.out.println("The " + brand + " is starting.");} public String getBrand() {return brand;}} class Car extends Vehicle {public Car(String brand) {super(brand);}} public class Solution {public static void main(String[] args) {Car myCar = new Car("BMW"); myCar.start(); // Output: The BMW is starting.}} In the absence of a specific constructor in the Car class, Java provides a default constructor that internally calls super() to ensure the superclass's constructor is invoked. This initialization allows the Car class to inherit the brand attribute from the Vehicle class seamlessly.

Understanding the super Keyword in Method Overriding

The super keyword is essential in inheritance for calling superclass methods from a subclass, especially useful in method overriding. It enables a subclass to extend or utilize the functionality of a superclass without directly modifying it. Method overriding in Java allows a subclass to provide a specific implementation of a method already defined in its superclass. This is achieved by using the @Override annotation in the subclass. For instance, when overriding a method to add or alter its behavior, super can be used to call the original method from the superclass and integrate its functionality with new enhancements: class Vehicle {public String start() {return "Vehicle is starting...";}} class Car extends Vehicle {@Override public String start() {return super.start() + " Beep! Beep!";}} public class Solution {public static void main(String[] args) {Car myCar = new Car(); System.out.println(myCar.start()); // Output: Vehicle is starting... Beep! Beep!}} In this way, super allows subclasses to build upon or adapt the functionality of their superclasses efficiently and cleanly.

Java

class Artist {
    private String name;

    public Artist(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

class Musician extends Artist {
    private String instrument;

    public Musician(String name, String instrument) {
        super(name);
        this.instrument = instrument;
    }

    public String getInstrument() {
        return instrument;
    }
}

public class Solution {
    public static void main(String[] args) {
        Musician john = new Musician("John Lennon", "Guitar");
        System.out.println(john.getName()); // Output: John Lennon
        System.out.println(john.getInstrument()); // Output: Guitar
    }
}

Java

class Vehicle {
    private String brand;

    public Vehicle(String brand) {
        this.brand = brand;
    }

    public void start() {
        System.out.println("The " + brand + " is starting.");
    }

    public String getBrand() {
        return brand;
    }
}

class Car extends Vehicle {
    public Car(String brand) {
        super(brand);
    }
}

public class Solution {
    public static void main(String[] args) {
        Car myCar = new Car("BMW");
        myCar.start(); // Output: The BMW is starting.
    }
}

Java

class Vehicle {
    public String start() {
        return "Vehicle is starting...";
    }
}

class Car extends Vehicle {
    @Override
    public String start() {
        return super.start() + " Beep! Beep!";
    }
}

public class Solution {
    public static void main(String[] args) {
        Car myCar = new Car();
        System.out.println(myCar.start()); // Output: Vehicle is starting... Beep! Beep!
    }
}