我已经看到了所有的答案。但大家都忘了提一个非常重要的问题:

Super()应该在构造函数的第一行中调用或使用。

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

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(argument1)，它将调用接受一个argument1类型形参的构造函数(如果存在的话)。

它还可以用于从父类调用方法。即super.aMethod ()

更多信息和教程在这里

来源文章:Java:调用super()

是的。Super(…)将调用超类的构造函数。

说明:

独立的例子:

class Animal {
    public Animal(String arg) {
        System.out.println("Constructing an animal: " + arg);
    }
}

class Dog extends Animal {
    public Dog() {
        super("From Dog constructor");
        System.out.println("Constructing a dog.");
    }
}

public class Test {
    public static void main(String[] a) {
        new Dog();
    }
}

打印:

Constructing an animal: From Dog constructor
Constructing a dog.

一些事实:

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()函数。

还有其他一些用途。

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

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