Constructores de Java (con ejemplos)

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 () (// cuerpo del constructor))

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

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

Ejemplo 1: constructor de 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 llamado: el nombre es Programiz

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

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

 Main obj = new Main();

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

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

Tipos de constructor

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

  1. Constructor No-Arg
  2. Constructor parametrizado
  3. Constructor predeterminado

1. Constructores Java No-Arg

De manera similar a los métodos, un constructor de Java puede tener o no parámetros (argumentos).

Si un constructor no acepta ningún parámetro, se lo 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 :

 El constructor se llama Valor de 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.

Note que hemos declarado el constructor como privado.

Una vez que se declara un constructor private, no se puede acceder a él desde fuera de la clase. Entonces, está prohibido crear objetos desde fuera de la clase usando 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 públicos sin argumentos de Java

 class Company ( String name; // public constructor public Company() ( name = "Programiz"; ) ) public 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 :

 Nombre de la empresa = Programiz

Lectura recomendada: Modificador de acceso de Java

2. Constructor con parámetros Java

Un constructor de Java también puede aceptar uno o más parámetros. Estos 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 :

 Lenguaje de programación Java Lenguaje de programación Python Lenguaje de programación C

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

 Main obj1 = new Main("Java");

Here, we are passing the single value to the constructor. Based on the argument passed, the language variable is initialized inside the constructor.

3. Java Default Constructor

If we do not create any constructor, the Java compiler automatically create a no-arg constructor during the execution of the program. This constructor is called default constructor.

Example 5: Default Constructor

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

Output:

 a = 0 b = false

Here, we haven't created any constructors. Hence, the Java compiler automatically creates the default constructor.

The default constructor initializes any uninitialized instance variables with default values.

Type Default Value
boolean false
byte 0
short 0
int 0
long 0L
char u0000
float 0.0f
double 0.0d
object Reference null

In the above program, the variables a and b are initialized with default value 0 and false respectively.

The above program is equivalent to:

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

The output of the program is the same as Example 5.

Important Notes on Java Constructors

  • Constructors are invoked implicitly when you instantiate objects.
  • The two rules for creating a constructor are:
    The name of the constructor should be the same as the class.
    A Java constructor must not have a return type.
  • If a class doesn't have a constructor, the Java compiler automatically creates a default constructor during run-time. The default constructor initializes instance variables with default values. For example, the int variable will be initialized to 0
  • Constructor types:
    No-Arg Constructor - a constructor that does not accept any arguments
    Parameterized constructor - a constructor that accepts arguments
    Default Constructor - a constructor that is automatically created by the Java compiler if it is not explicitly defined.
  • A constructor cannot be abstract or static or final.
  • A constructor can be overloaded but can not be overridden.

Constructors Overloading in Java

Similar to Java method overloading, we can also create two or more constructors with different parameters. This is called constructors overloading.

Example 6: Java Constructor Overloading

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

Output:

 Programming Language: Java Programming Language: Python

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

Según el parámetro pasado durante la creación del objeto, se llaman 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 una thispalabra clave para especificar la variable de la clase. Para saber más sobre la thispalabra clave, visite Java esta palabra clave.

Articulos interesantes...