如前所述，在默认构造函数内部，在构造函数的第一行调用隐式super()。

这个super()自动调用从类层次结构顶部开始的构造函数链，并向下移动层次结构。

如果程序的类层次结构中有两个以上的类，顶层类的默认构造函数将首先被调用。

下面是一个例子:

class A {
    A() {
    System.out.println("Constructor A");
    }
}

class B extends A{

    public B() {
    System.out.println("Constructor B");
    }
}

class C extends B{ 

    public C() {
    System.out.println("Constructor C");
    }

    public static void main(String[] args) {
    C c1 = new C();
    }
} 

以上将输出:

Constructor A
Constructor B
Constructor C

我愿意与代码分享我所了解的一切。

java中的super关键字是一个引用变量，用于引用父类对象。它主要用于以下情况:-

1. super与变量的使用:

class Vehicle 
{ 
    int maxSpeed = 120; 
} 

/* sub class Car extending vehicle */
class Car extends Vehicle 
{ 
    int maxSpeed = 180; 

    void display() 
    { 
        /* print maxSpeed of base class (vehicle) */
        System.out.println("Maximum Speed: " + super.maxSpeed); 
    } 
} 

/* Driver program to test */
class Test 
{ 
    public static void main(String[] args) 
    { 
        Car small = new Car(); 
        small.display(); 
    } 
} 

输出:

Maximum Speed: 120

super with的使用方法:

/* Base class Person */
class Person 
{ 
    void message() 
    { 
        System.out.println("This is person class"); 
    } 
} 

/* Subclass Student */
class Student extends Person 
{ 
    void message() 
    { 
        System.out.println("This is student class"); 
    } 

    // Note that display() is only in Student class 
    void display() 
    { 
        // will invoke or call current class message() method 
        message(); 

        // will invoke or call parent class message() method 
        super.message(); 
    } 
} 

/* Driver program to test */
class Test 
{ 
    public static void main(String args[]) 
    { 
        Student s = new Student(); 

        // calling display() of Student 
        s.display(); 
    } 
}

输出:

This is student class
This is person class

3.super与构造函数的使用:

class Person 
{ 
    Person() 
    { 
        System.out.println("Person class Constructor"); 
    } 
} 

/* subclass Student extending the Person class */
class Student extends Person 
{ 
    Student() 
    { 
        // invoke or call parent class constructor 
        super(); 

        System.out.println("Student class Constructor"); 
    } 
} 

/* Driver program to test*/
class Test 
{ 
    public static void main(String[] args) 
    { 
        Student s = new Student(); 
    } 
} 

输出:

Person class Constructor
Student class Constructor

super关键字可用于调用超类构造函数和引用超类的成员

当您使用正确的参数调用super()时，实际上调用了构造函数Box，它通过使用相应参数的值来初始化变量width、height和depth。你只剩下初始化它的增值权重。如果有必要，现在可以将类变量Box设为私有。放在Box类私有修饰符的字段中，并确保您可以毫无问题地访问它们。

在超类中可以有多个重载版本的构造函数，因此可以使用不同的参数调用方法super()。程序将执行与指定参数匹配的构造函数。

public class Box {

    int width;
    int height;
    int depth;

    Box(int w, int h, int d) {
        width = w;
        height = h;
        depth = d;
    }

    public static void main(String[] args){
        HeavyBox heavy = new HeavyBox(12, 32, 23, 13);
    }

}

class HeavyBox extends Box {

    int weight;

    HeavyBox(int w, int h, int d, int m) {

        //call the superclass constructor
        super(w, h, d);
        weight = m;
    }

}

还有其他一些用途。

引用继承接口的默认方法:

import java.util.Collection;
import java.util.stream.Stream;

public interface SkipFirstCollection<E> extends Collection<E> {

    @Override
    default Stream<E> stream() {
        return Collection.super.stream().skip(1);
    }
}

还有一种很少使用的情况，在实例化静态子类时，使用限定的超类为超类构造函数提供一个外部实例:

public class OuterInstance {

    public static class ClassA {

        final String name;

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

        public class ClassB {
            public String getAName() {
                return ClassA.this.name;
            }
        }
    }

    public static class ClassC extends ClassA.ClassB {
        public ClassC(ClassA a) {
            a.super();
        }
    }

    public static void main(String[] args) {
        final ClassA a = new ClassA("jeff");
        final ClassC c = new ClassC(a);
        System.out.println(c.getAName());
    }
}

然后:

$ javac OuterInstance.java && java OuterInstance
jeff

构造函数 在构造函数中，可以使用它而不带点来调用另一个构造函数。Super调用父类中的构造函数;调用该类中的构造函数:

public MyClass(int a) {
  this(a, 5);  // Here, I call another one of this class's constructors.
}

public MyClass(int a, int b) {
  super(a, b);  // Then, I call one of the superclass's constructors.
}

Super在父类需要初始化自身时很有用。这允许您只在一个构造函数中编写一次所有硬初始化代码，并从所有其他更容易编写的构造函数调用它，这很有用。

方法 在任何方法中，都可以使用它和一个点来调用另一个方法。Super.method()调用超类中的方法;this.method()调用该类中的一个方法:

public String toString() {
  int    hp   = this.hitpoints();  // Calls the hitpoints method in this class
                                   //   for this object.
  String name = super.name();      // Calls the name method in the superclass
                                   //   for this object.

  return "[" + name + ": " + hp + " HP]";
}

super在某些情况下是有用的:如果你的类和你的超类有相同的方法，Java会假设你想在你的类中使用这个方法;Super允许你请求父类的方法。这只在提高代码可读性时有用。

一些事实:

Super()用于调用直接父节点。 Super()可以用于实例成员，即实例变量和实例方法。 可以在构造函数中使用Super()来调用父类的构造函数。

好，现在让我们实际实现super()的这些点。

检查程序1和程序2之间的区别。这里，程序2证明了Java中super()的第一个语句。

程序1

class Base
{
    int a = 100;
}

class Sup1 extends Base
{
    int a = 200;
    void Show()
    {
        System.out.println(a);
        System.out.println(a);
    }
    public static void main(String[] args)
    {
        new Sup1().Show();
    }
}

输出:

200 200

现在检查程序2，试着找出主要的区别。

项目2

class Base
{
    int a = 100;
}

class Sup2 extends Base
{
    int a = 200;
    void Show()
    {
        System.out.println(super.a);
        System.out.println(a);
    }
    public static void main(String[] args)
    {
        new Sup2().Show();
    }
}

输出:

100 200

在程序1中，输出只是派生类。它既不能打印基类的变量，也不能打印父类的变量。但是在程序2中，我们在输出变量a时使用了super()，它打印的不是派生类变量a的值，而是基类变量a的值。因此，它证明了super()是用来调用直接父节点的。

好，现在看看程序3和程序4的区别。

项目3

class Base
{
    int a = 100;
    void Show()
    {
        System.out.println(a);
    }
}

class Sup3 extends Base
{
    int a = 200;
    void Show()
    {
        System.out.println(a);
    }
    public static void Main(String[] args)
    {
        new Sup3().Show();
    }
}

输出:

200

这里输出是200。当我们调用Show()时，派生类的Show()函数被调用。但是，如果我们想调用父类的Show()函数，应该怎么做呢?请查看程序4以获得解决方案。

项目4

class Base
{
    int a = 100;
    void Show()
    {
        System.out.println(a);
    }
}

class Sup4 extends Base
{
    int a = 200;
    void Show()
    {
        super.Show();
        System.out.println(a);
    }
    public static void Main(String[] args)
    {
        new Sup4().Show();
    }
}

输出:

100 200

这里我们有两个输出，100和200。当调用派生类的Show()函数时，它首先调用父类的Show()函数，因为在派生类的Show()函数内部，我们通过将super关键字放在函数名之前调用父类的Show()函数。