Clases Abstractas, Interfaces y Organización del Código
Respondé todas las preguntas y presioná Calificar para ver tu puntaje.
Respuesta correcta: Una clase abstracta representa un molde incompleto que puede compartir estado y código base; una interfaz es un contrato puro de capacidades que cualquier clase puede firmar.
¿Por qué? Una clase abstracta define una jerarquía conceptual de "es-un" con estado compartido (atributos de instancia) y código heredable. Una interfaz define un contrato de "sabe-hacer" enfocado en capacidades que clases no emparentadas pueden compartir.
new
Respuesta correcta: Verdadero
¿Por qué? Verdadero. Las clases abstractas pueden y suelen tener constructores (generalmente protected) para que las subclases inicialicen el estado común mediante super(...). Lo que está prohibido es invocar new ClaseAbstracta().
super(...)
new ClaseAbstracta()
Respuesta correcta: public static final
¿Por qué? En una interfaz, todas las variables son constantes: son implícitamente public, static y final. Las interfaces no pueden almacenar estado de instancia mutable.
public
static
final
implements
¿Por qué? Verdadero. Aunque Java no admite herencia múltiple de clases (extends), sí permite implementar cualquier cantidad de interfaces, lo que permite componer múltiples capacidades en una sola clase.
extends
Respuesta correcta: Falla en tiempo de compilación a menos que la propia subclase también sea declarada como abstract.
¿Por qué? Una clase concreta tiene la obligación contractual de implementar todos los métodos abstractos heredados. Si no lo hace, no puede ser instanciable y debe declararse también como abstract.
abstract
default
Respuesta correcta: Proveer una implementación base u opcional en la interfaz, permitiendo evolucionar contratos existentes sin romper las clases que ya los implementaban.
¿Por qué? Los métodos default permiten añadir nuevos métodos a interfaces ya publicadas con una implementación por defecto, evitando romper compatibilidad binaria con las clases clientes existentes.
Respuesta correcta: En la composición el ciclo de vida del objeto parte está estrictamente ligado al del objeto todo (si se destruye el todo, se destruye la parte); en la agregación los objetos tienen ciclos de vida independientes.
¿Por qué? La composición implica pertenencia fuerte y ciclo de vida dependiente (por ejemplo, una Casa y sus Habitaciones). La agregación es una relación débil donde las partes pueden existir independientemente (por ejemplo, un Departamento universitario y sus Profesores).
¿Por qué? Verdadero. Una interfaz puede heredar de una o más interfaces mediante extends (por ejemplo, public interface SubInterfaz extends InterfazA, InterfazB), acumulando sus contratos.
public interface SubInterfaz extends InterfazA, InterfazB
Respuesta correcta: Porque desacopla a los clientes de las implementaciones específicas, permitiendo intercambiar componentes y probarlos con facilidad sin modificar el código consumidor.
¿Por qué? "Programar contra una interfaz y no contra una implementación" es uno de los principios capitales de la ingeniería de software: reduce el acoplamiento y permite reemplazar implementaciones sin afectar a las clases que consumen el contrato.
Persona
public abstract void hablar();
Empleado extends Persona
hablar()
abstract class Persona { public abstract void hablar(); } class Empleado extends Persona { // no implementa hablar() }
Empleado
Respuesta correcta: Error de compilación: una subclase concreta debe implementar todos los métodos abstractos heredados o declararse también abstract.
¿Por qué? Un método abstracto es una obligación contractual. Toda subclase concreta debe sobrescribirlo; si no puede o no quiere, debe declararse también abstract y pasar la obligación a sus propias subclases.
Persona p = new Persona();
Respuesta correcta: Falso
¿Por qué? Falso. Una clase abstracta nunca puede instanciarse con new, sin importar cuántas subclases la implementen. Lo que sí es válido es Persona p = new Empleado();: la referencia es del tipo abstracto y el objeto de una subclase concreta.
Persona p = new Empleado();
main
Jefe
public static String tomarDecisiones()
ParaJefes
static String tomarDecisiones()
Jefe empleado = new Jefe(); System.out.println(empleado.tomarDecisiones());
Respuesta correcta: "Decisión postergada hasta la próxima reunión de equipo." (la versión estática de Jefe).
¿Por qué? Los métodos static de una interfaz no se heredan, así que no hay conflicto: Jefe solo ve su propio tomarDecisiones() estático. La versión de la interfaz solo se alcanzaría con ParaJefes.tomarDecisiones().
tomarDecisiones()
ParaJefes.tomarDecisiones()
Jefe.tomarDecisiones()
¿Por qué? Falso. Los métodos estáticos de una interfaz pertenecen únicamente a la interfaz y no se heredan. Se invocan siempre con su nombre: ParaJefes.tomarDecisiones(). Si Jefe no define uno propio, Jefe.tomarDecisiones() no compila.
class Empleado extends Persona
interface ParaJefes
class Jefe extends Empleado implements ParaJefes
Persona p = new Jefe();
ParaJefes pj = new Jefe();
Empleado e = new Jefe();
ParaJefes pj = new Empleado();
Respuesta correcta: ParaJefes pj = new Empleado();
¿Por qué? Jefe es una Empleado, una Persona y además cumple el contrato ParaJefes. En cambio Empleado no implementa ParaJefes, así que un Empleado no es un ParaJefes y el compilador rechaza la asignación.
public abstract String tomarDecisiones(String decision);
public abstract
¿Por qué? Verdadero. Los miembros de una interfaz son públicos por defecto y, si no tienen cuerpo, abstractos. Escribir public abstract es válido, pero innecesario; por eso las clases que lo implementan deben declarar el método como public.
pj.hablar();
ClassCastException
Respuesta correcta: Error de compilación: la referencia es de tipo ParaJefes, y ese tipo no declara hablar().
¿Por qué? El compilador solo permite invocar los métodos del tipo de la referencia, no los del objeto real. Para llamar a hablar() hay que usar una referencia Persona, Empleado o Jefe, o hacer un cast explícito.
Figura
Figura(String color)
abstract class Figura { String color; public Figura(String color) { this.color = color; } } class Circulo extends Figura { double radio; public Circulo(String color, double radio) { super(color); this.radio = radio; } }
super(color)
color
new Figura("Rojo")
Respuesta correcta: Lo ejecutan las subclases al llamar a super(color), para inicializar el estado común (como el color).
¿Por qué? Aunque la clase abstracta no se instancie directamente, sus subclases sí, y construir un Circulo implica construir primero su parte Figura. Por eso Circulo llama a super(color) en su constructor. Es una de las diferencias clave frente a una interfaz, que no tiene constructores.
Circulo
mostrarInformacion()
ParaMostrar
Figura f = new Circulo("Rojo", 5); f.mostrarInformacion();
¿Por qué? Verdadero. El compilador valida contra el tipo de la referencia (Figura), que no declara mostrarInformacion(). Para usarlo habría que declarar el método en Figura o hacer un cast a Circulo.
String mostrarCantLados()
Rectangulo
ParaMostrar[] figuras = { new Circulo("Rojo", 5), new Rectangulo("Azul", 4, 6) }; for (ParaMostrar f : figuras) { System.out.println(f.mostrarCantLados()); }
Respuesta correcta: 0 y luego 4, aunque la referencia sea de tipo ParaMostrar (polimorfismo).
¿Por qué? Se llama al método a través del contrato ParaMostrar, pero en ejecución cada objeto responde con su propia implementación: Circulo devuelve "0" y Rectangulo "4". Es polimorfismo por interfaz: el código que recorre el arreglo no sabe, ni necesita saber, qué figura concreta tiene.
class Rectangulo extends Figura, Marco implements ParaMostrar
Marco
¿Por qué? Falso. Java solo permite herencia simple de clases: una clase puede extender una única clase. En cambio, puede implementar tantas interfaces como necesite, como hace Rectangulo al extender Figura e implementar ParaMostrar.
ParaMostrar.mostrarCantLados()
class Circulo extends Figura implements ParaMostrar { String mostrarCantLados() { // sin public return "0"; } }
Respuesta correcta: Error de compilación: al implementar un método de interfaz no se puede reducir su visibilidad por debajo de public.
¿Por qué? Una sobrescritura puede ampliar la visibilidad pero nunca reducirla. Como el método de la interfaz es public, la implementación también debe serlo. Por eso, en la clase abstracta Figura un método de acceso de paquete puede sobrescribirse como public, pero no al revés.
WindowListener
WindowAdapter
Respuesta correcta: Evitar tener que escribir los métodos vacíos que no te interesan: extendés la clase y sobrescribís solo el que necesitás.
¿Por qué? Implementar WindowListener directamente obliga a escribir los siete métodos aunque solo te interese uno. Una clase adaptadora provee implementaciones vacías por defecto, y la subclase sobrescribe únicamente lo relevante, como windowActivated en EventosDeVentana.
windowActivated
EventosDeVentana
EventosDeVentana extends WindowAdapter
class EventosDeVentana extends WindowAdapter { @Override public void windowActivated(WindowEvent e) { System.out.println("VENTANA ACTIVA"); } }
¿Por qué? Falso. WindowAdapter ya implementa los siete métodos de WindowListener con cuerpo vacío, por lo que la subclase hereda esas implementaciones y puede sobrescribir solo los que necesite.
miMarco.addWindowListener(new EventosDeVentana());
addWindowListener
Object
JFrame
Respuesta correcta: Porque EventosDeVentana hereda de WindowAdapter, que implementa WindowListener; por lo tanto es un WindowListener (relación "es un").
¿Por qué? WindowAdapter implementa WindowListener, y EventosDeVentana extiende WindowAdapter, de modo que un EventosDeVentana es también un WindowListener. Es el mismo polimorfismo por interfaz que permite usar un Circulo donde se espera un ParaMostrar.
Puntaje: