Constructores de Java

En este tutorial, aprenderá sobre los constructores de Java con la ayuda de ejemplos, cómo crear y usarlos y los diferentes tipos de constructores.

¿Qué es un constructor?

En Java, cada clase tiene su constructor, que se llama automáticamente cuando se crea un objeto de la clase. El constructor es similar a un método, pero en realidad no es un método.

UnJava 方法Se distinguen de los constructores de Java por su nombre y tipo de retorno. El constructor tiene el mismo nombre que el constructor de la clase y no devuelve ningún valor. Por ejemplo,

class Test {
　　　　Test() {
　　　　　　　　//Cuerpo del constructor
　　　　}
}

Aquí, Test() es un constructor. Tiene el mismo nombre que la clase y no tiene tipo de retorno.

class Test {
　　　　void Test() {
　　　　　　　　//　Cuerpo del método
　　　　}
}

　Aquí, Test() tiene el mismo nombre que la clase. Pero tiene un tipo de retorno void. Por lo tanto, es un método, no un constructor.

Ejemplo: Constructor de Java

class Main {
　　　private int x;
　　　//　Cuerpo del constructor
　　　private Main(){
　　　　　　　System.out.println("Se llama al constructor");
　　　　　　　x =　5;
　　　}
　　　public static void main(String[] args){
　　　　　　　//Llamar al constructor al crear el objeto
　　　　　　　Main obj = new Main();
　　　　　　　System.out.println("El valor de x = ")　+　obj.x);
　　　}
}

salida:

Se llama al constructor
El valor de x =　5

　En el ejemplo anterior, tenemos un constructor privado llamado Main(). En el método main, estamos creando un objeto de clase llamado obj.

Main obj = new Main();

　En este proceso, se llamará al constructor. Por lo tanto, se ejecutará la sentencia print y se inicializará la variable x.

Tipos de constructores

En Java, los constructores se pueden dividir en3Tipo:

• 无参数构造函数

• 默认构造函数

• Constructor con parámetros

无参数构造函数

Los constructores de Java pueden tener o no tener parámetros. Si el constructor no recibe parámetros, se llama constructor sin parámetros. Por ejemplo,

private Constructor() {
　　　//　Cuerpo del constructor
}

Ejemplo de constructor sin parámetros

class Main {
　　　int i;
　　　//Constructor sin parámetros
　　　private Main(){
　　　　　　　i =　5;
　　　　　　　System.out.println("Objeto creado y i = ")　+　i);
　　　}
　　　public　static　void　main(String[]　args)　{
　　　　　　　//Llamar al constructor sin parámetros
　　　　　　　Main obj = new Main();
　　　}
}

salida:

Objeto creado y i =　5

Aquí, la función Main() no recibe ningún parámetro.

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

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

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

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

salida:

Domain name = oldtoolbag.com

相关阅读： Java 访问修饰符

默认构造函数

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

示例：默认构造函数

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);
　　　　}
}

salida:

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);
　　　　}
}

salida:

a = 0
b = false

参数化构造函数

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

private Constructor (arg1, arg2, ..., argn) {
　　　　//　Cuerpo del constructor
}

Ejemplo: constructor parametrizado

class　Vehicle　{
　　　　int　wheels;
　　　　//Constructor que acepta un solo valor
　　　　private　Vehicle(int　wheels){
　　　　　　　　this.wheels　=　wheels;
　　　　　　　　System.out.println(wheels　+　"　Se creó el vehículo con ruedas.");
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Llamar al constructor pasando un solo valor
　　　　　　　　Vehicle　v1　=　new　Vehicle(2);
　　　　　　　　Vehicle　v2　=　new　Vehicle(3);
　　　　　　　　Vehicle　v3　=　new　Vehicle(4);
　　　　}
}

salida:

2　Se creó el vehículo con ruedas.
3　Se creó el vehículo con ruedas.
4　Se creó el vehículo con ruedas.

En el ejemplo anterior, tenemos un constructor llamado Vehicle(). El constructor acepta un parámetro llamado wheels.

Aquí, al crear un objeto, pasamos parámetros al constructor. Y, basado en los parámetros, está generando salida.

Sobrecarga de constructores en Java

　Al igual que en la sobrecarga de métodos, también podemos sobrecargar constructores en Java. Si no está familiarizado con la sobrecarga de métodos, visiteJava 方法重载。

En la sobrecarga del constructor, hay dos o más constructores con diferentes parámetros. Por ejemplo:

class　Company　{
　　　　String　domainName;
　　　　//Constructor sin parámetros
　　　　public　Company(){
　　　　　　　　this.domainName　=　"default";
　　　　}
　　　　//Constructor con un solo parámetro
　　　　public　Company(String　domainName){
　　　　　　　　this.domainName　=　domainName;
　　　　}
　　　　public　void　getName(){
　　　　　　　　System.out.println(this.domainName);
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Llamar al constructor sin parámetros
　　　　　　　　Company　defaultObj　=　new　Company();
　　　　　　　　//Llamar al constructor con un solo parámetro
　　　　　　　　Company　w3codeboxObj　=　new　Company("oldtoolbag.com");
　　　　　　　　defaultObj.getName();
　　　　　　　　w3codeboxObj.getName();
　　　　}
}

salida:

default
oldtoolbag.com

En el ejemplo anterior, tenemos dos constructores: public Company() y public Company(String domainName).

Aquí, dos constructores inicializan las variables domainName con diferentes valores.因此，根据我们需要的值，我们可以从 main() 方法调用构造函数。

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

重要笔记

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

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

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

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

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

• 构造函数类型：

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

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

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

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

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