Super是一个关键词。在子类方法定义中使用它来调用父类中定义的方法。父类的私有方法不能被调用。只有public和protected方法可以被super关键字调用。类构造函数也使用它来调用父类的构造函数。

点击这里查看进一步的解释。

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

The super keyword in Java is a reference variable that is used to refer to the immediate parent class object.

Java超级关键字的使用

Super可用于引用直接父类实例变量。 Super可用于调用直接父类方法。 Super()可用于调用直接父类构造函数。

super()是用来调用父构造函数吗?

是的。

请解释一下超级()。

Super()是Super关键字的一种特殊用法，用于调用无参数的父构造函数。通常，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()函数。