Question

我无法绕过super()的概念。 Java Tutorials给出了这个例子：

public class Superclass {
    public void printMethod() {
        System.out.println("Printed in Superclass.");
    }
}

public class Subclass extends Superclass {
    // overrides printMethod in Superclass
    public void printMethod() {
        super.printMethod();
        System.out.println("Printed in Subclass");
    }
    public static void main(String[] args) {
        Subclass s = new Subclass();
        s.printMethod();    
    }
}

但如果我重写printMethod，为什么我需要调用Superclass方法？为什么我不能只在printMethod()的子类方法中编写任何内容并继续前进？

Answer 1

绝对没有必要打电话给超级。如果需要，它只是帮助您调用超类方法中包含的逻辑。很多时候，您需要运行确切的逻辑，然后提供额外的逻辑。

覆盖始终并不意味着提供全新的逻辑。有时您想提供轻微的变化。例如，如果方法返回一个值，则调用超类方法并获取值。然后使用子类方法中的逻辑对该对象进行一些修改，并将其返回给调用者。

Answer 2

您可以覆盖它。在这种情况下，将忽略父方法。如果您希望在子类中执行父方法，则使用super()。

Answer 3

这用于避免重复的代码。假设你有一个班级：

public class SuperClass() {
    private int var1;
    private int var2;
    private int var3;

    public SuperClass() {
        var1 = 1;
        var2 = 2;
        var3 = 3;   
    }
}

和一个子类：

public class SubClass() {
    private int var1;
    private int var2;
    private int var3;
    private int var4;

    public SubClass() {
        super();
        var4 = 4;
    }
}

在此示例中，您使用super()来调用超类构造函数（构造函数通常用于初始化成员），因此您可以专注于SubClass成员，而不必重复所有初始化行（适用于var1，var2和var3）。

Answer 4

基本上，超级课程是该课程的最高级别。创建新子类时，必须使用关键字“extends”从超类“继承”。这样做有两件事;它允许您使用在超类中创建的任何方法，在子类中它还允许您覆盖超类中的方法。基本上，如果你想在一堆类中使用一个方法，你可以使用超类创建它，然后子类可以使用标准点表示法调用该方法。

Answer 5

如果您只运行此程序，子类的Inside PrintMethod将调用超类“printMethod”（打印“以超类打印”），然后执行您在子类方法中编写的内容（print“Printed in Subclass “）。

      public void printMethod() {
      //super.printMethod();   // comment this line
      System.out.println("Printed in Subclass");
     }

如果你这样运行，它将只打印你在子类方法中写的东西。

想法是，如果你想在子类中使用超类方法信息，那么你可以调用Super.MethodName（）。

Answer 6

明确说明：

public static void main(String[] args) {
    Subclass s = new Subclass();
    s.printMethod();    
 }

Subclass s = new Subclass（）;

（i）当我们创建子类对象时会发生什么？    将执行subclss的构造函数   （ii）我们在子类（Subclass）中是否有任何结构函数      如果我们有dat将执行..      但是我们没有这样的默认costructor会超越   （iii）默认的构造函数将具有什么？

Subclass（）{        超（）;       }   （iv）super（）会做什么？      它调用超类构造函数
超级类中的
我们也没有构造函数   将执行默认构造函数

超类（）{   超级（）;
```
 }
```
超类的超类是Object类

所以Object类是java中的evry类的超类

所以它会创建对象类的对象..
```
    object of Object class created
                 |
```
来到它的子类构造函数... //步骤（iv）

超类（）{ 超（）; //执行
```
 }

   object of Object class created
                 |
    object of Superclass  craeted
```
所以超类constuctror执行也完成了它将创建超级类的对象..

然后控制来到它的子类结构//步骤（iii）

所以Subclass（）{ 超（）; //执行 }

在完成子类构造函数后，它创建子类
的对象
```
 *Important point : after completion of constructor execution 
         Object of thet class will be created*

     object of Object class created
                 |
    object of Superclass  craeted
                 |
      object of Subclass  craeted
```
所有这一切都是因为Subclass s = new Subclass（）;
1. 所以当你创建子类的对象时，会创建对象..
2. s.printMethod（）;
```
now you are calling a method on subclass object


                                 ^
```
3. printMethod（）存在于超类和子类
  中
  当你在子类对象上调用一个方法时会发生什么？
  
  （i）它将在最外层的objest：Object类的Object中搜索该方法所以现在printMethod（）不在对象类的对象中（ii）接下来在下一个超类对象中进行搜索，即。超类的对象 object具有printMethod（）方法的超类对象
  
  （iii）so方法发现... eventhougth方法在下一个子对象中找到controll serches，大多数对象是子类对象的对象....
  
  （iv）在两个物体中发现了两个方法，但它超过了大多数对象方法。
  
  所以sub子对象是Subclass对象......
  
  所以它执行子类printMethod（）方法。

注意：当我们在object上调用一个方法时，如果是ovverriden，它将执行sub most objects方法.....

现在我们的方法是......

public void printMethod() {
    super.printMethod();
    System.out.println("Printed in Subclass");
}

此方法的第一行是super.printMethod（）;

默认超级字体到超类对象：超类的对象

超类.printMethod（）的对象是

public void printMethod（）{ System.out.println（“以超类打印。”）; }

所以打印：

以超类打印。

下一行是：System.out.println（“在子类中打印”）;

所以打印：在子类中打印

注意：首先在创建对象时称为超类构造函数..

现在在称为超类方法的方法中..

注意：

1.如果没有任何构造函数的类，jvm将默认构造函数指定为

类名（）{ 超（）;调用超类构造函数 }

如果class alrdy有构造函数

构造函数的第一行应该是super（）调用。

例如：A类{ int variablea;

             A(int a){

            variablea=a;

              }

  public static void main(String[] args) {
       A a=new A(2);   
            }

           }


    in this example 
     A(int a){

            variablea=a;

              }   code replaces with


           A(int a){
           super(); by jvm by default

            variablea=a;

              }

Answer 7

您可以在子类中使用super来引用其直接超类。超级有两种一般形式。

从子类
从子类

我假设您正在尝试理解第二个。

一个例子，它可以让你理解super如何帮助引用超类的成员：

public class Human {
String name;
int age;
public void printDetails() {
  System.out.println("Name:"+name);
  System.out.println("Age:"+age);
}
}

public class Student extends Human {
int rollNumber;
String grade;
public void printDetails() {
    super.printDetails();
    System.out.println("Roll Number:"+rollNumber);
    System.out.println("Grade:"+grade);
}   

public void printNameAgeAndSayGoodMorning(){
    super.printDetails();
    System.out.println("Good morning!");
}
public static void main(String[] args) {
    Student s = new Student();
    s.name="MyName";
    s.age=27;
    s.rollNumber=3;
    s.grade="A+";
    s.printDetails(); 
    System.out.println(); //just an empty line
    s.printNameAgeAndSayGoodMorning();      
}

}

为简单起见，我避免使用构造函数或任何getter / setter方法。

在这个例子中，你认为你真的必须＆＃34;只要在子类中写下任何东西＆＃34;而不是重用超类中可用的printDetails()方法？

理解超级的概念？

7 个答案: