Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Aprende Constructor | Clases
Java Extendido

bookConstructor

Cómo simplificar la inicialización de clases

Inicializar cada campo cada vez puede ser tedioso. Para estos fines, las clases tienen constructores. La sintaxis para un constructor es la siguiente:

Main.java

Main.java

copy

              
1234

            
modifier ClassName(ParameterType parameter1, ParameterType parameter2) {
    this.parameter1 = parameter1;
    this.parameter2 = parameter2;
}

Analicemos cada palabra escrita aquí:

  • modifier: Se refiere al modificador de acceso, que suele ser public para los constructores. Los casos en los que un constructor puede tener un modificador de acceso diferente se tratarán en un curso aparte;
  • ClassName: Es simplemente el nombre de la clase en la que se está creando este constructor;
  • ParameterType: Es el tipo de parámetro que se utilizará en el constructor. Es importante prestar atención aquí porque este parámetro debe ser del mismo tipo que el campo en la clase; Por ejemplo: Si la clase tiene dos parámetros, String name y int age, entonces el constructor debe tener los mismos parámetros (si queremos inicializar todos los campos a través del constructor). Si queremos inicializar solo un campo específico de la clase a través del constructor, por ejemplo, name, entonces debemos usar solo un parámetro con el mismo tipo y nombre que el campo en la clase;
  • Luego, dentro del cuerpo del constructor, asignamos valores a los campos de la clase utilizando los valores pasados en el parámetro.

Palabra clave "this"

Con la ayuda de la palabra clave this, es posible hacer referencia al campo de la clase en la que se escribe el valor de esta palabra clave. Por ejemplo, cuando se tiene una clase con dos campos: name y age, se puede escribir this.name dentro del constructor o método, y se referirá específicamente al campo de la clase, no a la variable local que se pasa como parámetro a ese constructor o método. De esta manera, es posible inicializar los campos de la clase a través del constructor utilizando la sintaxis: this.name = name;.

Ejemplo

A continuación, se muestra un ejemplo de un constructor en una clase que ayuda a inicializar todos los campos para mayor claridad:

Person.java

Person.java

copy

              
1234567891011

            
class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

Se tiene una clase llamada Person con tres campos. Cada uno de estos campos ha sido añadido al constructor utilizando la palabra clave this. Por lo tanto, el constructor inicializa los campos con los valores de los parámetros. Utilicemos este constructor en el método main para que se observe que los campos se inicializan con lo que se pasa como parámetros:

Main.java

Main.java

copy

              
123456789101112131415161718192021

            
package com.example;

class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
    }
}

Inicializamos el objeto Person llamado bob utilizando el constructor, pasando name, age y gender como parámetros. Luego, imprimimos sus parámetros en pantalla y observamos que el objeto tiene los valores de campo especificados en los parámetros del constructor.

Sobrecarga de Constructores

El constructor también puede ser sobrecargado y no cubrir la inicialización de todos los campos de la clase. Por ejemplo, si no queremos especificar el género de Alice, podemos sobrecargar el constructor para aceptar solo 2 parámetros e inicializar los campos con ellos:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425262728

            
package com.example;

class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
        Person alice = new Person("Alice", 17);
        System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age);
    }
}

Se puede concluir que un constructor, al igual que un método, puede sobrecargarse y aceptar diferentes cantidades y tipos de parámetros.

Constructor por defecto

Un constructor por defecto es un constructor que no recibe parámetros y no inicializa ningún campo. Existe en todas las clases por defecto si no tienen ningún otro tipo de constructor, por lo que se le llama constructor por defecto. Cada vez que creamos un objeto de cualquier clase, utilizamos un constructor. Para poder usar el constructor por defecto cuando ya existe un constructor que acepta parámetros, también es necesario escribir un constructor vacío:

Main.java

Main.java

copy

              
123456789101112131415161718192021222324252627282930313233

            
package com.example;

class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
        Person alice = new Person("Alice", 17);
        System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age);
        Person john = new Person();
        System.out.println("John's name: " + john.name + ", John's age: " + john.age);
    }
}

Utilizamos 3 constructores diferentes para inicializar cada uno de los objetos Person. Como se puede observar en el último ejemplo, John no tiene nombre ni edad porque estos campos no están inicializados para el objeto. Por lo tanto, es posible sobrecargar el constructor tantas veces como sea necesario y crear objetos a través de él.

1. ¿Cuál de las siguientes afirmaciones sobre los constructores es verdadera?

2. ¿Cuál es el propósito de un constructor en Java?

3. ¿Cuál de los siguientes fragmentos de código demuestra la forma correcta de crear un constructor con parámetros?

question mark

¿Cuál de las siguientes afirmaciones sobre los constructores es verdadera?

Select the correct answer

question mark

¿Cuál es el propósito de un constructor en Java?

Select the correct answer

question mark

¿Cuál de los siguientes fragmentos de código demuestra la forma correcta de crear un constructor con parámetros?

Select the correct answer

¿Todo estuvo claro?

¿Cómo podemos mejorarlo?

¡Gracias por tus comentarios!

Sección 4. Capítulo 6

Pregunte a AI

expand

Pregunte a AI

ChatGPT

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

Awesome!

Completion rate improved to 2.63

bookConstructor

Desliza para mostrar el menú

Cómo simplificar la inicialización de clases

Inicializar cada campo cada vez puede ser tedioso. Para estos fines, las clases tienen constructores. La sintaxis para un constructor es la siguiente:

Main.java

Main.java

copy

              
1234

            
modifier ClassName(ParameterType parameter1, ParameterType parameter2) {
    this.parameter1 = parameter1;
    this.parameter2 = parameter2;
}

Analicemos cada palabra escrita aquí:

  • modifier: Se refiere al modificador de acceso, que suele ser public para los constructores. Los casos en los que un constructor puede tener un modificador de acceso diferente se tratarán en un curso aparte;
  • ClassName: Es simplemente el nombre de la clase en la que se está creando este constructor;
  • ParameterType: Es el tipo de parámetro que se utilizará en el constructor. Es importante prestar atención aquí porque este parámetro debe ser del mismo tipo que el campo en la clase; Por ejemplo: Si la clase tiene dos parámetros, String name y int age, entonces el constructor debe tener los mismos parámetros (si queremos inicializar todos los campos a través del constructor). Si queremos inicializar solo un campo específico de la clase a través del constructor, por ejemplo, name, entonces debemos usar solo un parámetro con el mismo tipo y nombre que el campo en la clase;
  • Luego, dentro del cuerpo del constructor, asignamos valores a los campos de la clase utilizando los valores pasados en el parámetro.

Palabra clave "this"

Con la ayuda de la palabra clave this, es posible hacer referencia al campo de la clase en la que se escribe el valor de esta palabra clave. Por ejemplo, cuando se tiene una clase con dos campos: name y age, se puede escribir this.name dentro del constructor o método, y se referirá específicamente al campo de la clase, no a la variable local que se pasa como parámetro a ese constructor o método. De esta manera, es posible inicializar los campos de la clase a través del constructor utilizando la sintaxis: this.name = name;.

Ejemplo

A continuación, se muestra un ejemplo de un constructor en una clase que ayuda a inicializar todos los campos para mayor claridad:

Person.java

Person.java

copy

              
1234567891011

            
class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

Se tiene una clase llamada Person con tres campos. Cada uno de estos campos ha sido añadido al constructor utilizando la palabra clave this. Por lo tanto, el constructor inicializa los campos con los valores de los parámetros. Utilicemos este constructor en el método main para que se observe que los campos se inicializan con lo que se pasa como parámetros:

Main.java

Main.java

copy

              
123456789101112131415161718192021

            
package com.example;

class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
    }
}

Inicializamos el objeto Person llamado bob utilizando el constructor, pasando name, age y gender como parámetros. Luego, imprimimos sus parámetros en pantalla y observamos que el objeto tiene los valores de campo especificados en los parámetros del constructor.

Sobrecarga de Constructores

El constructor también puede ser sobrecargado y no cubrir la inicialización de todos los campos de la clase. Por ejemplo, si no queremos especificar el género de Alice, podemos sobrecargar el constructor para aceptar solo 2 parámetros e inicializar los campos con ellos:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425262728

            
package com.example;

class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
        Person alice = new Person("Alice", 17);
        System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age);
    }
}

Se puede concluir que un constructor, al igual que un método, puede sobrecargarse y aceptar diferentes cantidades y tipos de parámetros.

Constructor por defecto

Un constructor por defecto es un constructor que no recibe parámetros y no inicializa ningún campo. Existe en todas las clases por defecto si no tienen ningún otro tipo de constructor, por lo que se le llama constructor por defecto. Cada vez que creamos un objeto de cualquier clase, utilizamos un constructor. Para poder usar el constructor por defecto cuando ya existe un constructor que acepta parámetros, también es necesario escribir un constructor vacío:

Main.java

Main.java

copy

              
123456789101112131415161718192021222324252627282930313233

            
package com.example;

class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
        Person alice = new Person("Alice", 17);
        System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age);
        Person john = new Person();
        System.out.println("John's name: " + john.name + ", John's age: " + john.age);
    }
}

Utilizamos 3 constructores diferentes para inicializar cada uno de los objetos Person. Como se puede observar en el último ejemplo, John no tiene nombre ni edad porque estos campos no están inicializados para el objeto. Por lo tanto, es posible sobrecargar el constructor tantas veces como sea necesario y crear objetos a través de él.

1. ¿Cuál de las siguientes afirmaciones sobre los constructores es verdadera?

2. ¿Cuál es el propósito de un constructor en Java?

3. ¿Cuál de los siguientes fragmentos de código demuestra la forma correcta de crear un constructor con parámetros?

question mark

¿Cuál de las siguientes afirmaciones sobre los constructores es verdadera?

Select the correct answer

question mark

¿Cuál es el propósito de un constructor en Java?

Select the correct answer

question mark

¿Cuál de los siguientes fragmentos de código demuestra la forma correcta de crear un constructor con parámetros?

Select the correct answer

¿Todo estuvo claro?

¿Cómo podemos mejorarlo?

¡Gracias por tus comentarios!

Sección 4. Capítulo 6
some-alt