Clases que repiten lo mismo
Un Auto, una Moto y un Camión comparten marca, arrancar() y frenar(). Copiar y pegar funciona hasta que cambia una regla: ahí hay que acordarse de los tres lugares.
Auto
marcaarrancar()frenar()Moto
marcaarrancar()frenar()Camión
marcaarrancar()frenar()Copiar y pegar
Cambia una regla → hay que tocar tres lugares
Herencia
Vehiculo marcaarrancar()frenar() Lo común vive una sola vez, arriba; las subclases lo reciben con extends.
1 Primera sentencia
super(...) Nada corre antes de que la parte heredada esté lista
2 Si falta
super() Java lo inserta sin argumentos, automáticamente
3 Sin constructor vacío en el padre
no compila Hay que llamar a uno que sí exista
Error de compilación
constructor Vehiculo in class Vehiculo cannot be applied to given types Al escribir un constructor con argumentos, Vehiculo dejó de tener uno vacío
super.arrancar()
super.arrancar(); // extiende, no reemplaza Llama a la versión del padre de un método sobrescrito
@Override
Verificación del compilador
No cambia la ejecución: confirma que realmente sobrescribís algo
Sin la anotación
arrancar(int velocidad) Es un método nuevo de Auto: el original sigue heredado
Nombre y parámetros
Idénticos: si cambian, es un método nuevo
Tipo de retorno
El mismo, o un subtipo (retorno covariante)
Visibilidad
La misma o más abierta, nunca más cerrada
Excepciones checked
Las mismas, menos, o subtipos
private · static · final
No se pueden sobrescribir
Sin polimorfismo
if (v instanceof Auto) { … } else if (v instanceof Moto) { … } else if (v instanceof Camion) { … } Crece para siempre y hay que editarla cada vez
Con polimorfismo
for (Vehiculo v : flota) v.arrancar(); Cada objeto ejecuta su propia versión: ninguna cadena, ningún casteo
Clase final
public final class Coordenada Nadie puede heredar de acá
Método final
public final void acreditar(…) Este método no se sobrescribe
Sobrescribir cambiando parámetros
Método nuevo. Poné siempre @Override
Constructor hijo sin super(...)
Llamá a super(argumentos) en la primera línea
Método sobrescribible en el constructor del padre
Usá solo métodos private o final
Castear sin instanceof
ClassCastException. Usá if (v instanceof X x)
Heredar solo para reutilizar código
Sin "es un", componé: tené el objeto y delegá
Confundir sobrecarga con sobrescritura
Misma clase y firmas distintas vs. subclase y misma firma
1 Paso
Empleado
nombre, sueldoBase y calcularSalario()
2 Paso
Gerente
suma un bono con super.calcularSalario()
3 Paso
Vendedor
suma una comisión del 8 % sobre sus ventas
4 Paso
toString()
sobrescrito en las tres clases
5 Paso
Un solo bucle
sobre un Empleado[]: sin instanceof ni casteos
CursoDeJava · l10_herencia_polimorfismo_y_sobrecarga
Empleados, zoológico, transporte, animales, personas y materias, y un integrador de biblioteca
Un Auto, una Moto y un Camión comparten marca, arrancar() y frenar().
Copiar y pegar funciona hasta que cambia una regla: ahí hay que acordarse de los tres lugares.
Un Auto, una Moto y un Camión comparten marca, arrancar() y frenar(). Copiar y pegar funciona hasta que cambia una regla: ahí hay que acordarse de los tres lugares.
La herencia pone lo común arriba, una sola vez, y cada clase lo recibe.
El polimorfismo es su consecuencia: por eso la lección trata las dos cosas juntas.
La herencia pone lo común arriba, una sola vez, y cada clase lo recibe. El polimorfismo es su consecuencia: por eso la lección trata las dos cosas juntas.
public class Vehiculo {protected String marca; public Vehiculo(String marca) { this.marca = marca; } public void arrancar() { System.out.println("El vehículo arranca."); }public void frenar() { System.out.println("El vehículo frena."); }} public class Auto extends Vehiculo {public Auto(String marca) { super(marca); } @Overridepublic void arrancar() {System.out.println("Auto " + marca + " arrancando con botón.");} public void abrirBaul() { System.out.println("Baúl abierto."); }} extends hace que Auto reciba todos los atributos y métodos de Vehiculo.
La flecha apunta al padre: va de lo específico a lo general.
extends hace que Auto reciba todos los atributos y métodos de Vehiculo. La flecha apunta al padre: va de lo específico a lo general.
Auto no declara marca ni frenar(), pero los tiene: los heredó.
Moto y Camión reciben lo mismo, y cada clase suma lo propio.
Auto no declara marca ni frenar(), pero los tiene: los heredó. Moto y Camión reciben lo mismo, y cada clase suma lo propio.
Una subclase puede redefinir un método heredado con @Override.
Auto y Moto cambian arrancar(); Camión cambia frenar().
Todo lo demás sigue siendo el del padre.
Una subclase puede redefinir un método heredado con @Override. Auto y Moto cambian arrancar(); Camión cambia frenar(). Todo lo demás sigue siendo el del padre.
Antes de escribir extends, preguntate en voz alta: ¿un X es un Y?
Un Auto es un Vehiculo: la herencia está bien puesta.
Un Auto no es un Motor: tiene uno. Eso es composición.
Antes de escribir extends, preguntate en voz alta: ¿un X es un Y? Un Auto es un Vehiculo: la herencia está bien puesta. Un Auto no es un Motor: tiene uno. Eso es composición.
Java tiene herencia simple: una clase extiende a una sola clase.
No existe extends A, B: para combinar comportamientos están las interfaces.
Java tiene herencia simple: una clase extiende a una sola clase. No existe extends A, B: para combinar comportamientos están las interfaces.
Al instanciar una subclase no corre un constructor: corre toda la cadena.
Va desde Object, el ancestro más lejano, hasta la clase concreta.
Al instanciar una subclase no corre un constructor: corre toda la cadena. Va desde Object, el ancestro más lejano, hasta la clase concreta.
Primero suben las llamadas: cada super(...) le cede el control al padre.
Si no escribís super(...), Java inserta super() por su cuenta.
Primero suben las llamadas: cada super(...) le cede el control al padre. Si no escribís super(...), Java inserta super() por su cuenta.
Después se ejecutan los cuerpos, de arriba hacia abajo: 1, 2 y 3.
Cuando corre el cuerpo de Auto, la parte heredada ya está inicializada.
Después se ejecutan los cuerpos, de arriba hacia abajo: 1, 2 y 3. Cuando corre el cuerpo de Auto, la parte heredada ya está inicializada.
Tres reglas, sin excepción: super(...) tiene que ser la primera sentencia.
Si falta, Java inserta super(); y si el padre no lo tiene, no compila.
Tres reglas, sin excepción: super(...) tiene que ser la primera sentencia. Si falta, Java inserta super(); y si el padre no lo tiene, no compila.
El error más frecuente: el padre solo tiene un constructor con argumentos.
El compilador reclama por un constructor que nunca escribiste.
Se arregla llamando a super(marca) en la primera línea.
El error más frecuente: el padre solo tiene un constructor con argumentos. El compilador reclama por un constructor que nunca escribiste. Se arregla llamando a super(marca) en la primera línea.
public class Vehiculo {protected String marca;public Vehiculo(String marca) { this.marca = marca; }// Al escribir este constructor, Vehiculo dejó de tener uno sin argumentos} public class Auto extends Vehiculo {public Auto() {// ERROR: Java intenta insertar super() y Vehiculo no tiene ese constructor}} javac Auto.javaAuto.java:8: error: constructor Vehiculo in class Vehiculo cannot be applied to given types; public Auto() { ^ required: String found: no arguments super también llama a la versión del padre de un método sobrescrito.
Así extendés el comportamiento en lugar de reemplazarlo.
super también llama a la versión del padre de un método sobrescrito. Así extendés el comportamiento en lugar de reemplazarlo.
@Overridepublic void arrancar() {super.arrancar(); // primero hace lo que hace todo vehículoSystem.out.println("...y activa el arranque sin llave.");} java MainEl vehículo arranca....y activa el arranque sin llave. Sobrescribir es redefinir un método heredado con la misma firma.
@Override no cambia la ejecución: le pide al compilador que lo verifique.
Sin la anotación, un parámetro de más crea un método nuevo y el bug es silencioso.
Sobrescribir es redefinir un método heredado con la misma firma. @Override no cambia la ejecución: le pide al compilador que lo verifique. Sin la anotación, un parámetro de más crea un método nuevo y el bug es silencioso.
public class Auto extends Vehiculo {@Overridepublic void arrancar(int velocidad) { // ← ERROR de compilación, y eso es bueno...}} javac Auto.javaAuto.java:3: error: method does not override or implement a method from a supertype @Override ^ Nombre y parámetros deben ser idénticos; el retorno puede ser un subtipo.
La visibilidad solo puede abrirse, nunca cerrarse: es la promesa del padre.
Las excepciones checked no se ensanchan; private, static y final no se sobrescriben.
Nombre y parámetros deben ser idénticos; el retorno puede ser un subtipo. La visibilidad solo puede abrirse, nunca cerrarse: es la promesa del padre. Las excepciones checked no se ensanchan; private, static y final no se sobrescriben.
Sobrecarga: varios métodos con el mismo nombre dentro de la misma clase.
El compilador elige mirando los tipos de los argumentos que escribiste.
Todo queda resuelto antes de ejecutar: no hay herencia en juego.
Sobrecarga: varios métodos con el mismo nombre dentro de la misma clase. El compilador elige mirando los tipos de los argumentos que escribiste. Todo queda resuelto antes de ejecutar: no hay herencia en juego.
Sobrescritura: un mismo método redefinido más abajo en la jerarquía.
La decide la JVM, mirando el objeto real que hay en el Heap.
Solo se sabe con el programa ya corriendo.
Sobrescritura: un mismo método redefinido más abajo en la jerarquía. La decide la JVM, mirando el objeto real que hay en el Heap. Solo se sabe con el programa ya corriendo.
El tipo de retorno no cuenta para la sobrecarga.
int calcular() y double calcular() no compilan juntos: ¿cuál elegir?
El tipo de retorno no cuenta para la sobrecarga. int calcular() y double calcular() no compilan juntos: ¿cuál elegir?
Una variable Vehiculo puede apuntar a cualquier objeto que sea un Vehiculo.
La variable vive en el Stack; el objeto, con sus capas heredadas, en el Heap.
Una variable Vehiculo puede apuntar a cualquier objeto que sea un Vehiculo. La variable vive en el Stack; el objeto, con sus capas heredadas, en el Heap.
El tipo de la variable decide qué métodos podés escribir: lo revisa el compilador.
El tipo del objeto decide qué código corre: lo resuelve la JVM en cada llamada.
Esas dos frases son, literalmente, la definición de polimorfismo.
El tipo de la variable decide qué métodos podés escribir: lo revisa el compilador. El tipo del objeto decide qué código corre: lo resuelve la JVM en cada llamada. Esas dos frases son, literalmente, la definición de polimorfismo.
v.arrancar(): el compilador comprueba que Vehiculo declare arrancar().
En ejecución, la JVM sigue la referencia y busca el método en el objeto real.
Empieza por Auto: ahí está la versión sobrescrita, y esa es la que corre.
v.arrancar(): el compilador comprueba que Vehiculo declare arrancar(). En ejecución, la JVM sigue la referencia y busca el método en el objeto real. Empieza por Auto: ahí está la versión sobrescrita, y esa es la que corre.
v.frenar(): Auto no lo sobrescribió, así que la búsqueda sigue hacia arriba.
Lo encuentra en Vehiculo y ejecuta esa versión heredada.
v.frenar(): Auto no lo sobrescribió, así que la búsqueda sigue hacia arriba. Lo encuentra en Vehiculo y ejecuta esa versión heredada.
v.abrirBaul() no compila: Vehiculo no declara abrirBaul().
Para usar lo propio de Auto hace falta un casteo, con red: instanceof.
Sin la comprobación, un casteo equivocado revienta con ClassCastException.
v.abrirBaul() no compila: Vehiculo no declara abrirBaul(). Para usar lo propio de Auto hace falta un casteo, con red: instanceof. Sin la comprobación, un casteo equivocado revienta con ClassCastException.
Un arreglo de Vehiculo guarda a la vez un Auto, una Moto y un Camión.
Cada casilla apunta a un objeto distinto, pero todas son de tipo Vehiculo.
Un arreglo de Vehiculo guarda a la vez un Auto, una Moto y un Camión. Cada casilla apunta a un objeto distinto, pero todas son de tipo Vehiculo.
Taller.revisar recorre la flota sin saber qué clase hay en cada casilla.
Cada objeto ejecuta SU propia versión de arrancar().
Es un solo bucle: no hay instanceof ni casteos.
Taller.revisar recorre la flota sin saber qué clase hay en cada casilla. Cada objeto ejecuta SU propia versión de arrancar(). Es un solo bucle: no hay instanceof ni casteos.
Mañana agregás Bicicleta extends Vehiculo y el Taller la maneja sin cambios.
Ese es el premio: código nuevo que se integra sin tocar el que ya funcionaba.
Mañana agregás Bicicleta extends Vehiculo y el Taller la maneja sin cambios. Ese es el premio: código nuevo que se integra sin tocar el que ya funcionaba.
Sin polimorfismo necesitás una cadena de instanceof que crece para siempre.
Y hay que editarla cada vez que aparece una clase nueva.
Con polimorfismo, cada clase sabe qué hacer y el bucle no cambia.
Sin polimorfismo necesitás una cadena de instanceof que crece para siempre. Y hay que editarla cada vez que aparece una clase nueva. Con polimorfismo, cada clase sabe qué hacer y el bucle no cambia.
public class Taller {// Este método no conoce Auto, Moto ni Camión. Y no necesita conocerlos.public void revisar(Vehiculo[] flota) {for (Vehiculo v : flota) {v.arrancar(); // cada objeto ejecuta SU propia versiónv.frenar();}}} Vehiculo[] flota = {new Auto("Toyota"),new Moto("Honda"),new Camion("Scania")};new Taller().revisar(flota); La herencia es la relación más fuerte entre dos clases: ata la subclase al padre.
Auto extends Motor no pasa la prueba: un Auto no es un Motor.
La herencia es la relación más fuerte entre dos clases: ata la subclase al padre. Auto extends Motor no pasa la prueba: un Auto no es un Motor.
Composición: un Auto tiene un Motor y le delega el trabajo.
motor.encender(): el Auto no hereda nada, solo le pide al motor.
Composición: un Auto tiene un Motor y le delega el trabajo. motor.encender(): el Auto no hereda nada, solo le pide al motor.
Podés cambiar el motor sin tocar una línea del Auto.
Y probar el Auto con un motor de mentira. La herencia no permite ninguna de las dos.
Podés cambiar el motor sin tocar una línea del Auto. Y probar el Auto con un motor de mentira. La herencia no permite ninguna de las dos.
Si una clase no debe extenderse, marcala con final y el compilador lo hace cumplir.
Lo mismo vale para un método: un final no se sobrescribe.
Si una clase no debe extenderse, marcala con final y el compilador lo hace cumplir. Lo mismo vale para un método: un final no se sobrescribe.
public final class Coordenada { ... } // nadie puede heredar de acá public class Cuenta {public final void acreditar(double monto) { ... } // este método no se sobrescribe} Aunque no escribas extends, toda clase de Java hereda de Object.
De ahí vienen métodos que ya usaste sin notarlo: toString(), equals() y hashCode().
Aunque no escribas extends, toda clase de Java hereda de Object. De ahí vienen métodos que ya usaste sin notarlo: toString(), equals() y hashCode().
Sin sobrescribir toString(), println(a) imprime la clase y un código hash.
La búsqueda sube hasta Object y ejecuta su versión: inútil para depurar.
Sin sobrescribir toString(), println(a) imprime la clase y un código hash. La búsqueda sube hasta Object y ejecuta su versión: inútil para depurar.
Sobrescribirlo cuesta dos líneas y te devuelve horas de depuración.
Ahora la búsqueda se detiene en Auto y el resultado se puede leer.
equals() y hashCode() tienen reglas propias: los verás en la lección 16.
Sobrescribirlo cuesta dos líneas y te devuelve horas de depuración. Ahora la búsqueda se detiene en Auto y el resultado se puede leer. equals() y hashCode() tienen reglas propias: los verás en la lección 16.
Sobrescribir cambiando los parámetros crea un método nuevo: poné siempre @Override.
Un constructor hijo sin super(...) falla si el padre no tiene constructor vacío.
Llamar a un método sobrescribible desde el constructor del padre deja campos sin inicializar.
Sobrescribir cambiando los parámetros crea un método nuevo: poné siempre @Override. Un constructor hijo sin super(...) falla si el padre no tiene constructor vacío. Llamar a un método sobrescribible desde el constructor del padre deja campos sin inicializar.
Castear sin instanceof termina en ClassCastException en ejecución.
Heredar solo para reutilizar código, sin un "es un", arma jerarquías rígidas: componé.
Y no confundas sobrecarga con sobrescritura: una es del compilador, la otra de la JVM.
Castear sin instanceof termina en ClassCastException en ejecución. Heredar solo para reutilizar código, sin un "es un", arma jerarquías rígidas: componé. Y no confundas sobrecarga con sobrescritura: una es del compilador, la otra de la JVM.
El desafío: una jerarquía de empleados con Empleado, Gerente y Vendedor.
Cada subclase sobrescribe calcularSalario() y las tres sobrescriben toString().
El desafío: una jerarquía de empleados con Empleado, Gerente y Vendedor. Cada subclase sobrescribe calcularSalario() y las tres sobrescriben toString().
Gerente suma un bono y Vendedor una comisión del 8 %, los dos con super.calcularSalario().
No repiten la lógica del sueldo base: la reutilizan y le suman lo suyo.
Gerente suma un bono y Vendedor una comisión del 8 %, los dos con super.calcularSalario(). No repiten la lógica del sueldo base: la reutilizan y le suman lo suyo.
public class Empleado {private final String nombre;private final double sueldoBase; public Empleado(String nombre, double sueldoBase) {this.nombre = nombre;this.sueldoBase = sueldoBase;} public double calcularSalario() { return sueldoBase; } @Overridepublic String toString() { return getClass().getSimpleName() + " " + nombre; }} public class Gerente extends Empleado {private final double bono; public Gerente(String nombre, double sueldoBase, double bono) {super(nombre, sueldoBase); // primera sentencia, obligatoriothis.bono = bono;} @Overridepublic double calcularSalario() {return super.calcularSalario() + bono; // extiende, no reemplaza}} public class Vendedor extends Empleado {private static final double COMISION = 0.08; // comisión del 8 %private final double ventasDelMes; public Vendedor(String nombre, double sueldoBase, double ventasDelMes) {super(nombre, sueldoBase);this.ventasDelMes = ventasDelMes;} @Overridepublic double calcularSalario() {return super.calcularSalario() + ventasDelMes * COMISION;}} Lo que hay que mirar es el bucle: no pregunta de qué tipo es cada empleado.
Si mañana agregás un Pasante, ese bucle sigue funcionando sin una sola modificación.
Lo que hay que mirar es el bucle: no pregunta de qué tipo es cada empleado. Si mañana agregás un Pasante, ese bucle sigue funcionando sin una sola modificación.
Empleado[] nomina = {new Empleado("Ana Torres", 800000),new Gerente("Luis Paz", 1500000, 400000),new Vendedor("Sofia Rios", 700000, 2500000)}; double total = 0;// Un solo bucle, sin instanceof y sin casteos:for (Empleado e : nomina) {double salario = e.calcularSalario();total += salario;System.out.printf("%-22s $ %,.2f%n", e, salario);}System.out.printf("%-22s $ %,.2f%n", "TOTAL", total); java MainNominaEmpleado Ana Torres $ 800,000.00Gerente Luis Paz $ 1,900,000.00Vendedor Sofia Rios $ 900,000.00TOTAL $ 3,600,000.00 extends solo si un X es un Y; la cadena de constructores sube con super y se ejecuta bajando.
Sobrecarga la decide el compilador, sobrescritura la JVM: la variable define qué podés llamar.
Preferí composición antes que herencia, y marcá con final lo que no debe extenderse.
extends solo si un X es un Y; la cadena de constructores sube con super y se ejecuta bajando. Sobrecarga la decide el compilador, sobrescritura la JVM: la variable define qué podés llamar. Preferí composición antes que herencia, y marcá con final lo que no debe extenderse.
Reforzá todo con programas completos en el repositorio del curso.
Clonalo, abrí l10_herencia_polimorfismo_y_sobrecarga y ejecutá cada uno mientras releés la lección.
Reforzá todo con programas completos en el repositorio del curso. Clonalo, abrí l10_herencia_polimorfismo_y_sobrecarga y ejecutá cada uno mientras releés la lección.