Polimorfismo: Sobreescritura de Métodos

Al imprimir cualquier objeto en la consola con System.out.println(object), en realidad, estamos ejecutando el método .toString() de dicho objeto, por lo que si sobreescribimos este método en nuestras clases, el resultado en la consola también cambiará automáticamente.

Un ejemplo clásico de poliformismo es el siguiente. Podemos crear dos clases distintas: Gato y Perro, que heredan de la superclase Animal. La clase Animal tiene el método abstracto makesound() que se implementa de forma distinta en cada una de las subclases (gatos y perros suenan de forma distinta). Entonces, un tercer objeto puede enviar el mensaje de hacer sonido a un grupo de objetos Gato y Perro por medio de una variable de referencia de clase Animal, haciendo así un uso polimórfico de dichos objetos respecto del mensaje mover.

class Animal {
  public void makeSound() {
    System.out.println("Grr...");
  }
}
class Cat extends Animal {
  public void makeSound() {
    System.out.println("Meow");
  }
}
class Dog extends Animal {
  public void makeSound() {
    System.out.println("Woof");
  }
}

Como todos los objetos Gato y Perro son objetos Animales, podemos hacer lo siguiente

public static void main(String[ ] args) {
  Animal a = new Dog();
  Animal b = new Cat();
}

Creamos dos variables de referencia de tipo Animal y las apuntamos a los objetos Gato y Perro. Ahora, podemos llamar a los métodos makeSound().

a.makeSound();
//Outputs "Woof"

b.makeSound();
//Outputs "Meow"

Por lo general diremos que existen 3 tipos de polimorfismo:

• Sobrecarga: El más conocido y se aplica cuando existen funciones con el mismo nombre en clases que son completamente independientes una de la otra.

• Paramétrico: Existen funciones con el mismo nombre pero se usan diferentes parámetros (nombre o tipo). Se selecciona el método dependiendo del tipo de datos que se envíe.

• Inclusión: Es cuando se puede llamar a un método sin tener que conocer su tipo, así no se toma en cuenta los detalles de las clases especializadas, utilizando una interfaz común.

En Java solo permite la herencia Monogámica, un solo padre, lol

Creo que cambiamos lo que antes imprimia cosas sin sentido
[email protected]

💡 Todas las clases que generaremos en Java, heredaran de la clase Object.

Super! Me costó un poco pero entendido!

En el ejemplo, se sobrescribió el método .toString() en la clase Patient que se había sobrescrito en la clase User.

buena clase, ahora me cae el 20 de muchas cosas. excelente maestra!

Entiendo, por lo menos en este caso, que cuando se imprime el objeto, por defecto llama al método “toString” con las características correspondiente a cada objeto…

Qué interesante!

Para los que no les aparece la documentación de los mètodos en Intellij. Tienen que cambiar sus configuraciones. File->Settings->Editor->General->Code Completion
y activar las opciones: Show the documentation popup in 1000ms, ademàs, show full method signatures

Polimorfismo: Sobrescribiendo el método toString

En Java, todas las clases que creemos heredan de la clase Object. De esta clase es de donde vienen los métodos que tienen las clases que no fueron creados por nosotros, como equals, hashCode, toString, etc.

En Java no se permite la herencia múltiple, es decir, una clase solo puede heredar de una sola clase.

El Polimorfismo es una característica de la programación orientada a objetos que consiste en sobrescribir algunos métodos de la clase de la cual heredan nuestras subclases para asignar comportamientos diferentes.

Además de los métodos de las superclases, también podemos redefinir el comportamiento de los métodos que “heredan” todos nuestros objetos, así como .toString, hashCode, finalize, notify, entre otros.

Cuando una clase hereda de otra y en esta clase hija se redefine un método con una implementación distinta a la del padre.

Los métodos marcados como final o static no se pueden sobrescribir.

Un constructor en una subclase usando los miembros heredados de la superclase con argumentos diferentes.

Si en alguna clase declaramos el método toString vemos que por encima aparece @Override, esto quiere decir que el método que estamos usando pertenece a la clase padre. En este caso toString pertenece a la clase Object, que es la clase padre de todas las clases que creemos.

La función del método toString es imprimir todos los atributos con sus valores del objeto desde el que se aplique. El comportamiento de este puede ser cambiado según se requiera.

clase padre solo hay uno c:

Buenas, la sobre escritura de método permite que al momento de crear un objeto este sea llamado?
Esto porque veo que cuando crea el objeto patient este no llama al método toString

 @Override
    public String toString() {
        String newLine = System.getProperty("line.separator");
        return "User: " + this.name 
                + newLine
                + "Email: " + this.email
                + newLine
                + "Address: " + this.address
                + newLine
                + "Phone number: " + this.phoneNumber;
    }

Importante no confundir sobreescritura con sobrecarga.

Comparto un ejemplo entre nuestras clases
Clase User:

public void showData(){
        System.out.println("Name:"+ name + " Email:"+email+" ID:"+id);
    }

Clase Doctor:

@Override
    public void showData(){
        System.out.println("Name:"+ getName() + " Email:"+getEmail()+" ID:"+ getId()+" Speciality:"+getSpeciality());
    }

Como ven en el metodo sobrescrito le agregue la especialidad

Según comprendí… con el método toString() vamos a sobrescribir lo que retorne al llamar cada objeto, por lo que no tenemos que llamar al método toString() sino directamente llamar al objeto y vendrá según lo hayamos decidido en el método

Si no les muestra la clase de donde viene el método presionen ctrl+q

Les comparto mis apuntes detallados de la clase.

Todo bien hasta ahora jaja 💗📘💻

Polimorfismo, consiste en que un objeto puede tomar muchas formas. Dependiendo del contexto una misma variable objeto puede comportarse de una manera o de otra.

La clase OBJECT es conocida también como clase cósmica, porque se trata de una clase padre o superclase de la cual heredan todas las clases de java.

intelliJ ya reconoce lo que queremos hacer, solo basta on poner toString y te genera el siguiente codigo

@Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", address='" + address + '\'' +
                ", phoneNumber='" + phoneNumber + '\'' +
                '}';
    }

Metodo tostring, nos muestra la forma como se imprimirá el objeto

    @Override
    public String toString() {
        return
                "ID= " + ID + ", name='" + super.getName() + '\'' +
                ", lastname= '" + super.getLastname() + '\'' +
                ", tell= '" + super.getTell() + '\'' +
                ", Address= '" + Address + '\'' +
                ", latitud= '" + latitud + '\'' +
                ", longitud= '" + longitud + '\'' +
                "}\n";
    }

buena clase gracias anahi

En este caso no es mejor colocar la clase User como abstracta?, luego colocarle un metodo abstracto que se llame no se printInfo. En cada subclase tendras este metodo pero con diferente comportamiento. Que opinan?

Me gusta el método .toString para formatear lo que imprimmiremos.

Genial

La sobreescritura de metodos, permite modificar el compartamiento de los metodos de la clase padre para dar un comportamiento distinto en la clase hija.

ok muchas gracias

Genial!!!

Espectacular! Muy bien explicado.

polimorfismo y sobrescribiendo métodos 😃

Estupenda clase instructora Anahí, por medio de la sobreescritura podemos ahorrar o mejorar ciertos métodos para facilitarnos el desarrollo de la aplicación.

Los métodos Static y final no se pueden sobreescribir

La sobreescritura es cuando una clase hereda de otra y en esta clase se redefine un método con una implementación distinta.

Por fin entendí este tema jajajjaj

Sinceramente no habia entendido esto en el curso pasado bien, pero en este lo entendi bien.

Vamos muy bien 😃

Muy claro el uso de Polimorfismo.
Todo OK 😁

Excelente clase. Con la herencia logramos optimizar nuesto codigo para que sea mucho mas facil de mantener y crear nuevos features.

Ann explica super bien todas las clases 😃

El metodo toString obtiene el nombre de la clase + ‘@’+ el hascode que es un identificador firma de un objeto

publicStringtoString(){
returngetClass().getName()+"@"+Integer.toHexString(hashCode());
}

Solo tengo un detalle los constructores no se sobre escriben

Cuando uno sobre escribe un metodo en una clase hija cambia su comportamiento, sin embargo el constructor de clase hija, Llamara si o si al constructor padre, por lo tanto no estoy cambiando su comportamiento.

**Clase 21 - Polimorfismo: Sobre-escritura de métodos **

Para los que les apetezca tomar la clase en Eclipse iré subiendo mi código; hay pequeñas diferencias con Intellij, por no decir ninguna, pero con Eclipse se puede trabajar igual de bien. NOTA: Solo subiré la jerarquía y lo que haya sido modificado, tendrán los archivos no modificados en las clases anteriores.

Project Hierarchy

File: User.java; Method: toString()

@Override
public String toString() {
	return "User:" + name + ", Email: " + email + "\n" +
		"Address: " + address + " Phone: " + phoneNumber;
}

File: Patient.java; Method: toString()

@Override
public String toString() {
	return super.toString() + "\nAge: " + birthday + "\n Weight: " + getWeight() + "\n Height: " + getHeight()
			+ "\n Blood: " + getBlood();
}

La clase Object es la raíz de la jerarquía de clases. Cada clase tiene Object como superclase. Todos los objetos, incluidas las matrices, implementan los métodos de esta clase.
https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html

Acá es donde es importante diferenciar los argumentos de los parámetros. Un parámetro es la variable que se declara dentro de los paréntesis de un método o constructor (con tipo y nombre) y el argumento es el valor que se le da a ese parámetro cuando se hace el llamado al método y/o constructor.

polimorfismo :0

Muy interesante el tema del polimorfismo, se trata de poder modificar o personalizar métodos que han sido heredados para ajustarlos a el comportamiento deseado.

 @Override
    public String toString() {
        return super.toString() + "\nAge: " + birthay + "\nWeight: " + getWeight() + "\nHeight: " + getHeight() + "\nBlood: " + blood;
    }```

Polimorfismo: Sobreescritura de Métodos

En Java hay una Clase de la que heredan todas las Clases, esa es la Clase Object. Esto permite usar una serie de métodos y atributos que proporciona la Clase Object.

**Nota: ** en Java no se permite la herencia múltiple de Clases. Las Clases hijas sólo pueden tener una Clase padre.

**Sobrescritura **

Cuando una Clase hereda de otra y en la Clase hija se redefine un método con una implementación distinta a la de la Clase padre.

Nota: los métodos marcados como final o static no se pueden sobrescribir.

Sobrescritura de Constructores

Un constructor en una subclase usando los miembros heredados de la superclase con argumentos diferentes.

Ejemplo: sobrescribir el método toString().

@Override //  Indica que el método qu esta a continuación no es propio de la Clase y va a ser sobrescrito.
public String toString() {
    return "User{" +
        "id=" + id +
        ", name='" + name + '\'' +
        ", email='" + email + '\'' +
        ", address='" + address + '\'' +
        ", phoneNumber='" + phoneNumber + '\'' +
        '}';
}

Usar el método con la sobrescritura:

System.out.println(myDoctor);
/*
Al imprimir cualquier objeto en la consola con System.out.println(object), en realidad, se esta ejecutando el método .toString() de dicho objeto, por lo que si se sobrescribe este método en una Clase, el resultado en la consola también cambiará automáticamente.
*/

Se puede sobrescribir un mismo método en diferentes Clases y en cada una darle un comportamiento diferente. Por ejemplo después de sobrescribir el método toString() en el ejemplo anterior, se podría volver a sobrescribir dicho método para que muestre datos adicionales:

@Override
public String toString() {
    return super.toString() + // return super.toString() → Retorna el método sobrescrito en la superclase para poder concaternarle los datos adicionales.
        "Age='" + birthday + '\'' +
        ", weight=" + getWeight() +
        ", height=" + getHeight() +
        ", blood='" + blood + '\'' +
        '}';
}

A IntelliJ le escribi toString le di Tab y me puso todo de una, amo a este IDE. Creo que voy a mandar a la ñonga a Visual Studio Code

Muy buena Clase