super y estas palabras clave en Java

En java, la palabra clave super se usa para acceder a los métodos de la clase principal, mientras que esto se usa para acceder a los métodos de la clase actual .

esta palabra clave es una palabra clave reservada en Java, es decir, no podemos usarla como identificador. Se utiliza para hacer referencia a la instancia de la clase actual, así como a los miembros estáticos. Se puede utilizar en varios contextos como se indica a continuación:

• para referirse a la variable de instancia de la clase actual
• para invocar o iniciar el constructor de clase actual
• se puede pasar como un argumento en la llamada al método
• se puede pasar como argumento en la llamada al constructor
• se puede utilizar para devolver la instancia de clase actual

Ejemplo

// Program to illustrate this keyword
// is used to refer current class
class RR {
    // instance variable
    int a = 10;
 
    // static variable
    static int b = 20;
 
    void GFG()
    {
        // referring current class(i.e, class RR)
        // instance variable(i.e, a)
        this.a = 100;
 
        System.out.println(a);
 
        // referring current class(i.e, class RR)
        // static variable(i.e, b)
        this.b = 600;
 
        System.out.println(b);
    }
 
    public static void main(String[] args)
    {
        // Uncomment this and see here you get
        // Compile Time Error since cannot use
        // 'this' in static context.
        // this.a = 700;
        new RR().GFG();
    }
}

100
600

súper palabra clave 

1. super es una palabra clave reservada en java, es decir, no podemos usarla como identificador.
2. super se usa para referirse a la instancia de la superclase, así como a los miembros estáticos .
3. super también se usa para invocar el método o constructor de la superclase .
4. La palabra clave super en el lenguaje de programación java se refiere a la superclase de la clase en la que se está utilizando actualmente la palabra clave super.
5. El uso más común de la palabra clave super es que elimina la confusión entre las superclases y subclases que tienen métodos con el mismo nombre.

super se puede usar en varios contextos como se indica a continuación:

• se puede utilizar para hacer referencia a la variable de instancia de clase principal inmediata
• se puede usar para referirse al método de clase padre inmediato
• se puede usar para referirse al constructor de la clase principal inmediata.

Ejemplo

// Program to illustrate super keyword
// refers super-class instance
 
class Parent {
    // instance variable
    int a = 10;
 
    // static variable
    static int b = 20;
}
 
class Base extends Parent {
    void rr()
    {
        // referring parent class(i.e, class Parent)
        // instance variable(i.e, a)
        System.out.println(super.a);
 
        // referring parent class(i.e, class Parent)
        // static variable(i.e, b)
        System.out.println(super.b);
    }
 
    public static void main(String[] args)
    {
        // Uncomment this and see here you get
        // Compile Time Error since cannot use 'super'
        // in static context.
        // super.a = 700;
        new Base().rr();
    }
}

10
20

Similitudes en esto y super

• Podemos usar esto así como super en cualquier lugar excepto en áreas estáticas . Un ejemplo de esto ya se muestra arriba, donde usamos esto, así como super dentro de la principal vacía estática pública (String []args), por lo tanto, obtenemos un error de tiempo de compilación ya que no podemos usarlos dentro del área estática.
• Podemos usar esto y super cualquier número de veces en un programa . 
• Ambos son palabras clave no estáticas .

Ejemplo 

// Java Program to illustrate using this
// many number of times
 
class RRR {
    // instance variable
    int a = 10;
 
    // static variable
    static int b = 20;
 
    void GFG()
    {
        // referring current class(i.e, class RR)
        // instance variable(i.e, a)
        this.a = 100;
 
        System.out.println(a);
 
        // referring current class(i.e, class RR)
        // static variable(i.e, b)
        this.b = 600;
 
        System.out.println(b);
 
        // referring current class(i.e, class RR)
        // instance variable(i.e, a) again
        this.a = 9000;
 
        System.out.println(a);
    }
 
    public static void main(String[] args)
    {
        new RRR().GFG();
    }
}

100
600
9000

Vea arriba, hemos usado esto 3 veces. Así que esto se puede utilizar cualquier número de veces.

// Java Program to illustrate using super
// many number of times
 
class Parent {
    // instance variable
    int a = 36;
 
    // static variable
    static float x = 12.2f;
}
 
class Base extends Parent {
    void GFG()
    {
        // referring super class(i.e, class Parent)
        // instance variable(i.e, a)
        super.a = 1;
        System.out.println(a);
 
        // referring super class(i.e, class Parent)
        // static variable(i.e, x)
        super.x = 60.3f;
 
        System.out.println(x);
    }
    public static void main(String[] args)
    {
        new Base().GFG();
    }
}

1
60.3

Vea arriba, hemos usado super 2 veces. Entonces super se puede usar cualquier número de veces. 

Nota: Podemos usar ‘esto’ y ‘super’ cualquier cantidad de veces, pero lo principal es que no podemos usarlos dentro de un contexto estático. 

Consideremos un ejemplo engañoso de esta palabra clave: 

// Java program to illustrate
// the usage of this keyword
 
class RR {
    int first = 22;
    int second = 33;
 
    void garcia(int a, int b)
    {
        a = this.first;
        b = this.second;
        System.out.println(first);
        System.out.println(second);
        System.out.println(a);
        System.out.println(b);
    }
 
    void louis(int m, int n)
    {
        this.first = m;
        this.second = n;
        System.out.println(first);
        System.out.println(second);
        System.out.println(m);
        System.out.println(n);
    }
 
    public static void main(String[] args)
    {
        new RR().garcia(100, 200);
        new RR().louis(1, 2);
    }
}

Producción: 

//it is of S.O.P(first) of garcia method
22
//it is of S.O.P(second) of garcia method
33
//it is of S.O.P(a) of garcia method
22
//it is of S.O.P(b) of garcia method
33
//it is of S.O.P(first) of louis method
1
//it is of S.O.P(second) of louis method
2
//it is of S.O.P(m) of louis method
1
//it is of S.O.P(n) of louis method
2

Flujo del programa: Primero, comienza desde main y luego tenemos new RR().garcia(100, 200), luego el flujo va al método garcia de la clase RR y luego tenemos:

a = this.first
b = this.second 

Aquí, lo que sucede es que el valor de la variable de instancia (es decir, la primera) y el valor de la variable estática (es decir, la segunda) se asignan a las variables locales ayb del método de García, respectivamente. Por lo tanto, el valor de a y b resulta ser 22 y 33 respectivamente. A continuación tenemos el nuevo RR().louis(1, 2), por lo tanto, aquí el flujo va al método louis de la clase RR y en eso tenemos:  

this.first = m
this.second = n

Aquí, arriba, lo que sucede es que el valor de las variables locales del método louis, es decir, m y n, se asignan a la instancia, así como las variables estáticas, es decir, primero y segundo, respectivamente. 
Por lo tanto, el valor de la primera y la segunda variable son los mismos que hemos pasado al método louis, es decir, 1 y 2 respectivamente.

¿Podemos usar this() y super() en el mismo constructor?

Una cosa interesante a tener en cuenta aquí es que, de acuerdo con las pautas de Java, this() o super() deben ser la primera declaración en el bloque constructor para que se ejecute. Por lo tanto, no podemos tenerlos juntos en el mismo constructor, ya que ambos deben ser la primera declaración en el bloque para una ejecución adecuada, lo cual no es posible. Intentar hacerlo generaría un error del compilador.

class Vehicle {
    Vehicle() { System.out.println("Vehicle is created."); }
}
 
class Bike extends Vehicle {
    Bike() { System.out.println("Bike is created."); }
 
    Bike(String brand)
    {
        super(); // it calls Vehicle(), the parent class
                 // constructor of class Bike
        this();
        System.out.println("Bike brand is " + brand);
    }
}
 
public class GFG {
    public static void main(String args[])
    {
        Bike bike = new Bike("Honda");
    }
}

Al ejecutar el programa anterior, obtenemos un error en la línea número 12 que dice que «la llamada a esto debe ser la primera declaración en el constructor». Esto se debe a que intentamos usar tanto super() como this() juntos. Si bien super() era la primera línea del constructor, esta declaración() violaba la condición de que debería ser la primera línea, por lo que generaba un error.

Errores de compilación:

prog.java:12: error: call to this must be first statement in constructor
        this();
            ^
1 error

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.