Java Language
Constructores

Introducción

Observaciones

Constructor predeterminado

El "predeterminado" para los constructores es que no tienen ningún argumento. En caso de que no especifique ningún constructor, el compilador generará un constructor predeterminado por usted.
Esto significa que los siguientes dos fragmentos son semánticamente equivalentes:

public class TestClass {
    private String test;
}

public class TestClass {
    private String test;
    public TestClass() {

    }
}

La visibilidad del constructor predeterminado es la misma que la visibilidad de la clase. Por lo tanto, una clase definida de paquete privado tiene un constructor predeterminado privado de paquete

Sin embargo, si tiene un constructor no predeterminado, el compilador no generará un constructor predeterminado para usted. Así que estos no son equivalentes:

public class TestClass {
    private String test;
    public TestClass(String arg) {
    }
}

public class TestClass {
    private String test;
    public TestClass() {
    }
    public TestClass(String arg) {
    }
}

Tenga en cuenta que el constructor generado no realiza una inicialización no estándar. Esto significa que todos los campos de su clase tendrán su valor predeterminado, a menos que tengan un inicializador.

public class TestClass {

    private String testData;

    public TestClass() {
        testData = "Test"
    }
}

Los constructores se llaman así:

TestClass testClass = new TestClass();

Constructor con Argumentos

Los constructores se pueden crear con cualquier tipo de argumentos.

public class TestClass {

    private String testData;

    public TestClass(String testData) {
        this.testData = testData;
    }
}

Llamado así:

TestClass testClass = new TestClass("Test Data");

Una clase puede tener múltiples constructores con diferentes firmas. Para encadenar llamadas de constructor (llamar a un constructor diferente de la misma clase al crear instancias) use this() .

public class TestClass {

    private String testData;

    public TestClass(String testData) {
        this.testData = testData;
    }

    public TestClass() {
        this("Test"); // testData defaults to "Test"
    }
}

Llamado así:

TestClass testClass1 = new TestClass("Test Data");
TestClass testClass2 = new TestClass();

Llamar al constructor padre

Digamos que tienes una clase para padres y una clase para niños. Para construir una instancia de Child siempre se requiere que se ejecute algún constructor Parent desde el principio del constructor de Child. Podemos seleccionar el constructor principal que queremos llamando explícitamente a super(...) con los argumentos apropiados como nuestra primera declaración del constructor secundario. Hacer esto nos ahorra tiempo al reutilizar el constructor de las clases principales en lugar de volver a escribir el mismo código en el constructor de las clases secundarias.

Sin super(...) método:

(implícitamente, la versión no-args super() se llama invisiblemente)

class Parent {
    private String name;
    private int age;
    
    public Parent() {} // necessary because we call super() without arguments
    
    public Parent(String tName, int tAge) {
        name = tName;
        age = tAge;
    }
}

// This does not even compile, because name and age are private,
// making them invisible even to the child class.
class Child extends Parent {
    public Child() {
        // compiler implicitly calls super() here
        name = "John";
        age = 42;
    }
}

Con el método super() :

class Parent {
    private String name;
    private int age;
    public Parent(String tName, int tAge) {
        name = tName;
        age = tAge;
    }
}

class Child extends Parent {
    public Child() {
        super("John", 42);   // explicit super-call
    }
}

Nota: las llamadas a otro constructor (encadenamiento) o el súper constructor DEBEN ser la primera declaración dentro del constructor.

Si llama al constructor super(...) explícitamente, debe existir un constructor padre coincidente (eso es sencillo, ¿no es así?).

Si no llama explícitamente a ningún constructor super(...) , su clase principal debe tener un constructor sin argumentos, y esto puede ser escrito explícitamente o creado por defecto por el compilador si la clase principal no proporciona cualquier constructor

class Parent{
    public Parent(String tName, int tAge) {}
}

class Child extends Parent{
    public Child(){}
}

La clase Parent no tiene un constructor predeterminado, por lo tanto, el compilador no puede agregar super en el constructor Child. Este código no se compilará. Debes cambiar los constructores para que encajen en ambos lados, o escribir tu propia super llamada, así:

class Child extends Parent{
    public Child(){
          super("",0);
    }
}