“This” y “Super”: la diferencia más fácil de entender en programación orientada a objetos

Idea básica

Piensa en la programación orientada a objetos como en una familia:

• Tú eres una persona con tus propias características (nombre, edad, gustos).

• Pero también heredas cosas de tus padres (tu apellido, algunas costumbres, incluso habilidades).

En este escenario:

• this es como decir: “yo mismo”.se refiere a lo que tienes tú como persona.

• super es como decir: “mi papá o mi mamá” se refiere a lo que heredaste de tu familia.

¿Qué hace this?

this es la forma en que un objeto habla de sí mismo. Sirve para:

1. 1. Evitar confusiones con nombres repetidos
      A veces una variable se llama igual que un atributo. this aclara cuál es cuál.

      class Persona {
          String nombre;
          Persona(String nombre) {
              this.nombre = nombre; // "this" aclara que hablamos del atributo
          }
      }
      

   2. Usar tus propios métodos o atributos
      Es como decir: “quiero que el que actúe sea yo, no otro”.

   3. Pasarte a ti mismo como argumento
      Por ejemplo, cuando una función necesita trabajar con la instancia completa y no con una parte.

En otras palabras, this es el yo de la clase.

¿Qué hace super?

super aparece cuando hay herencia. Una clase puede “heredar” características de otra, y con super le decimos al programa: “usa lo que ya definió mi papá”.

1. Acceder a lo heredado
   Si tu padre (la clase padre) ya tiene un método, no hace falta volver a escribirlo. Con super puedes usarlo directamente.

2. Llamar al constructor de la superclase
   Es como decir: “antes de que yo exista, primero que se construya lo que heredé”.

3. Combinar comportamientos
   Si un hijo quiere hacer algo parecido a su padre, pero con un toque personal, puede llamar al método del padre y después añadir lo suyo.

   class Animal {
       void sonido() {
           System.out.println("Hace un sonido genérico");
       }
   }
   
   class Perro extends Animal {
       @Override
       void sonido() {
           super.sonido(); // Llama al comportamiento del padre
           System.out.println("Guau guau"); // Añade su propia lógica
       }
   }
   

Diferencia clave

• this -> apunta a lo que soy yo (mi identidad, mis atributos, mis métodos).

• super -> apunta a lo que heredé de arriba (mi padre o madre en la jerarquía).

O dicho de manera aún más sencilla:

• this = “mírame a mí mismo”.

• super = “mira lo que mi padre ya tenía”.

Ejemplo práctico: this y super trabajando juntos

Imagina que estamos programando un sistema sencillo para registrar animales.

class Animal {
    String nombre;

    // Constructor de la clase padre
    Animal(String nombre) {
        this.nombre = nombre; // "this" distingue el atributo del parámetro
    }

    void sonido() {
        System.out.println("Hace un sonido genérico");
    }
}

// Clase hija que hereda de Animal
class Perro extends Animal {

    // Constructor de la clase hija
    Perro(String nombre) {
        super(nombre); // Llama al constructor del padre con "super"
    }

    @Override
    void sonido() {
        super.sonido(); // Llama primero al método de la clase padre
        System.out.println("Guau guau"); // Añade su propio comportamiento
    }

    void presentarse() {
        System.out.println("Hola, soy " + this.nombre); // Usa "this" para referirse al atributo propio
    }
}

¿Qué sucede aquí?

1. En la clase Animal:

   • Usamos this.nombre = nombre; para aclarar que estamos guardando el valor en el atributo de la clase, y no en el parámetro local.

2. En la clase Perro:

   • En el constructor, usamos super(nombre); para decir: antes de crear al perro, inicializa lo que el padre (Animal) ya tenía definido.

   • En el método sonido(), super.sonido(); llama primero al comportamiento genérico, y después agregamos el ladrido del perro.

   • En el método presentarse(), this.nombre apunta al atributo de la instancia actual.

Aclaración de uso:

• this se usa para hablar de uno mismo (la clase actual).

• super se usa para apoyarse en lo que ya hizo el padre.

“Entender la diferencia entre this y super no solo mejora tu código, también te ayuda a pensar como un verdadero arquitecto de software: claro, organizado y con visión a futuro.”