7¿Qué cuatro principios de POO soporta Java?
Java soporta encapsulation, abstraction, inheritance y polymorphism. Encapsulation oculta el estado interno detrás de una API pública. Abstraction se centra en el comportamiento esencial. Inheritance crea un nuevo tipo a partir de uno existente. Polymorphism permite trabajar con distintas implementaciones mediante un contrato común. En la práctica, composition suele ser preferible a inheritance porque reduce el acoplamiento.
interface PaymentService {
void pay(BigDecimal amount);
}
class CardPaymentService implements PaymentService {
@Override
public void pay(BigDecimal amount) {
// payment implementation
}
}
8¿En qué se diferencian method overloading y overriding?
Overloading significa que varios métodos tienen el mismo nombre pero parámetros distintos; el compilador elige el método según los tipos estáticos de los argumentos. Overriding significa que una subclass sustituye la implementación de un instance method de la parent class; runtime dispatch elige el método según el tipo real del objeto. Los static methods se ocultan, no se sobrescriben, y los private methods no se sobrescriben porque no se heredan como miembros accesibles.
void send(String message) {}
void send(String message, int priority) {}
class Animal {
void speak() { System.out.println("Animal"); }
}
class Dog extends Animal {
@Override
void speak() { System.out.println("Dog"); }
}
9¿En qué se diferencia un interface de una abstract class?
Un interface define un contrato y puede contener abstract methods, default methods, static methods, constants y private helpers. Una abstract class además puede tener estado de instancia, constructores, protected fields, implementación compartida y métodos abstractos o concretos. Una clase solo puede extend una class, pero puede implementar múltiples interfaces. Usa interface para un contrato independiente y abstract class para tipos cercanos con implementación y estado compartidos.
interface Repository<T> {
Optional<T> findById(long id);
}
10¿Qué significa la palabra clave final?
Una variable final solo puede asignarse una vez, pero una referencia final no vuelve inmutable al objeto referenciado. Un método final no puede sobrescribirse. Una clase final no puede extenderse. final comunica intención y limita cambios de referencia o herencia, pero por sí solo no proporciona un modelo immutable completo ni thread safety.
final int maxAttempts = 3;
final List<String> names = new ArrayList<>();
names.add("Alice"); // allowed
public final void validate() {}
public final class Token {}
11¿Qué es un record en Java y cuándo usarlo?
Un record es una forma compacta de declarar un data carrier. El compilador crea private final fields, accessors, constructor, equals, hashCode y toString. Los records son final y encajan bien con DTOs, commands, events, results de cálculo, keys y values. Un record ofrece shallow immutability: si un componente contiene una mutable list, esa list aún puede cambiar, por lo que puede hacer falta defensive copy.
public record User(long id, String name) {}
public record Order(List<String> items) {
public Order {
items = List.copyOf(items);
}
}
12¿Qué es un immutable object y cómo se crea?
Un immutable object no cambia su estado observable después de crearse. Normalmente la class se hace final, los fields private final, no se exponen setters, el estado se inicializa completamente en el constructor y no se filtran mutable internals. Para inputs y outputs mutables se usan defensive copies. Los immutable objects son más fáciles de razonar, más seguros como map keys y más sencillos de compartir entre threads.
public final class User {
private final String name;
private final List<String> roles;
public User(String name, List<String> roles) {
this.name = name;
this.roles = List.copyOf(roles);
}
public List<String> getRoles() {
return roles;
}
}