← Volver a actividades
Autoevaluación

Autoevaluación: Lectura de Código con Clases Abstractas e Interfaces

Clases Abstractas, Interfaces y Organización del Código · 30 min aprox.

Respondé todas las preguntas y presioná Calificar para ver tu puntaje.

1. ¿Qué líneas del main impiden que este programa compile?
abstract class Mascota {
    private String nombre;

    public Mascota(String nombre) {
        this.nombre = nombre;
    }

    public abstract void emitirSonido();

    public String getNombre() {
        return nombre;
    }
}

class Gato extends Mascota {
    public Gato() {
        super("Gato");
    }

    @Override
    public void emitirSonido() {
        System.out.println("miau, miau, miau");
    }
}

public class Veterinaria {
    public static void main(String[] args) {
        Mascota[] refugio = new Mascota[3];   // línea A
        refugio[0] = new Gato();              // línea B
        Mascota otra = new Mascota("Tom");    // línea C
        refugio[0].emitirSonido();            // línea D
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Solo C: Mascota no se puede instanciar, aunque sí se puede usar como tipo de variables y de arrays.

¿Por qué? new Mascota[3] crea un array con tres referencias en null: no crea ningún objeto Mascota, así que es válido. La línea B guarda un Gato, que es una Mascota. La línea C intenta crear el objeto abstracto y javac responde Mascota is abstract; cannot be instantiated. El constructor de Mascota existe para que lo invoque super("Gato"), no para usarlo con new.

2. ¿Qué se imprime al ejecutar figura.describir()?
abstract class Figura {
    protected String color;

    public Figura(String color) {
        this.color = color;
    }

    abstract double calcularArea();

    abstract String mostrarInformacion();

    public void describir() {
        System.out.println(mostrarInformacion() + " | área: " + calcularArea());
    }
}

class Rectangulo extends Figura {
    private double ancho, alto;

    public Rectangulo(String color, double ancho, double alto) {
        super(color);
        this.ancho = ancho;
        this.alto = alto;
    }

    @Override
    double calcularArea() {
        return ancho * alto;
    }

    @Override
    String mostrarInformacion() {
        return "Rectángulo: " + color + " de " + ancho + " x " + alto;
    }
}

public class Main {
    public static void main(String[] args) {
        Figura figura = new Rectangulo("Azul", 4, 6);
        figura.describir();
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Rectángulo: Azul de 4.0 x 6.0 | área: 24.0

¿Por qué? describir() es un método concreto escrito una sola vez en la clase abstracta, y delega los pasos concretos en mostrarInformacion() y calcularArea(). Al ejecutarse, el objeto es un Rectangulo, así que se usan sus implementaciones. Como ancho y alto son double, se imprimen como 4.0, 6.0 y 24.0.

3. ¿Qué muestra la última línea del main?
abstract class Vehiculo {
    private double hp;
    private int stock;
    private double precio;

    public Vehiculo(double hp, int stock, double precio) {
        this.hp = hp;
        this.stock = stock;
        this.precio = precio;
    }

    public int getStock() {
        return stock;
    }

    public void vender() {
        this.stock--;
    }

    abstract String verCaracteristicas();
}

class Terrestre extends Vehiculo {
    private int ruedas;

    public Terrestre(double hp, int stock, double precio, int ruedas) {
        super(hp, stock, precio);
        this.ruedas = ruedas;
    }

    @Override
    String verCaracteristicas() {
        return "Ruedas: " + ruedas;
    }
}

class Acuatico extends Vehiculo {
    private String tipoCasco;

    public Acuatico(double hp, int stock, double precio, String tipoCasco) {
        super(hp, stock, precio);
        this.tipoCasco = tipoCasco;
    }

    @Override
    String verCaracteristicas() {
        return "Tipo de casco: " + tipoCasco;
    }
}

public class Main {
    public static void main(String[] args) {
        Vehiculo auto = new Terrestre(200, 10, 10000, 4);
        Vehiculo barco = new Acuatico(500, 5, 20000, "Lancha");

        auto.vender();
        auto.vender();
        barco.vender();

        System.out.println(auto.getStock() + " | " + barco.getStock() + " | " + barco.verCaracteristicas());
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: 8 | 4 | Tipo de casco: Lancha

¿Por qué? Una clase abstracta sí tiene estado de instancia: cada objeto recibe sus propios hp, stock y precio. auto arranca con 10 y vende dos veces (8), y barco arranca con 5 y vende una vez (4). vender() es un método concreto que se hereda tal cual y accede a stock desde la propia clase Vehiculo, por eso que sea private no impide usarlo. El texto final lo resuelve la implementación de Acuatico.

4. ¿Qué se imprime al recorrer el array medios?
interface Pagable {
    boolean pagar(double monto);
    boolean estaDisponible();

    default void pagarSiPuede(double monto) {
        if (estaDisponible()) {
            pagar(monto);
        } else {
            System.out.println("Medio de pago no disponible.");
        }
    }
}

class TarjetaCredito implements Pagable {
    private final String numero;
    private double limiteDisponible;

    public TarjetaCredito(String numero, double limiteDisponible) {
        this.numero = numero;
        this.limiteDisponible = limiteDisponible;
    }

    @Override
    public boolean pagar(double monto) {
        limiteDisponible -= monto;
        System.out.println("Pagado con tarjeta " + numero);
        return true;
    }

    @Override
    public boolean estaDisponible() {
        return limiteDisponible > 0;
    }
}

public class Main {
    public static void main(String[] args) {
        Pagable[] medios = { new TarjetaCredito("4417", 1000), new TarjetaCredito("9021", 0) };
        for (Pagable medio : medios) {
            medio.pagarSiPuede(500);
        }
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Pagado con tarjeta 4417 y luego Medio de pago no disponible.

¿Por qué? TarjetaCredito hereda pagarSiPuede de la interfaz sin tener que escribirlo. El método default llama a estaDisponible() y a pagar() del objeto real: la primera tarjeta tiene límite 1000 y cobra; la segunda tiene límite 0, así que estaDisponible() devuelve false y se imprime el aviso.

5. ¿Qué ocurre al compilar este programa con las líneas A y B?
interface ParaJefes {
    String tomarDecisiones(String decision);

    static String politica() {
        return "Decidir con datos";
    }
}

abstract class Persona {
    public abstract void hablar();
}

class Empleado extends Persona {
    @Override
    public void hablar() {
        System.out.println("Empleado");
    }
}

class Jefe extends Empleado implements ParaJefes {
    @Override
    public String tomarDecisiones(String decision) {
        return "El jefe decide: " + decision;
    }
}

public class Main {
    public static void main(String[] args) {
        Jefe jefe = new Jefe();
        System.out.println(ParaJefes.politica());   // línea A
        System.out.println(jefe.politica());        // línea B
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: La línea B no compila: los métodos static de una interfaz pertenecen a la interfaz y no se heredan, así que se invocan como ParaJefes.politica().

¿Por qué? Un método static de una interfaz es una utilidad de la interfaz, no de las clases que la firman. ParaJefes.politica() es la forma correcta de invocarlo. Jefe no lo hereda, por eso jefe.politica() produce error: cannot find symbol. Desde Java 8, las interfaces sí admiten métodos con cuerpo (default y static).

6. ¿Qué ocurre al compilar y ejecutar este código?
interface ParaJefes {
    String tomarDecisiones(String decision);
}

class Jefe implements ParaJefes {
    String tomarDecisiones(String decision) {
        return "El jefe decide: " + decision;
    }
}

public class Main {
    public static void main(String[] args) {
        ParaJefes jefe = new Jefe();
        System.out.println(jefe.tomarDecisiones("contratar"));
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: No compila: los métodos de una interfaz son implícitamente public y Jefe no puede implementarlo con menor visibilidad.

¿Por qué? En una interfaz los métodos son siempre public, aunque no se escriba. Al omitir public, Jefe declara el método con visibilidad de paquete, y javac lo rechaza con attempting to assign weaker access privileges; was public. Se arregla declarando public String tomarDecisiones(...). @Override es recomendable, pero no obligatorio.

7. Las variables pato y n apuntan al mismo objeto. ¿Qué ocurre al compilar este main?
interface Nadable {
    void nadar();
}

interface Volable {
    void volar();
}

class Ave {
}

class Pato extends Ave implements Nadable, Volable {
    @Override public void nadar() { System.out.println("El pato nada."); }
    @Override public void volar() { System.out.println("El pato vuela."); }
}

public class Main {
    public static void main(String[] args) {
        Pato pato = new Pato();
        Nadable n = pato;
        n.nadar();   // línea A
        n.volar();   // línea B
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: La línea B no compila: a través de una variable Nadable solo se ven los métodos que declara Nadable, aunque el objeto también sepa volar.

¿Por qué? Un mismo objeto puede verse desde ángulos distintos según el tipo de la variable. Vista como Nadable, solo expone nadar(); el compilador revisa el tipo de la variable y responde cannot find symbol para volar(). Para volar hay que mirarlo como Volable (o como Pato).

8. ¿Cuál de las dos declaraciones del main no compila?
interface Nadable {
    void nadar();
}

class Ave {
}

class Pato extends Ave implements Nadable {
    @Override public void nadar() { System.out.println("El pato nada."); }
}

class Submarino implements Nadable {
    @Override public void nadar() { System.out.println("El submarino se sumerge."); }
}

public class Main {
    public static void main(String[] args) {
        Nadable[] grupo = { new Pato(), new Submarino() };   // línea A
        Ave[] aves = { new Pato(), new Submarino() };        // línea B
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Solo la línea B: Submarino no hereda de Ave, y lo único que comparte con Pato es la interfaz Nadable.

¿Por qué? Pato y Submarino no comparten ningún ancestro, pero los dos firman Nadable: por eso conviven en un Nadable[]. En cambio, un Submarino no es un Ave, y javac responde incompatible types: Submarino cannot be converted to Ave. La interfaz es lo único que tienen en común, y alcanza.

9. NotificadorBase no implementa enviar(). ¿Qué ocurre al compilar y ejecutar este programa?
interface Notificador {
    void enviar(String mensaje);
    String canal();
}

abstract class NotificadorBase implements Notificador {
    @Override
    public String canal() {
        return "genérico";
    }
    // enviar() no se implementa acá
}

class NotificadorEmail extends NotificadorBase {
    @Override
    public void enviar(String mensaje) {
        System.out.println("[" + canal() + "] " + mensaje);
    }

    @Override
    public String canal() {
        return "email";
    }
}

public class Main {
    public static void main(String[] args) {
        Notificador notificador = new NotificadorEmail();
        notificador.enviar("Hola");
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Compila e imprime [email] Hola.

¿Por qué? Es el patrón que combina interfaz y clase abstracta: NotificadorBase firma el contrato, resuelve una parte y, por ser abstracta, puede dejar enviar() pendiente para sus subclases. NotificadorEmail completa enviar() y redefine canal(). Como el objeto real es un NotificadorEmail, canal() devuelve email.

10. ¿Qué ocurre al compilar Auditoria.java?
import java.util.Date;
import java.sql.Date;

public class Auditoria {
    private Date fechaOperacion = new Date();
}
Correcto Incorrecto Sin responder

Respuesta correcta: No compila: no se pueden importar dos clases con el mismo nombre simple. Hay que importar una y escribir el nombre completo (FQCN) de la otra.

¿Por qué? java.util.Date y java.sql.Date viven en paquetes distintos, pero comparten el nombre simple Date. Java no admite esa ambigüedad y rechaza el segundo import. La solución es importar la que más se usa y escribir el FQCN de la otra donde haga falta, por ejemplo private java.sql.Date fechaPersistenciaBD;.

11. Las tres clases están en archivos separados, como indica el comentario de cada bloque. ¿Qué ocurre al compilarlas juntas?
// Archivo universidad/modelos/Persona.java
package universidad.modelos;

class Persona {
    private String nombre;

    public Persona(String nombre) {
        this.nombre = nombre;
    }

    public String getNombre() {
        return nombre;
    }
}

// Archivo universidad/modelos/Estudiante.java
package universidad.modelos;

public class Estudiante extends Persona {
    private String carrera;

    public Estudiante(String nombre, String carrera) {
        super(nombre);
        this.carrera = carrera;
    }

    public String getCarrera() {
        return carrera;
    }
}

// Archivo universidad/servicios/Registro.java
package universidad.servicios;

import universidad.modelos.Estudiante;
import universidad.modelos.Persona;

public class Registro {
    public void listar(Estudiante[] estudiantes) {
        for (Estudiante e : estudiantes) {
            System.out.println(e.getNombre() + " - " + e.getCarrera());
        }
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Falla import universidad.modelos.Persona: Persona es *package-private* y no se puede usar desde otro paquete.

¿Por qué? Persona no tiene modificador, así que solo es visible dentro de universidad.modelos. Para el compilador, universidad.servicios es otro paquete, aunque comparta el prefijo, y responde Persona is not public in universidad.modelos; cannot be accessed from outside package. Si se quita ese import, todo compila: Estudiante es pública y getNombre() es un método public que hereda de Persona.

12. Analizá cómo obtiene sus partes cada clase. ¿Qué relación modela Libro con Pagina y cuál Biblioteca con Libro?
import java.util.Arrays;

class Pagina {
    private final int numero;

    Pagina(int numero) {
        this.numero = numero;
    }
}

class Libro {
    private final Pagina[] paginas;

    public Libro(int cantidadPaginas) {
        paginas = new Pagina[cantidadPaginas];
        for (int i = 0; i < cantidadPaginas; i++) {
            paginas[i] = new Pagina(i + 1);
        }
    }

    public int cantidadPaginas() {
        return paginas.length;
    }
}

class Biblioteca {
    private final Libro[] libros;

    public Biblioteca(Libro[] libros) {
        this.libros = Arrays.copyOf(libros, libros.length);
    }
}

public class Main {
    public static void main(String[] args) {
        Libro[] libros = { new Libro(120), new Libro(80) };
        Biblioteca biblioteca = new Biblioteca(libros);
        System.out.println(libros[0].cantidadPaginas());
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Libro–Pagina es composición y Biblioteca–Libro es agregación.

¿Por qué? Libro crea sus páginas en su propio constructor y no las expone: las páginas no existen fuera del libro, es composición. Biblioteca recibe libros que ya existían afuera (el main los sigue usando después), así que es agregación. final solo impide reasignar el array, no define el tipo de relación.