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

this和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

在上面的代码中，我们创建了一个参数化构造函数“Main”，以及一个字符串类型的参数“name”。因此，在调用构造函数时，我们使用了参数“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程序，该程序使用构造函数分配和初始化超类成员。