Diferencia entre super() y this() en java

super y esta palabra clave super(), así como la palabra clave this(), se usan para hacer llamadas al constructor . super() se usa para llamar al constructor de la clase base (es decir, la clase principal) mientras que this() se usa para llamar al constructor de la clase actual . Veamos ambos en detalle:

palabra clave super() 

super() se usa para llamar al constructor de la clase base (clase principal). 

// Java code to illustrate usage of super()
 
class Parent {
    Parent()
    {
        System.out.println("Parent class's No " +
                              " arg constructor");
    }
}
 
class Child extends Parent {
    Child()
    {
        super();
        System.out.println("Flow comes back from " +
                        "Parent class no arg const");
    }
    public static void main(String[] args)
    {
        new Child();
        System.out.println("Inside Main");
    }
}

Producción:

Parent class's No arg constructor
Flow comes back from Parent class no arg const
Inside Main

Flujo de programa:

• En main, hemos hecho una declaración new Child() , por lo que llama al constructor sin argumentos de la clase Child.
• Dentro de eso tenemos super() que llama al no argumento de la clase Parent ya que hemos escrito super() y no tiene argumentos, por eso no llama al constructor de argumentos de la clase Parent, ya que tenemos una declaración SOP y, por lo tanto, imprime el No de la clase Parent. constructor de argumentos .
• Ahora, a medida que se completa Sin argumento const de la clase principal, el flujo vuelve al sin argumento de la clase secundaria y en eso tenemos una declaración SOP y, por lo tanto, imprime El flujo regresa de la clase principal sin const arg .
• Además, después de completar el constructor sin argumentos del flujo de clases secundarias, ahora regresa a main y ejecuta las declaraciones restantes e imprime Inside Main .

Podemos usar super() solo dentro del constructor y en ningún otro lugar , ni siquiera en un contexto estático, ni siquiera dentro de los métodos, y super() debería ser la primera declaración dentro del constructor. 

// Java program to illustrate usage of
// super() as first statement
 
class Parent {
    Parent()
    {
        System.out.println("Parent class's No " +
                           "arg constructor");
    }
}
 
class Child extends Parent {
    Child()
    {
        // Uncommenting below line causes compilation
        // error because super() should be first statement
        // System.out.println("Compile Time Error");
        super();
 
        System.out.println("Flow comes back from " +
                       "Parent class no arg const");
    }
 
    public static void main(String[] args)
    {
        new Child();
        System.out.println("Inside main");
    }
}

Producción:

Parent class's No arg constructor
Flow comes back from Parent class no arg const
Inside main

Nota: super() debe ser la primera declaración dentro de cualquier constructor. Solo se puede usar dentro del constructor y en ningún otro lugar. super() se usa para referirse solo al constructor de la clase principal (superclase) .

esta() palabra clave 

this() se usa para llamar al constructor de la clase actual . 

// Java code to illustrate usage of this()
 
class RR {
    RR()
    {
        this(10);
        System.out.println("Flow comes back from " +
                           "RR class's 1 arg const");
    }
 
    RR(int a)
    {
        System.out.println("RR class's 1 arg const");
    }
    public static void main(String[] args)
    {
        new RR();
        System.out.println(" Inside Main & quot;);
    }
}

Producción:

RR class's 1 arg const
Flow comes back from RR class's 1 arg const
Inside Main

Flujo de programa :

• Primero, comience desde main y luego hemos hecho una declaración new Child() , por lo tanto, llama al constructor sin argumentos de la clase Child, dentro de eso tenemos this (10) que llama al argumento 1 de la clase actual (es decir, RR clase)
• Como hemos escrito este (10) y 1 argumento, es por eso que llama al constructor de 1 argumento de la clase RR. En eso, tenemos una declaración SOP y, por lo tanto, imprime 1 arg const de la clase RR .
• Ahora, a medida que se completa el 1 argumento const de la clase RR, el flujo vuelve al no argumento de la clase RR y en eso tenemos una declaración SOP y, por lo tanto, imprime Flow regresa del 1 arg const de la clase RR .
• Además, después de completar el constructor sin argumentos del flujo de clase RR, ahora regresa a main y ejecuta las declaraciones restantes e imprime Inside Main .

Podemos usar this() solo dentro del constructor y en ningún otro lugar , ni siquiera en un contexto estático, ni siquiera dentro de los métodos, y this() debe ser la primera declaración dentro del constructor. 

// Java program to illustrate usage of
// this() as first statement
 
class RR {
    RR()
    {
        // Uncommenting below line causes compilation
        // error because this() should be first statement
        // System.out.println("Compile Time
        // Error");
        this(51);
        System.out.println(
            " Flow comes back from RR & quot; + "
            class 1 arg const& quot;);
    }
    RR(int k)
    {
        System.out.println("RR class's 1 arg const");
    }
    public static void main(String[] args)
    {
        new RR();
        System.out.println(" Inside main & quot;);
    }
}

Producción:

RR class's 1 arg constructor
Flow comes back from RR class 1 arg const
Inside main

Nota: this() debe ser la primera declaración dentro de cualquier constructor. Solo se puede usar dentro del constructor y en ningún otro lugar. this() se usa para referirse solo al constructor de la clase actual .

Puntos importantes sobre this() y super()

1. Podemos usar super() así como this() solo una vez dentro del constructor. Si usamos super() dos veces o this() dos veces o super() seguido de this() o this() seguido de super(), inmediatamente obtenemos un error de tiempo de compilación, es decir, podemos usar super() o this( ) como primera instrucción dentro del constructor y no ambas .
2. Depende de usted si usa super() o this() o no porque si no estamos usando this() o super() entonces, por defecto, el compilador pondrá super() como la primera declaración dentro del constructor. 

Ejemplo

// Java program to illustrate super() by default
// executed by compiler if not provided explicitly
 
class Parent {
    Parent()
    {
        System.out.println("Parent class's No " +
                          "argument constructor");
    }
    Parent(int a)
    {
        System.out.println("Parent class's 1 argument" +
                                      " constructor");
    }
 
}
 
class Base extends Parent {
    Base()
    {
        // By default compiler put super()
        // here and not super(int)
        System.out.println("Base class's No " +
                        "argument constructor");
    }
    public static void main(String[] args)
    {
        new Base();
        System.out.println("Inside Main");
    }
}

Output:
Parent class's No argument constructor
Base class's No argument constructor
Inside Main

Flujo de programa:

• Dentro de main tenemos una nueva Base() , luego el flujo va al constructor Sin argumentos de la clase Base.
• Después de eso, si no ponemos ni super() ni this() entonces, por defecto, el compilador pone super() .
• Entonces, el flujo va al constructor No arg de la clase principal y no al constructor de 1 argumento .
• Después de eso, imprime el constructor sin argumentos de la clase principal .
• Después de eso, cuando el constructor Parent() completa el flujo nuevamente, regresa al constructor sin argumentos de la clase base y ejecuta la siguiente declaración SOP, es decir, el constructor sin argumentos de la clase base .
• Después de completar el flujo del constructor Sin argumentos, vuelve a main() e imprime las declaraciones restantes dentro de main(), es decir, Inside main

Llamada de constructor recursivo no permitida 

// Java program to illustrate recursive
// constructor call not allowed
 
class RR {
    RR() { this(30); }
    RR(int a) { this(); }
    public static void main(String[] args) { new RR(); }
}

Producción:

Compile time error saying recursive constructor invocation

Flujo del programa: aquí, arriba comienza desde main() y luego el flujo va al constructor No arg de la clase RR. Después de eso, tenemos esto (30) y el flujo va al constructor 1 arg de RR y en eso tenemos esto() así que nuevamente el flujo va al constructor No arg de la clase base y en eso nuevamente tenemos esto (30) y fluye nuevamente va al constructor 1 arg de la clase Base y continúa… como una recursión. Por lo tanto, no es válido, es por eso que recibimos un error en tiempo de compilación que dice invocación de constructor recursivo . Por lo tanto, las invocaciones de constructores recursivos no están permitidas en Java.

Veamos las diferencias en forma tabular de la siguiente manera:

Este artículo es una contribución de Rajat Rawat . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.