Java 理解超级的概念？

我很难理解

super（）

的概念。Java教程给出了以下示例：

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

，为什么我需要调用超类方法呢？为什么我不能在

printMethod（）

的子类方法中编写任何内容，然后继续前进？

您可以覆盖它。在这种情况下，将忽略父方法<如果希望在子类中执行父方法，则使用code>super（）。在这种情况下，将忽略父方法<如果希望在子类中执行父方法，则使用code>super（）。在这种情况下，将忽略父方法<如果希望在子类中执行父方法，则使用code>super（）。在这种情况下，将忽略父方法<如果希望在子类中执行父方法，则使用code>super（）。 如果需要，它只会帮助您调用超类方法中包含的逻辑。 很多时候，您希望运行确切的逻辑，然后提供附加逻辑

---

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

完全不需要调用super。 如果需要，它只会帮助您调用超类方法中包含的逻辑。 很多时候，您希望运行确切的逻辑，然后提供附加逻辑

---

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

完全不需要调用super。 如果需要，它只会帮助您调用超类方法中包含的逻辑。 很多时候，您希望运行确切的逻辑，然后提供附加逻辑

---

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

完全不需要调用super。 如果需要，它只会帮助您调用超类方法中包含的逻辑。 很多时候，您希望运行确切的逻辑，然后提供附加逻辑

---

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

这用于避免重复代码。假设你有一门课：

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（）

调用超类构造函数（构造函数通常用于初始化成员），这样您就可以专注于

子类

成员，而不必重复所有初始化行（对于

var1

、

var2

和

var3

）.

这用于避免重复代码。假设你有一门课：

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（）

调用超类构造函数（构造函数通常用于初始化成员），这样您就可以专注于

子类

成员，而不必重复所有初始化行（对于

var1

、

var2

和

var3

）.

这用于避免重复代码。假设你有一门课：

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（）

调用超类构造函数（构造函数通常用于初始化成员），这样您就可以专注于

子类

成员，而不必重复所有初始化行（对于

var1

、

var2

和

var3

）.

这用于避免重复代码。假设你有一门课：

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（）

调用超类构造函数（构造函数通常用于初始化成员），这样您就可以专注于

子类

成员，而不必重复所有初始化行（对于

var1

、

var2

和

var3

）.

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

基本上，超类是程序的最高层。创建新的子类时，必须使用关键字“extends”从超类“继承”。这有两件事；它允许您使用在超类、子类中创建的任何方法，还允许您覆盖超类中的方法。基本上，如果您有一个方法要在一组类中使用，那么您可以使用超类来创建它，然后子类可以使用标准的点表示法调用该方法。

基本上是supe

now you are calling a method on subclass object


                                 ^

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

             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;

              }

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();      
}

}