Constructor在 java 中是允许您创建对象实例的代码块。它没有返回类型。 它有两个要点
-
构造函数名称应与类相同
-
构造函数不应该有任何返回类型，否则它将与方法相同。
ava中有三种构造函数。
-
默认构造函数
-
没有 arg 构造函数
-
参数化构造函数
## 如何调用构造函数？
要调用构造函数，您需要使用关键字 new，后跟类名，如果有参数，则后跟。 例如：如果要创建Employee类的对象，可以这样调用构造函数：new Employee()
## 承包商的类型
### 默认构造函数：
当您不为您的类提供构造函数时，JVM 将创建默认构造函数。它对您不可见，JVM 会在初始化类的对象时自动创建它。
让我们看看例子：
package org.arpit.java2blog;
public class Employee {
String name;
int age;
public void workOnAssignment()
{
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee();
e1.setName("John");
e1.setAge(20);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
正如您在此处看到的，我们没有为此类提供任何构造函数，但JVM在这种情况下会创建默认构造函数。 当你运行上面的程序时，你会得到下面的输出：
John 20
没有 arg 构造函数
no arg constructor是您在类中明确提供的构造函数，它没有任何参数。
package org.arpit.java2blog;
public class Employee {
String name;
int age;
public Employee()
{
System.out.println("Calling no arg constructor");
}
public void workOnAssignment()
{
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee();
e1.setName("John");
e1.setAge(20);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
当您调用上述程序时，您将得到以下输出：
Calling no arg constructor
John
20
参数化构造函数
当您将参数传递给构造函数时，会调用这种类型的构造函数Parameterized constructor。
package org.arpit.java2blog;
public class Employee {
String name;
int age;
public Employee(String name,int age)
{
System.out.println("Calling Parameterized constructor");
this.name=name;
this.age=age;
}
public void workOnAssignment()
{
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee("John",20);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
当你运行上面的程序时，你会得到下面的输出：
Calling Parameterized constructor
John
20
如果您提供参数化构造函数，那么您需要小心。 让我们看看下面的程序：
package org.arpit.java2blog;
public class Employee {
String name;
int age;
public Employee(String name,int age)
{
System.out.println("Calling Parameterized constructor");
this.name=name;
this.age=age;
}
public void workOnAssignment()
{
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee();
e1.setName("John");
e1.setAge(20);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
如果你注意到，你会在第 38 行得到编译错误。为什么这样？ 因为如果您在类中创建参数化构造函数，JVM 不会为您提供默认构造函数。如果您不编写任何构造函数，那么只有 JVM 会为您提供默认构造函数。
构造函数链
Constructor chaining是子类在内部或显式调用其父类的构造函数的概念。 每当您在 Java 中创建对象时，都会调用其超类构造函数。编译器只是在内部将 super() 放入构造函数中。 让我们在示例的帮助下查看： 假设您有 Person 具有属性名称的类，并且您有名为Employee扩展类的子Person类。
package org.arpit.java2blog;
public class Person
{
String name;
public Person()
{
System.out.println("Calling Person constructor");
name="John";
}
}
class Employee extends Person{
int age;
public Employee()
{
System.out.println("Calling Employee class constructor");
name="Martin";
}
public void workOnAssignment()
{
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee();
System.out.println(e1.getName());
}
}
当你运行上面的程序时，你会得到下面的输出：
Calling Person constructor
Calling Employee class constructor
Martin
正如您在此处看到的，First Person 构造函数被调用并将 name 变量设置为John Then Employee 构造函数被调用，该构造函数将 name 变量覆盖为Martin。 这就是为什么我们最后看到一个变量名为“Martin”。
如果要显式调用超类参数化构造函数怎么办
您可以使用super 关键字轻松完成。 让我们在示例的帮助下看看。
package org.arpit.java2blog;
public class Person
{
String name;
public Person(String name)
{
this.name=name;
System.out.println("Calling Person Parameterized constructor");
}
}
class Employee extends Person{
int age;
public Employee(String name)
{
super(name);
System.out.println("Calling Employee class constructor");
}
public void workOnAssignment()
{
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee("John");
System.out.println("Employee's name:"+e1.getName());
}
}
当你运行上面的程序时，你会得到下面的输出：
调用人员参数化构造函数 调用员工类构造函数 员工姓名：John
如果你想调用同一个类的另一个构造函数怎么办
如果你想调用overloaded constructor同一个类，你可以使用这个关键字来做到这一点。 例如：
package org.arpit.java2blog;
public class Employee {
String name;
int age;
public Employee() {
System.out.println("Calling No arg constructor");
}
public Employee(String name,int age)
{
this();
System.out.println("Calling Parameterized constructor");
this.name=name;
this.age=age;
}
public void workOnAssignment()
{
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[])
{
Employee e1=new Employee("John",20);
System.out.println("Employee's name : "+e1.getName());
System.out.println("Employee's age : "+e1.getAge());
}
}
当你运行上面的程序时，你会得到下面的输出：
Calling No arg constructor
Calling Parameterized constructor
Employee’s name : John
Employee’s age : 20
请注意，用于调用重载构造函数的 this 关键字应该是该构造函数中的第一个语句。
这就是Java中的构造函数。
|