java - Java中的super()

Question

是super()用来调用父构造函数的吗？请解释super()。

score 282 · Accepted Answer

super()调用不带参数的父构造函数。

它也可以与参数一起使用。即super(argument1)，它将调用接受 1 个类型参数的构造函数argument1（如果存在）。

它也可以用来调用父级的方法。IEsuper.aMethod()

更多信息和教程在这里

score 160 · Accepted Answer

一些事实：

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

好的，现在让我们实际实现super().

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

程序 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 并尝试找出主要区别。

节目二

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 中，我们在打印其输出时使用super()了变量a，而不是打印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()派生类的函数内部，我们调用Show()了父类的函数函数名前的super关键字。

score 40 · Accepted Answer

来源文章：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.

score 30 · Accepted Answer

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

是的。

请解释一下 Super()。

super()super是调用无参数父构造函数的关键字的特殊用途。通常，super关键字可用于调用重写方法、访问隐藏字段或调用超类的构造函数。

这是官方教程

score 7 · Accepted Answer

调用无参数超级构造函数只是浪费屏幕空间和程序员时间。无论您是否编写，编译器都会生成完全相同的代码。

class Explicit() {
    Explicit() {
        super();
    }
}

class Implicit {
    Implicit() {
    }
}

score 6 · Accepted Answer

是的，super()（小写）调用父类的构造函数。您可以包含参数：super(foo, bar)

还有一个super关键字，您可以在方法中使用它来调用超类的方法

“Java super”的快速谷歌搜索结果如下

score 4 · Accepted Answer

那是对的。Super 用于调用父构造函数。所以假设你有一个这样的代码块

class A{
    int n;
    public A(int x){
        n = x;
    }
}

class B extends A{
    int m;
    public B(int x, int y){
        super(x);
        m = y;
    }
}

然后你可以给成员变量n赋值。

score 2 · Accepted Answer

我已经看到了所有的答案。但是大家都忘了提一个很重要的点：

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

score 1 · Accepted Answer

只是超级（）；单独将调用默认构造函数，如果它存在于类的超类中。但是您必须自己显式编写默认构造函数。如果你没有，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.
   }

}

score 1 · Accepted Answer

例如，在 selenium 自动化中，您有一个 PageObject 可以使用其父级的构造函数，如下所示：

public class DeveloperSteps extends ScenarioSteps {

public DeveloperSteps(Pages pages) {
    super(pages);
}........

score 1 · Accepted Answer

我想与我所理解的代码分享。

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

score 1 · Accepted Answer

我们可以用 SUPER 做什么？

访问超类成员

如果你的方法覆盖了它的一些超类的方法，你可以通过使用关键字superlike来调用被覆盖的方法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();
    }
}

JVM在创建对象时，总是先执行继承树最上层的类中的构造函数，然后一直向下执行继承树。之所以会出现这种情况，是因为Java编译器会自动插入一个调用超类的无参构造函数。如果超类中没有无参构造函数，并且子类没有明确说明要在超类中执行哪个构造函数，则会出现编译时错误.

在上面的代码中，如果我们想成功创建一个 Wolf 对象，则必须执行该类的构造函数。在此过程中，调用了 Animal 类中的二参数构造函数。同时，它显式调用了一个-argu-constructor 和 one-argu-constructor 隐式调用 Creature 类中的 non-argu-constructor 并且 non-argu-constructor 再次隐式调用 Object 类中的空构造函数。

score 0 · Accepted Answer

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

当您使用正确的参数调用super()时，我们实际上调用了构造函数Box，它初始化变量width、height和depth，并通过使用相应参数的值来引用它。你只剩下初始化它的增值权重了。如有必要，您现在可以将类变量 Box 设置为private。放入 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;
    }

}

score 0 · Accepted Answer

构造函数
在构造函数中，您可以使用不带点的方式调用另一个构造函数。super调用超类中的构造函数；this在此类中调用构造函数：

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如果超类需要初始化自己，这很有用。this允许您在一个构造函数中只编写一次所有硬初始化代码并从所有其他更容易编写的构造函数中调用它，这很有用。

方法
在任何方法中，您都可以将它与点一起使用来调用另一个方法。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允许您改为请求超类的方法。this仅作为使您的代码更具可读性的一种方式有用。

score 0 · Accepted Answer

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

score 0 · Accepted Answer

super是一个关键字。它在子类方法定义中用于调用超类中定义的方法。不能调用超类的私有方法。super 关键字只能调用公共和受保护的方法。类构造函数也使用它来调用其父类的构造函数。

在这里查看进一步的解释。

score 0 · Accepted Answer

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()可用于调用直接父类构造函数。

java - Java中的super()

17 回答 17

我们可以用 SUPER 做什么？

访问超类成员

调用超类构造函数

看下面的代码：

Related

Reference