Java 菜鸟教程

Java 流程控制

Java 数组

Java 面向对象(I)

Java 面向对象(II)

Java 面向对象(III)

Java 异常处理

Java 列表(List)

Java Queue(队列)

Java Map集合

Java Set集合

Java 输入输出(I/O)

Java Reader/Writer

Java 其他主题

Java 构造函数

在本教程中,您将在示例的帮助下了解Java构造函数,如何创建和使用它们以及不同类型的构造函数。

什么是构造函数?

在Java中,每个类都有它的构造函数,当类的对象被创建时,该构造函数将被自动调用。构造函数类似于方法,但实际上它不是方法。

一个Java方法和Java构造函数以通过其名称和返回类型进行区分。构造函数与类的构造函数同名,并且不返回任何值。例如,

class Test {
    Test() {
        //构造函数体
    }
}

在这里,Test()是一个构造函数。它具有与该类相同的名称,并且没有返回类型。

class Test {
    void Test() {
        // 方法主体
    }
}

 这里,Test()与类的名称相同。但是,它有一个返回类型void。因此,它是一个方法,而不是一个构造函数。

示例:Java构造函数

class Main {
   private int x;

   // 构造函数体
   private Main(){
       System.out.println("构造函数被调用");
       x = 5;
   }
   public static void main(String[] args){
       //创建对象时调用构造函数
       Main obj = new Main();
       System.out.println("x 的值 = " + obj.x);
   }
}

输出

构造函数被调用
x 的值 = 5

 在上面的示例中,我们有一个名为Main()的私有构造函数。在main方法中,我们正在创建一个名为obj的类对象。

Main obj = new Main();

 在此过程中,将调用构造函数。因此,执行print语句并初始化变量x。

构造函数的类型

在Java中,构造函数可以分为3种类型:

  • 无参数构造函数

  • 默认构造函数

  • 参数构造函数

无参数构造函数

Java构造函数可以具有或可以不具有任何参数。如果构造函数不接受任何参数,则称为无参数构造函数。例如,

private Constructor() {
   // 构造函数体
}

无参数构造函数的示例

class Main {

   int i;
   //没有参数的构造函数
   private Main(){
       i = 5;
       System.out.println("Object created and i = " + i);
   }

   public static void main(String[] args) {
       //不带任何参数调用构造函数
       Main obj = new Main();
   }
}

输出

Object created and i = 5

在这里,构造Main()函数不接受任何参数。

您是否注意到Main()构造函数的访问修饰符是私有(private)的?

这是因为该对象是从同一类中实例化的。因此,它可以访问构造函数。

但是,如果对象是在类外部创建的,则必须声明构造函数为public才能访问它。例如:

class Company {
    String domainName;

    // 公共构造函数
    public Company(){
        domainName = "(cainiaojc.com)";
    }
}

public class Main {
    
    public static void main(String[] args) {
        // 在另一个类中创建对象
        Company companyObj = new Company();
        System.out.println("Domain name = "+ companyObj.domainName);
    }
}

输出

Domain name = (cainiaojc.com)

相关阅读: Java访问修饰符

默认构造函数

如果不创建任何构造函数,则Java编译器将在运行时自动创建无参数的构造函数。此构造函数称为默认构造函数。默认构造函数使用默认值初始化所有未初始化的实例变量。

类型默认值
booleanfalse
byte0
short0
int0
long0L
char\u0000
float0.0f
double0.0d
objectnull

示例:默认构造函数

class DefaultConstructor {

    int a;
    boolean b;

    public static void main(String[] args) {

        //调用默认构造函数
        DefaultConstructor obj = new DefaultConstructor();
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

输出

a = 0
b = false

在上面的程序中,我们还没有初始化变量a和b的值。但是,当我们创建类的对象时,我们可以在输出中看到这些值已使用某些值进行了初始化。

 这是因为Java编译器自动创建了一个默认构造函数。构造函数将使用默认值0和false初始化变量a和b的值。

上面的程序等同于:

class DefaultConstructor {

    int a;
    boolean b;

    //私有构造函数 
    private DefaultConstructor() {
        a = 0;
        b = false;
    }

    public static void main(String[] args) {
        //调用构造函数
        DefaultConstructor obj = new DefaultConstructor();
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

输出

a = 0
b = false

参数化构造函数

与方法类似,我们可以将参数传递给构造函数。此类构造函数称为参数化构造函数。例如,

private Constructor (arg1, arg2, ..., argn) {
    // 构造函数体
}

示例:参数化构造函数

class Vehicle {

    int wheels;

    //接受单个值的构造函数
    private Vehicle(int wheels){
        this.wheels = wheels;
        System.out.println(wheels + " wheeler vehicle created.");
    }

    public static void main(String[] args) {
        //通过传递单个值来调用构造函数
        Vehicle v1 = new Vehicle(2);
        Vehicle v2 = new Vehicle(3);
        Vehicle v3 = new Vehicle(4);
    }
}

输出

2 wheeler vehicle created.
3 wheeler vehicle created.
4 wheeler vehicle created.

在上面的示例中,我们有一个名为Vehicle()的构造函数。构造函数接受一个名为wheels的参数。

在这里,当创建对象时,我们将参数传递给构造函数。并且,基于参数,它正在生成输出。

Java中的构造函数重载

 与方法重载类似,我们也可以在Java中重载构造函数。如果您不熟悉方法重载,请访问Java方法重载

在构造函数重载中,有两个或多个具有不同参数的构造函数。例如,

class Company {

    String domainName;

    //没有参数的构造函数
    public Company(){
        this.domainName = "default";
    }

    //具有单个参数的构造函数
    public Company(String domainName){
        this.domainName = domainName;
    }

    public void getName(){
        System.out.println(this.domainName);
    }

    public static void main(String[] args) {
        //不带参数调用构造函数
        Company defaultObj = new Company();

        //使用单个参数调用构造函数
        Company nhoooObj = new Company("(cainiaojc.com)");
        defaultObj.getName();
        nhoooObj.getName();
    }
}

输出

default
(cainiaojc.com)

在上面的示例中,我们有两个构造函数:public Company()和public Company(String domainName)。

在这里,两个构造函数都用不同的值初始化变量domainName。因此,根据我们需要的值,我们可以从main()方法调用构造函数。

注意,我们使用this关键字来指定类的变量。要了解有关this关键字的更多信息,请访问Java this关键字

重要笔记

  •  构造函数在实例化对象时被隐式调用。

  • 创建构造函数的两个规则是:

    • 构造函数的名称应与类的名称相同。

    • Java构造函数不得具有返回类型。

  • 如果类没有构造函数,则Java编译器会在运行时自动创建默认构造函数。默认构造函数使用默认值初始化实例变量。例如,int变量将被初始化为0

  • 构造函数类型:

    • 无参数构造函数  - 不接受任何参数的构造函数

    • 默认构造函数  - 如果没有显式定义,Java编译器会自动创建一个构造函数。

    • 参数化构造函数  - 接受参数的构造函数

  • 构造函数不能是抽象的abstract 、static或final。

  • 构造函数可以重载,但不能被重写。