Java 使用构造函数分配和初始化超类成员

在Java中，super表示父类，我们使用extends关键字将一个类继承到另一个类。在创建一个Java程序来使用构造函数分配和初始化超类成员之前，让我们先了解一些在本文中使用的概念。

什么是构造函数

• 构造函数与方法非常相似，但区别在于方法定义了对象的行为，而构造函数用于初始化这些对象。

• 我们可以为方法提供任何我们选择的名称，但构造函数必须与类名相同。

• 此外，方法可以返回一个值，而构造函数不返回任何值，因为它们不能具有任何返回类型。

当用户不创建任何构造函数时，Java编译器将自动创建一个（我们称之为默认构造函数）。

语法

public class Constructor_example {
   Constructor_example() { 
      // constructor 
      // code to be executed
   }
}

示例

public class Cnst {
   Cnst(){ 
      // constructor 
      System.out.println("I am constructor");
   }
   public static void main(String[] args) {
      Cnst obj = new Cnst();  
      // calling the Constructor
   }
}

输出

I am constructor

这个和super关键字

• this关键字用于区分同一类方法中的局部变量和实例变量，而super关键字用于区分超类成员和子类成员。

• this关键字用于调用当前类的方法、构造函数和变量，而super关键字用于调用基类的方法和构造函数。

示例1

以下示例说明了this关键字的用法。

public class Main {
   String name = "Your name";
   Main(String name) { 
   // Constructor
      this.name = name; 
      // Represents the variable of constructor Main
      System.out.println(name);
   }
   public static void main(String[] args) {
      Main obj = new Main("Tutorialspoint");  
   }
}

输出

Tutorialspoint

在上面的代码中，我们创建了一个带有参数’name’（类型为字符串）的参数化构造函数’Main’。这就是为什么在调用构造函数时，我们使用了参数’Tutorialspoint’。

示例2

以下示例演示了’super’关键字的使用。

class Tutorialspoint {
    String name="Your name";
}
public class Tutorix extends Tutorialspoint {
    String name = "My name";
    public void show() {
       // To access name variable of class Tutorialspoint
        System.out.println("Accessing base class name: " + super.name);
       // To access local variable of class Tutorix
        System.out.println("Accessing child class name: " + name);
    }
     public static void main(String[] args) {
       Tutorix obj = new Tutorix(); 
       obj.show();
    }
}

输出

Accessing base class name: Your name
Accessing child class name: My name

在上述代码中，类’Tutorix’继承了类’Tutorialspoint’。在子类’Tutorix’的’show()’方法中，我们试图使用super关键字访问父类’Tutorialspoint’的’name’变量。在主方法中，我们使用new关键字创建了一个’Tutorix’类的对象。我们使用该对象调用了show()方法。

通过构造函数分配和初始化超类成员

示例

class P {  
   String item_name;
   int rate;
   int quantity;
   P(String item_name, int rate, int quantity) { // Constructor of parent class
      this.item_name = item_name;
      this.rate = rate;
      this.quantity = quantity;
      System.out.println("I am super class constructor");
      System.out.println("I contain " + item_name + " " + rate + " " + quantity);
   }
}
public class C extends P { 
// Inheriting the parent class using extends keyword
   C(String status) {  
      // Constructor of child class        
      super("Milk", 60, 2); 
      // allocating values to parent class members
      System.out.println("I am sub class constructor ");
      System.out.println(status);
   }
   public static void main(String[] args) {
      C obj = new C("paid"); // calling the Child class constructor
   }
}

输出

I am super class constructor
I contain Milk 60 2
I am sub class constructor 
paid

在以上代码中，我们创建了一个父类‘P’，它有三个变量和一个构造函数以及三个参数。类‘C’是‘P’的子类。在‘C’中，我们使用super关键字为父类‘P’分配值。

结论

在本文中，我们了解了构造函数与普通方法的区别，以及this和super关键字的用法。最后，我们创建了一个Java程序，使用构造函数分配和初始化超类成员。