Programa Java para ilustrar la disponibilidad del constructor predeterminado de la superclase a la subclase por defecto

Un constructor en Java es un método especial que se usa para inicializar un objeto. Cada vez que se crea un objeto usando la palabra clave new(), se llama al menos una construcción. El nombre del constructor debe coincidir con el nombre de la clase y no puede tener un tipo de retorno. Si no hay un constructor disponible en la clase, en tal caso, el compilador de Java proporciona un constructor predeterminado (sin constructor de parámetros) de forma predeterminada.

¿Cuál es el propósito del constructor predeterminado (constructor sin parámetros) ?

El constructor predeterminado se usa para proporcionar los valores predeterminados al objeto, como 0, nulo, etc., según el tipo.

Ejemplo de constructor por defecto

En el código que se proporciona a continuación, hemos creado una clase denominada Constructor predeterminado y, dentro de esta clase, hemos creado un constructor predeterminado.

// Java program to illustrate default constructor
 
import java.io.*;
class defaultConstructor {
    int a;
    double d;
    String s;
 
    // creating default constructor
    defaultConstructor()
    {
        System.out.println("Hi I am a default constructor");
    }
}
class GFG {
    public static void main(String[] args)
    {
        // creating an object of class defaultConstructor
        // after creating an object it will invoke the
        // default constructor
        defaultConstructor obj = new defaultConstructor();
 
        // default constructor provide default values to
        // the object
        System.out.println(obj.a);
        System.out.println(obj.d);
        System.out.println(obj.s);
    }
}

Hi I am a default constructor
0
0.0
null

La Disponibilidad del Constructor por Defecto de la Súper Clase a la Subclase por Defecto.

Cuando heredamos de la clase principal a la secundaria, primero se debe llamar a la palabra clave super() en el constructor de la clase secundaria. Si no se llama a super() en el constructor de la clase secundaria, el compilador de Java lo hará por nosotros . Esta es la razón por la que también se llama al constructor de la clase principal cada vez que creamos un objeto de la clase secundaria.

Ejemplo 1:

// Java Program to Illustrate the Availability of Default
// Constructor of the Super Class to the Sub Class by
// Default
 
import java.io.*;
 
// creating parent class
class parent {
 
    // default constructor of parent class
    parent()
    {
        System.out.println(
            "I am default constructor from parent class");
    }
}
 
// creating child class and inheriting parent class to the
// child class
class child extends parent {
 
    // default constructor of child class
    child()
    {
        System.out.println(
            "I am default constructor from child class");
    }
}
class GFG {
    public static void main(String[] args)
    {
        // creating object of parent class and this will
        // only invoke parent class default constructor
        parent obj1 = new parent();
 
        // creating object of child class and this will
        // invoke parent class constructor first and then it
        // will invoke child class constructor
        child obj2 = new child();
    }
}

I am default constructor from parent class
I am default constructor from parent class
I am default constructor from child class

Ejemplo 2:

// Java Program to Illustrate the Availability of Default
// Constructor of the Super Class to the Sub Class by
// Default
 
import java.util.*;
 
class z {
 
    // default constructor of class z
    z() { System.out.println("Hi I am z"); }
}
 
class y extends z {
 
    // default constructor of class y
    y() { System.out.println("Hi I am y"); }
}
class x extends y {
 
    // default constructor of class x
    x() { System.out.println("Hi I am x"); }
}
 
class GFG {
 
    public static void main(String[] args)
    {
        // creating an object of class x
        // this will invoke the constructor of x
        // but before invoking the constructor of class x
        // it will invoke the constructor of it's parent
        // class which is y but y is child of z class so,
        // before invoking the constructor of y class it
        // will invoke the constructor of z class(parent of
        // y class)
        x obj = new x();
    }
}

Hi I am z
Hi I am y
Hi I am x

Ejemplo 3:

Aquí, solo queremos mostrar el uso de la palabra clave super(), cómo funciona 

// Java Program to Illustrate the Availability of Default
// Constructor of the Super Class to the Sub Class by
// Default
 
import java.util.*;
 
class z {
 
    // default constructor of class z
    z() { System.out.println("Hi I am z"); }
}
class y extends z {
 
    // default constructor of class y
    y()
    {
        // keyword super() is called by java compiler by
        // default in case of default constructor
        super();
 
        System.out.println("Hi I am y");
    }
}
class x extends y {
 
    // default constructor of class x
    x()
    {
        // keyword super() is called by java compiler by
        // default in case of default constructor
        super();
        System.out.println("Hi I am x");
    }
}
 
class GFG {
 
    public static void main(String[] args)
    {
        // creating an object of class x
        // this will invoke the constructor of x
        // but before invoking the constructor of class x
        // it will invoke the constructor of it's parent
        // class which is y but y is child of z class so,
        // before invoking the constructor of y class it
        // will invoke the constructor of z class(parent of
        // y class)
        x obj = new x();
    }
}

Hi I am z
Hi I am y
Hi I am x