在Java中使用 super 关键字调用基类构造函数

我们更喜欢继承来重用现有类中可用的代码。在Java中，继承是一个类继承另一个类的属性的概念。在下面的示例中，有两个类 Programming 和 DP，而 Programming 是父类，DP 是子类。在主类中，我们创建了 DP 的对象，即子类，因为它还允许我们从其父类访问方法，但是如果我们创建父类（编程）的对象，则我们无法从其访问方法或对象它的子类。

创建子类的对象后，我们首先调用子类的方法，然后调用父类的方法。这无关紧要，因为我们可以按任何顺序调用对象。

Java

// Java program to demonstrate inheritance properties
 
class Programming {
   
    // Creating method m1 for class Programming
    public void m1()
    {
      System.out.println("Programming");
    }
}
class DP extends Programming {
   
    // Creating method m2 for class DP
    public void m2()
    {
      System.out.println("DP");
    }
}
public class GFG {
   
    public static void main(String[] args)
    {
        // Creating Obj for Class DP and
        // Calling both m1 from class programming
        // And calling m2 from class DP respectively.
        DP obj = new DP();
        obj.m2();
        obj.m1();
    }
}

输出 ：

DP
Programming

构造函数继承

在下面的示例中，我们创建了一个父类和子类。在这里，我们已经创建了一个子类的对象，因为构造函数会在创建对象时调用自己，我们无需提及任何内容。

创建子类的对象后，构造函数应该打印自己类的输出，但是从输出中，我们可以确定父类被执行，然后子类被执行，这是因为我们为继承创建了一个构造函数默认情况下，每个类都包含一个 super()，因为我们正在调用一个继承类，它在第一行包含 super() 并调用 Parent 类。

Java

// Java program to illustrate
// the concept of Constructor
// inheritance.
 
// Base Class
class Programming {
   
    // Constructor for class Programming
    public Programming()
    {
        System.out.println("Programming");
    }
}
 
// Child Class inherit the Base
// Class
class DP extends Programming {
   
    // Constructor for class DP
    public DP() { System.out.println("DP"); }
}
 
// Main Class
public class GFG {
   
    public static void main(String[] args)
    {
        // Creating obj for
        // class DP
        DP obj = new DP();
    }
}

输出

Programming
DP

构造函数重载与 Super

在下面的示例中，我们使用了构造函数重载的概念，并且我们创建了一个子类的对象，在调用子类的构造函数后，其中的第一行是 super(10, 20)，表示从父类，如果我们不提及该行，默认情况下它会调用 super() ，而父类没有参数化构造函数。

Java

// Java program to demonstrate
// the concepts of constructor
// overloading.
 
// Base Class
class Programming {
   
    // Creating Constructor for
    // class Programming.
    public Programming()
    {
        System.out.println("Programming");
    }
 
    // Parameterized Constructor
    public Programming(int i, int j)
    {
        System.out.println("Programming + +");
    }
}
 
// Child Class
class DP extends Programming {
   
    public DP()
    {
        // Calling by using
        // Programming(int i,int j)
        // from class Programming.
        super(10, 20);
        System.out.println("DP");
    }
 
    // Parameterized Constructor
    // for class DP
    public DP(int i, int j)
    {
        System.out.println("DP + +");
    }
}
 
// Main Class
public class GFG {
    public static void main(String[] args)
    {
        // Creating Object for class DP.
        DP obj = new DP();
    }
}

输出：

Programming + +
DP

比喻

让我们看看下面的片段，

• 在下面的代码中，我们创建了一个子类的对象，我们从对象行本身传递了 10 的值，在转到特定的构造函数之后，它首先默认调用 super() 并从父类打印“Programming”班级。
• 需要注意的一点是，我们从对象创建行调用参数化构造函数，但默认情况下它将调用 super()，因为默认情况下可用。
• 在子类中，我们还可以给 super() 提供参数，以从父类调用特定的构造函数。

Java

// Base Class
class Programming {
   
    // Default Constructor
    public Programming()
    {
        System.out.println("Programming");
    }
 
    // parameterized Constructor
    public Programming(int i, int j)
    {
        System.out.println("Programming + +");
    }
}
class DP extends Programming {
   
    public DP() { System.out.println("DP"); }
 
    // parameterized Constructor with
    // one parameter
    public DP(int i) { System.out.println("DP +"); }
 
    // parameterized Constructor with
    // two parameter i and j.
    public DP(int i, int j)
    {
        System.out.println("DP + +");
    }
}
 
// Main Class
public class GFG {
   
    public static void main(String[] args)
    {
 
        // Creating obj for DP
        // class which inherits the
        // properties of class programming
        DP obj = new DP(10);
    }
}

输出 ：

Programming
DP +