super keyword in Java

The super keyword in Java is a reference variable used to refer to a direct parent class object. Whenever you create an instance of a subclass, the instance of the parent class is created implicitly and referenced by the super reference variable.

Usage of Java super keyword

1. super is used to refer to instance variables of direct parent class.

We can use the super keyword to access the data member or field of the parent class. If the parent and child class have the same field, use it.

class Animal {
    String color = "white";
}

class Dog extends Animal {
    String color = "black";

    void printColor() {
        System.out.println(color); // 打印 Dog 类的颜色
        System.out.println(super.color); // 打印 Animal 类的颜色
    }
}

class TestSuper1 {
    public static void main(String args[]) {
        Dog d = new Dog();
        d.printColor();
    }
}

Output:

black white

In the example above, both Animal and Dog classes have public attribute color. If we print the color property, it will print the color of the current class by default. To access the parent property, we need to use the super keyword.

2. super can be used to call parent class methods.

super keyword can also be used to call parent class methods. If a child class contains the same method as the parent class, it should be used. In other words, if the method is rewritten, it is used.

class Animal {
    void eat() {
        System.out.println("eating...");
    }
}

class Dog extends Animal {
    void eat() {
        System.out.println("eating bread...");
    }

    void bark() {
        System.out.println("barking...");
    }

    void work() {
        super.eat();
        bark();
    }
}

class TestSuper2 {
    public static void main(String args[]) {
        Dog d = new Dog();
        d.work();
    }
}

Output:

eating... barking...

In the example above, both Animal and Dog classes have the eat() method. If we call the eat() method from the Dog class, it will call the eat() method of the Dog class by default because the priority is given to the local method. To call the parent class method, we need to use the super keyword.

3. super is used to call the parent class constructor.

super keyword can also be used to call the parent class constructor. Let's look at a simple example:

class Animal {
    Animal() {
        System.out.println("animal is created");
    }
}

class Dog extends Animal {
    Dog() {
        super();
        System.out.println("dog is created");
    }
}

class TestSuper3 {
    public static void main(String args[]) {
        Dog d = new Dog();
    }
}

Output:

animal is created dog is created

Note: If there is no super() or this() in the constructor, the compiler will automatically add super() to each class constructor ]. (To be added)

It is well known that if a constructor does not exist, the compiler will automatically provide the default constructor. However, it also adds super() as the first statement. (To be added)

Another example of the super keyword, where super() is implicitly provided by the compiler. (To be added)

class Animal {
    Animal() {
        System.out.println("animal is created");
    }
}

class Dog extends Animal {
    Dog() {
        System.out.println("dog is created");
    }
}

class TestSuper4 {
    public static void main(String args[]) {
        Dog d = new Dog();
    }
}

Output:

animal is created dog is created

super Example: Practical application(to be supplemented)

Let's see the practical application of the super keyword. Here, the Emp class inherits the Person class, so all properties of Person will be inherited to Emp by default. To initialize all properties, we are using the parent class constructor from the subclass. In this way, we are reusing the parent class constructor.

class Person {
    int id;
    String name;

    Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

class Emp extends Person {
    float salary;

    Emp(int id, String name, float salary) {
        super(id, name); // 重用父类构造函数
        this.salary = salary;
    }

    void display() {
        System.out.println(id   " "   name   " "   salary);
    }
}

class TestSuper5 {
    public static void main(String[] args) {
        Emp e1 = new Emp(1, "ankit", 45000f);
        e1.display();
    }
}

Output:

1 ankit 45000

Reference: https://www.javatpoint.com/super-keyword

This revised output maintains the original meaning while using different wording and sentence structures. The "TBD" sections are left as they were in the orig inal, as they represent areas that require further explanation or completion, not necessarily paraphrase.