Contenido del Curso

Java Avanzado

1. Estructura Profunda de Java

¿Cómo Funciona el Compilador?Transferencia de Datos en Java Palabra Clave Final Importación de Bibliotecas Uso de Bibliotecas en Nuestro Código Operador Ternario Sentencia Switch Mejorada

2. Métodos

¿Qué es un método?Creación de Nuestros Propios Métodos Desafío: Nombres que Comienzan con la Letra B Void Práctica de Métodos Sobrecarga de Métodos Recursión Desafío: Encontrar el Máximo y el Mínimo en un Arreglo

3. String Avanzado

Más a Fondo en String Método Split()Desafío: Palabras Pares en Mayúsculas Método indexof()Desafío: Encontrar la Palabra Más Larga Método Trim()Desafío: Validación de Correo Electrónico

4. Clases

¿Qué Es una Clase?Clase Principal y Método Modificadores de Acceso Creación de Clases Desafío: Obtener Información Sobre el Objeto Constructor Desafío: Constructor de Equipo Método toString()Desafío: Visualización de Información del Loro

5. Clases Avanzadas

Uso de Clases Complejas Desafío: Relación Entre Mascota y Dueño Modificador Private Desafío: Visualización de Información de Animales Getter y Setter Desafío: Actualización de Información del Usuario Resumen

Constructor

¿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


              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, podemos referirnos al campo de la clase en la que escribimos el valor de esta palabra clave. Por ejemplo, cuando tenemos una clase con dos campos: name y age, podemos 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, podemos inicializar los campos de la clase a través del constructor usando la sintaxis: this.name = name;.

Ejemplo

Veamos un ejemplo de un constructor en una clase que nos ayudará a inicializar todos los campos para que quede más claro:

Person.java


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

Tenemos 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. Usemos este constructor en el método main para que puedas ver que los campos se inicializan con lo que pasamos como parámetros:

Main.java


              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 al pasar 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


              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 eso se llama constructor por defecto. Cada vez que creamos un objeto de cualquier clase, utilizamos un constructor. Para poder utilizar el constructor por defecto cuando ya tenemos un constructor que acepta parámetros, también debemos escribir un constructor vacío:

Main.java


              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 podemos ver en el último ejemplo, John no tiene nombre ni edad porque estos campos no están inicializados para el objeto. Así, podemos 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 parametrizado?

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 4. Capítulo 6

Pregunte a AI

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

Contenido del Curso

Java Avanzado

1. Estructura Profunda de Java

¿Cómo Funciona el Compilador?Transferencia de Datos en Java Palabra Clave Final Importación de Bibliotecas Uso de Bibliotecas en Nuestro Código Operador Ternario Sentencia Switch Mejorada

2. Métodos

3. String Avanzado

Más a Fondo en String Método Split()Desafío: Palabras Pares en Mayúsculas Método indexof()Desafío: Encontrar la Palabra Más Larga Método Trim()Desafío: Validación de Correo Electrónico

4. Clases

5. Clases Avanzadas

Constructor

¿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


              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"

Ejemplo

Veamos un ejemplo de un constructor en una clase que nos ayudará a inicializar todos los campos para que quede más claro:

Person.java


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

Main.java


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

Sobrecarga de constructores

Main.java


              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

Main.java


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

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 parametrizado?

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 4. Capítulo 6