如前所述，在默认构造函数内部，在构造函数的第一行调用隐式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

构造函数 在构造函数中，可以使用它而不带点来调用另一个构造函数。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. methodname ();

调用超类构造函数

如果构造函数没有显式调用超类构造函数，Java编译器会自动插入对超类的无参数构造函数的调用。如果超类没有无参数构造函数，则会得到编译时错误。

看看下面的代码:

class Creature {
    public Creature() {
        system.out.println("Creature non argument constructor.");
    }
}

class Animal extends Creature {
    public Animal (String name) {
        System.out.println("Animal one argument constructor");
    }
    public Animal (Stirng name,int age) {
        this(name);
        system.out.println("Animal two arguments constructor");
    }
}

class Wolf extends Animal {
    public Wolf() {
        super("tigerwang",33);
        system.out.println("Wolf non argument constructor");
    }
    public static void main(string[] args) {
        new Wolf();
    }
}

When creating an object,the JVM always first execute the constructor in the class of the top layer in the inheritance tree.And then all the way down the inheritance tree.The reason why this is possible to happen is that the Java compiler automatically inserts a call to the no-argument constructor of the superclass.If there's no non-argument constructor in the superclass and the subclass doesn't explicitly say which of the constructor is to be executed in the superclass,you'll get a compile-time error.

类的构造函数，在上面的代码中，如果我们想成功地创建Wolf对象 类必须执行。在这个过程中，Animal中的双参数构造函数 类被调用。同时，它显式地调用同一个参数中的单参数构造函数 类和单参数构造函数隐式调用生物中的非参数构造函数 类和非参数构造函数再次隐式调用Object中的空构造函数 类。

只是超级();Alone将调用默认构造函数，如果类的超类中存在默认构造函数。但是必须自己显式地编写默认构造函数。如果你不这样做，Java会为你生成一个没有实现的，保存super();，引用通用超类对象，并且不能在子类中调用它。

public class Alien{
   public Alien(){ //Default constructor is written out by user
   /** Implementation not shown…**/
   }
}

public class WeirdAlien extends Alien{
   public WeirdAlien(){
   super(); //calls the default constructor in Alien.
   }

}

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

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