Constructores Java

En este tutorial, aprenderemos sobre los constructores de Java, sus tipos y cómo usarlos con la ayuda de ejemplos.

¿Qué es un Constructor?

Un constructor en Java es similar a un método que se invoca cuando se crea un objeto de la clase.

A diferencia de los métodos de Java, un constructor tiene el mismo nombre que el de la clase y no tiene ningún tipo de retorno. Por ejemplo,

class Test {
  Test() {
    // constructor body
  }
}

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

Lectura recomendada: ¿Por qué los constructores no devuelven valores?

Ejemplo 1:Constructor Java

class Main {
  private String name;

  // constructor
  Main() {
    System.out.println("Constructor Called:");
    name = "Programiz";
  }

  public static void main(String[] args) {

    // constructor is invoked while
    // creating an object of the Main class
    Main obj = new Main();
    System.out.println("The name is " + obj.name);
  }
}

Salida :

Constructor Called:
The name is Programiz

En el ejemplo anterior, hemos creado un constructor llamado Main() . Dentro del constructor, estamos inicializando el valor del nombre variables.

Observe la declaración de crear un objeto de Main clase.

Main obj = new Main();

Aquí, cuando se crea el objeto, el Main() se llama constructor. Y, el valor del nombre la variable se inicializa.

Por lo tanto, el programa imprime el valor del nombre variables como Programiz .

Tipos de constructor

En Java, los constructores se pueden dividir en 3 tipos:

Constructor sin argumentos
Constructor parametrizado
Constructor predeterminado

1. Constructores Java sin argumentos

Al igual que los métodos, un constructor de Java puede o no tener parámetros (argumentos).

Si un constructor no acepta ningún parámetro, se le conoce como constructor sin argumentos. Por ejemplo,

private Constructor() {
   // body of the constructor
}

Ejemplo 2:constructor privado sin argumentos de Java

class Main {

  int i;

  // constructor with no parameter
  private Main() {
    i = 5;
    System.out.println("Constructor is called");
  }

  public static void main(String[] args) {

    // calling the constructor without any parameter
    Main obj = new Main();
    System.out.println("Value of i: " + obj.i);
  }
}

Salida :

Constructor is called
Value of i: 5

En el ejemplo anterior, hemos creado un constructor Main() . Aquí, el constructor no acepta ningún parámetro. Por lo tanto, se conoce como un constructor sin argumentos.

Observe que hemos declarado el constructor como privado.

Una vez que se declara un constructor private , no se puede acceder desde fuera de la clase. Por lo tanto, está prohibido crear objetos desde fuera de la clase utilizando el constructor privado.

Aquí, estamos creando el objeto dentro de la misma clase. Por lo tanto, el programa puede acceder al constructor. Para obtener más información, visite Java Implement Private Constructor.

Sin embargo, si queremos crear objetos fuera de la clase, debemos declarar el constructor como public .

Ejemplo 3:constructores sin argumentos públicos de Java

class Company {
  String name;

  // public constructor
  public Company() {
    name = "Programiz";
  }
}

class Main {
  public static void main(String[] args) {

    // object is created in another class
    Company obj = new Company();
    System.out.println("Company name = " + obj.name);
  }
}

Salida :

Company name = Programiz

Lectura recomendada: Modificador de acceso Java

2. Constructor parametrizado Java

Un constructor de Java también puede aceptar uno o más parámetros. Dichos constructores se conocen como constructores parametrizados (constructor con parámetros).

Ejemplo 4:Constructor parametrizado

class Main {

  String languages;

  // constructor accepting single value
  Main(String lang) {
    languages = lang;
    System.out.println(languages + " Programming Language");
  }

  public static void main(String[] args) {

    // call constructor by passing a single value
    Main obj1 = new Main("Java");
    Main obj2 = new Main("Python");
    Main obj3 = new Main("C");
  }
}

Salida :

Java Programming Language
Python Programming Language
C Programming Language

En el ejemplo anterior, hemos creado un constructor llamado Main() . Aquí, el constructor toma un solo parámetro. Observe la expresión,

Main obj1 = new Main("Java");

Aquí, estamos pasando el valor único al constructor. Según el argumento pasado, la variable de lenguaje se inicializa dentro del constructor.

3. Constructor predeterminado de Java

Si no creamos ningún constructor, el compilador de Java crea automáticamente un constructor sin argumentos durante la ejecución del programa. Este constructor se llama constructor por defecto.

Ejemplo 5:Constructor predeterminado

class Main {

  int a;
  boolean b;

  public static void main(String[] args) {

    // A default constructor is called
    Main obj = new Main();

    System.out.println("Default Value:");
    System.out.println("a = " + obj.a);
    System.out.println("b = " + obj.b);
  }
}

Salida :

a = 0
b = false

Aquí, no hemos creado ningún constructor. Por lo tanto, el compilador de Java crea automáticamente el constructor predeterminado.

El constructor predeterminado inicializa cualquier variable de instancia no inicializada con valores predeterminados.

Tipo	Valor predeterminado
`boolean`	falso
`byte`	0
`short`	0
`int`	0
`long`	0L
`char`	\u0000
`float`	0.0f
`double`	0.0d
`object`	Referencia nula

En el programa anterior, las variables a y b se inicializan con el valor predeterminado 0 y false respectivamente.

El programa anterior es equivalente a:

class Main {

  int a;
  boolean b;

  // a private constructor
  private Main() {
    a = 0;
    b = false;
  }

  public static void main(String[] args) {
    // call the constructor
    Main obj = new Main();

    System.out.println("Default Value:");
    System.out.println("a = " + obj.a);
    System.out.println("b = " + obj.b);
  }
}

El resultado del programa es el mismo que el del Ejemplo 5.

Notas importantes sobre los constructores de Java

Los constructores se invocan implícitamente cuando instancias objetos.
Las dos reglas para crear un constructor son:
El nombre del constructor debe ser el mismo que el de la clase.
Un constructor de Java no debe tener un tipo de retorno.
Si una clase no tiene un constructor, el compilador de Java crea automáticamente un constructor predeterminado durante el tiempo de ejecución. El constructor predeterminado inicializa las variables de instancia con valores predeterminados. Por ejemplo, el int la variable se inicializará a 0
Tipos de constructores:
Constructor sin argumentos - un constructor que no acepta ningún argumento
Constructor parametrizado - un constructor que acepta argumentos
Constructor predeterminado - un constructor que el compilador de Java crea automáticamente si no está definido explícitamente.
Un constructor no puede ser abstract o static o final .
Un constructor se puede sobrecargar pero no se puede anular.

Sobrecarga de constructores en Java

Similar a la sobrecarga de métodos de Java, también podemos crear dos o más constructores con diferentes parámetros. Esto se llama sobrecarga de constructores.

Ejemplo 6:Sobrecarga del constructor Java

class Main {

  String language;

  // constructor with no parameter
  Main() {
    this.language = "Java";
  }

  // constructor with a single parameter
  Main(String language) {
    this.language = language;
  }

  public void getName() {
    System.out.println("Programming Langauage: " + this.language);
  }

  public static void main(String[] args) {

    // call constructor with no parameter
    Main obj1 = new Main();

    // call constructor with a single parameter
    Main obj2 = new Main("Python");

    obj1.getName();
    obj2.getName();
  }
}

Salida :

Programming Language: Java
Programming Language: Python

En el ejemplo anterior, tenemos dos constructores:Main() y Main(String language) . Aquí, ambos constructores inicializan el valor de la variable language con diferentes valores.

Según el parámetro pasado durante la creación del objeto, se llaman a diferentes constructores y se asignan diferentes valores.

También es posible llamar a un constructor desde otro constructor. Para obtener más información, visite Java Call One Constructor from Another.

Nota :Hemos utilizado this palabra clave para especificar la variable de la clase. Para saber más sobre this palabra clave, visite Java esta palabra clave.

Métodos de Java Cadenas Java

Java