Unidad 10

Utilización avanzada
de clases

Contenidos

Parte 1: Relaciones entre clases. Composición de clases 3

Parte 2: Herencia. Concepto y tipos (simple y múltiple). 9
Parte 3: Superclases y subclases. 14
Parte 4: Constructores y herencia. 20
Parte 5: Modificadores en clases, atributos y métodos. 26
Parte 6: Sobreescritura de métodos. 33
Parte 7: Clases y métodos abstractos y finales 40
Parte 8: Interfaces. Clases abstractas vs. Interfaces. 47
Conclusión del Bloque: Utilización avanzada de clases 55
 Parte 1: Relaciones entre clases. Composición de clases
Utilización avanzada de clases

Parte 1: Relaciones entre clases. Composición de clases

1. Introducción a las Relaciones entre Clases

En la Programación Orientada a Objetos (POO), las clases no son entidades aisladas; interactúan entre sí para modelar
sistemas reales. Estas interacciones se denominan relaciones entre clases y pueden clasificarse en:

1. Asociación: Una clase utiliza o conoce a otra clase.

2. Composición: Una clase está formada por una o más instancias de otras clases.
3. Agregación: Similar a la composición, pero las partes pueden existir independientemente.
4. Herencia: Una clase hereda atributos y métodos de otra clase.

1.1. Asociación

La asociación representa una relación entre dos clases donde una clase utiliza a otra.

3
 Parte 1: Relaciones entre clases. Composición de clases
Utilización avanzada de clases

Ejemplo de Asociación

public class Profesor {

private String nombre;
public Profesor(String nombre) {
[Link] = nombre;
}
public String getNombre() {
return nombre;
}
}
public class Curso {
private String nombreCurso;
private Profesor profesor;
public Curso(String nombreCurso, Profesor profesor) {
[Link] = nombreCurso;
[Link] = profesor;
}
public void mostrarInformacion() {
[Link](“Curso: “ + nombreCurso);
[Link](“Profesor: “ + [Link]());
}
}
public class Main {
public static void main(String[] args) {
Profesor profesor1 = new Profesor(“Juan Pérez”);
Curso curso1 = new Curso(“Matemáticas”, profesor1);
[Link]();
}
}

4
 Parte 1: Relaciones entre clases. Composición de clases
Utilización avanzada de clases

Salida:

Curso: Matemáticas
Profesor: Juan Pérez

1.2. Composición

La composición es una relación ”tiene un” en la que una clase contiene una o más instancias de otra clase como parte
de su estado interno. Si el objeto “contenedor” se destruye, también lo hacen las partes.

Ejemplo de Composición

public class Motor {

private String tipo;
public Motor(String tipo) {
[Link] = tipo;
}
public String getTipo() {
return tipo;
}
}
public class Coche {
private String marca;
private Motor motor;
public Coche(String marca, Motor motor) {
[Link] = marca;
[Link] = motor;
}
public void mostrarInformacion() {
[Link](“Marca: “ + marca);
[Link](“Motor: “ + [Link]());
}
}
public class Main {
public static void main(String[] args) {
Motor motor1 = new Motor(“Eléctrico”);
Coche coche1 = new Coche(“Tesla”, motor1);
[Link]();
}
}

5
 Parte 1: Relaciones entre clases. Composición de clases
Utilización avanzada de clases

Salida:

Marca: Tesla
Motor: Eléctrico

1.3. Agregación

La agregación también es una relación “tiene un”, pero las partes pueden existir de forma independiente al todo.

Ejemplo de Agregación

public class Autor {

private String nombre;
public Autor(String nombre) {
[Link] = nombre;
}
public String getNombre() {
return nombre;
}
}
public class Libro {
private String titulo;
private Autor autor;
public Libro(String titulo, Autor autor) {
[Link] = titulo;
[Link] = autor;
}
public void mostrarInformacion() {
[Link](“Título: “ + titulo);
[Link](“Autor: “ + [Link]());
}
}
public class Main {
public static void main(String[] args) {
Autor autor1 = new Autor(“Gabriel García Márquez”);
Libro libro1 = new Libro(“Cien años de soledad”, autor1);
[Link]();
}
}

6
 Parte 1: Relaciones entre clases. Composición de clases
Utilización avanzada de clases

Salida:

Título: Cien años de soledad

Autor: Gabriel García Márquez

1.4. Diferencias entre Composición y Agregación

Aspecto Composición Agregación

Dependencia Las partes dependen del todo. Las partes pueden existir indepen-
dientemente.
Ejemplo Motor en un coche. Autor de un libro.
Representación UML Línea con rombo lleno. Línea con rombo vacío.

1.5. Ventajas de las Relaciones entre Clases

1. Reutilización del Código: Permite utilizar componentes existentes en nuevas clases.

2. Modularidad: Cada clase tiene una responsabilidad clara y única.
3. Flexibilidad: Facilita la implementación de sistemas complejos.

2. Ejercicio Guiado

Problema

1. Crea una clase Direccion con los atributos calle, ciudad y código postal.
2. Crea una clase Persona que tenga un atributo nombre y una composición con la clase Direccion.
3. Escribe un método en Persona que muestre la información completa de la persona, incluyendo su dirección.

7
 Parte 1: Relaciones entre clases. Composición de clases
Utilización avanzada de clases

3. Preguntas de Evaluación

1. ¿Qué tipo de relación representa una composición?

a) “Es un”.
b) “Tiene un”.
c) “Puede ser”.
d) “Usa un”.

2. ¿Cuál es la principal diferencia entre composición y agregación?

a) En composición, las partes son independientes del todo.

b) En agregación, las partes dependen del todo.
c) En composición, las partes no existen sin el todo.
d) Ninguna de las anteriores.

3. ¿Qué palabra clave se utiliza para crear una relación entre clases en Java?

a) class.
b) new.
c) Ninguna, las relaciones se crean mediante atributos.
d) extend.

8
 Parte 2: Herencia. Concepto y tipos (simple y múltiple).
Utilización avanzada de clases

Parte 2: Herencia. Concepto y tipos (simple y múltiple).

La herencia es uno de los pilares fundamentales de la Programación Orientada a Objetos (POO). Permite que una clase
(subclase o clase hija) herede atributos y métodos de otra clase (superclase o clase padre), promoviendo la reutiliza-
ción del código y la extensibilidad.

1. Concepto de Herencia

1. Definición:

La herencia establece una relación ”es un” entre una clase base (superclase) y una clase derivada (subclase).

• La subclase hereda los atributos y métodos de la superclase.

• Puede añadir nuevos métodos y atributos propios.
• Puede sobrescribir métodos heredados para cambiar su comportamiento.

2. Palabra Clave:

En Java, se utiliza la palabra clave extends para implementar herencia.

Ejemplo de Herencia

public class Animal {

public void comer() {
[Link](“Este animal está comiendo.”);
}
}
public class Perro extends Animal {
public void ladrar() {
[Link](“El perro está ladrando.”);
}
}
public class Main {
public static void main(String[] args) {
Perro miPerro = new Perro();
// Métodos heredados
[Link]();
// Métodos propios
[Link]();
}
}

9
 Parte 2: Herencia. Concepto y tipos (simple y múltiple).
Utilización avanzada de clases

Salida:

Este animal está comiendo.

El perro está ladrando.

2. Tipos de Herencia

2.1. Herencia Simple

En la herencia simple, una clase hereda de una sola clase base. Java admite este tipo de herencia de forma nativa.

Ejemplo de Herencia Simple

public class Vehiculo {

public void mover() {
[Link](“El vehículo se está moviendo.”);
}
}
public class Coche extends Vehiculo {
public void encenderLuces() {
[Link](“Las luces del coche están encendidas.”);
}
}
public class Main {
public static void main(String[] args) {
Coche miCoche = new Coche();
[Link](); // Método heredado
[Link](); // Método propio
}
}

Salida:

El vehículo se está moviendo.

Las luces del coche están encendidas.

2.2. Herencia Múltiple

Java no admite herencia múltiple directa para evitar ambigüedades (problema del diamante). Sin embargo, es posible
implementarla de manera indirecta mediante el uso de interfaces.

10
 Parte 2: Herencia. Concepto y tipos (simple y múltiple).
Utilización avanzada de clases

Ejemplo de Herencia Múltiple con Interfaces

interface Volador {
void volar();
}
interface Nadador {
void nadar();
}
public class Pato implements Volador, Nadador {
public void volar() {
[Link](“El pato está volando.”);
}
public void nadar() {
[Link](“El pato está nadando.”);
}
}
public class Main {
public static void main(String[] args) {
Pato miPato = new Pato();
[Link]();
[Link]();
}
}

Salida:

El pato está volando.

El pato está nadando.

3. Ventajas y Desventajas de la Herencia

Ventajas Desventajas
Reutilización del Código: Las subclases pueden aprove- Acoplamiento: Cambios en la superclase pueden afectar
char el código de la superclase. a las subclases.
Extensibilidad: Se pueden añadir funcionalidades a través Rigidez: Puede ser difícil modificar jerarquías complejas.
de nuevas subclases.
Facilidad de Mantenimiento: El código común se centrali- Sobrecarga: Una jerarquía muy profunda puede complicar
za en la superclase. la comprensión.

11
 Parte 2: Herencia. Concepto y tipos (simple y múltiple).
Utilización avanzada de clases

4. Consideraciones en la Herencia

1. Acceso a Miembros de la Superclase:

• Los miembros con acceso public y protected son accesibles en la subclase.

• Los miembros private no son accesibles directamente, pero pueden ser accedidos mediante métodos de la
superclase.

2. Jerarquías de Herencia:

• Se recomienda mantener jerarquías simples y claras.

• Una jerarquía profunda puede dificultar la comprensión y mantenimiento del código.

5. Ejercicio Guiado

Problema

1. Crea una superclase Empleado con atributos:

• nombre (String), edad (int) y salario (double).

• Método mostrarInformacion() que imprima todos los atributos.

2. Crea una subclase Gerente que herede de Empleado:

• Añade el atributo departamento (String).

• Sobrescribe el método mostrarInformacion() para incluir el departamento.

3. En la clase Main, crea objetos de ambas clases y prueba sus métodos.

12
 Parte 2: Herencia. Concepto y tipos (simple y múltiple).
Utilización avanzada de clases

6. Preguntas de Evaluación

1. ¿Qué palabra clave se utiliza para implementar herencia en Java?

a) extends
b) implements
c) inherits
d) Ninguna de las anteriores

2. ¿Qué diferencia existe entre herencia simple y múltiple?

a) La herencia simple permite heredar de varias clases.

b) La herencia múltiple es posible en Java directamente.
c) La herencia múltiple usa interfaces para evitar ambigüedades.
d) La herencia simple no existe en Java.

3. ¿Por qué Java no admite herencia múltiple directa?

a) Para mejorar la legibilidad del código.

b) Para evitar el problema del diamante.
c) Porque es innecesaria en Java.
d) Porque no se permite heredar de interfaces.

4. ¿Qué tipo de miembros de una superclase no son accesibles directamente en una subclase?

a) public
b) protected
c) private
d) Todos son accesibles.

13
 Parte 3: Superclases y subclases.
Utilización avanzada de clases

Parte 3: Superclases y subclases.

En el contexto de la Programación Orientada a Objetos (POO), las superclases y subclases son conceptos fundamen-
tales que reflejan las relaciones jerárquicas entre clases.

1. Concepto de Superclase

La superclase (también conocida como clase base o clase padre) es una clase que provee atributos y métodos que
pueden ser heredados por otras clases.

1. Definición:

• Una superclase contiene la funcionalidad común que será compartida con sus subclases.
• Se define como cualquier clase que es heredada por otra clase.

2. Características:

• Puede tener métodos y atributos comunes.

• Puede definir métodos que las subclases deben sobrescribir.
• Se utiliza para evitar duplicación de código.

Ejemplo de Superclase

java
Copiar código
public class Animal {
protected String nombre;
public Animal(String nombre) {
[Link] = nombre;
}
public void comer() {
[Link](nombre + “ está comiendo.”);
}
}

2. Concepto de Subclase

La subclase (también conocida como clase derivada o clase hija) es una clase que hereda atributos y métodos de la
superclase.

1. Definición:

• Una subclase puede extender la funcionalidad de la superclase.

14
 Parte 3: Superclases y subclases.
Utilización avanzada de clases

• Puede sobrescribir métodos de la superclase para cambiar su comportamiento.

2. Características:

• Puede añadir atributos y métodos propios.

• Utiliza la palabra clave extends para establecer la relación de herencia.

Ejemplo de Subclase

public class Perro extends Animal {

public Perro(String nombre) {
super(nombre); // Llama al constructor de la superclase
}
public void ladrar() {
[Link](nombre + “ está ladrando.”);
}
}

3. Relación entre Superclases y Subclases

La relación entre una superclase y una subclase se describe como una relación ”es un” (is-a relationship).

1. Subclase es un tipo especializado de la superclase.

Ejemplo: Un Perro es un Animal.

2. La subclase hereda las propiedades y métodos de la superclase, pero también puede:

• Definir nuevos métodos y atributos.

• Sobrescribir métodos de la superclase.

4. Uso de super en Subclases

La palabra clave super se utiliza en subclases para:

1. Llamar al constructor de la superclase.

2. Acceder a métodos o atributos de la superclase.

15
 Parte 3: Superclases y subclases.
Utilización avanzada de clases

Ejemplo: Uso de super

public class Animal {

protected String nombre;
public Animal(String nombre) {
[Link] = nombre;
}
public void dormir() {
[Link](nombre + “ está durmiendo.”);
}
}
public class Gato extends Animal {
public Gato(String nombre) {
super(nombre); // Llama al constructor de Animal
}
public void dormir() {
[Link](); // Llama al método dormir de la superclase
[Link](nombre + “ está soñando.”);
}
}
public class Main {
public static void main(String[] args) {
Gato miGato = new Gato(“Luna”);
[Link]();
}
}

Salida:

Luna está durmiendo.

Luna está soñando.

5. Sobrecarga y Sobrescritura

1. Sobrecarga de Métodos:

• Múltiples métodos con el mismo nombre pero diferentes parámetros en la misma clase o subclase.

2. Sobrescritura de Métodos:

• La subclase redefine un método de la superclase para cambiar su comportamiento.

• Usa la anotación @Override.

16
 Parte 3: Superclases y subclases.
Utilización avanzada de clases

Ejemplo de Sobrescritura

public class Animal {

public void sonido() {
[Link](“El animal hace un sonido.”);
}
}
public class Perro extends Animal {
@Override
public void sonido() {
[Link](“El perro ladra.”);
}
}
public class Main {
public static void main(String[] args) {
Perro miPerro = new Perro();
[Link]();
}
}

Salida:

El perro ladra.

6. Ventajas de Superclases y Subclases

Ventajas Descripción
Reutilización del Código La subclase aprovecha el código de la superclase.
Extensibilidad Es fácil añadir nuevas funcionalidades en subclases.
Centralización de Funcionalidades Comunes Reduce duplicación y facilita el mantenimiento.

17
 Parte 3: Superclases y subclases.
Utilización avanzada de clases

7. Ejercicio Guiado

Problema

1. Define una superclase Vehiculo con atributos:

• marca y velocidadMaxima.
• Método mostrarInformacion() para imprimir los atributos.

2. Define una subclase Coche que:

• Herede de Vehiculo.
• Añada un atributo tipoCombustible.
• Sobrescriba el método mostrarInformacion() para incluir el tipo de combustible.

3. En la clase principal, crea un objeto de la clase Coche e imprime su información.

18
 Parte 3: Superclases y subclases.
Utilización avanzada de clases

8. Preguntas de Evaluación

1. ¿Qué relación describe la herencia entre una superclase y una subclase?

a) “Tiene un”.
b) “Es un”.
c) “Usa un”.
d) Ninguna de las anteriores.

2. ¿Para qué se utiliza la palabra clave super?

a) Llamar al constructor de la subclase.

b) Sobrescribir métodos.
c) Acceder al constructor o métodos de la superclase.
d) Ninguna de las anteriores.

3. ¿Qué permite la sobrescritura de métodos?

a) Reutilizar código sin cambiarlo.

b) Cambiar el comportamiento de un método heredado.
c) Crear múltiples versiones de un método.
d) Definir un método privado.

4. ¿Qué ocurre si una subclase no llama explícitamente al constructor de la superclase?

a) Lanza un error.
b) Se llama al constructor por defecto de la superclase.
c) No se inicializa el objeto.
d) Se ejecuta el método toString().

19
 Parte 4: Constructores y herencia.
Utilización avanzada de clases

Parte 4: Constructores y herencia.

Los constructores desempeñan un papel crucial en la inicialización de objetos en Java. Cuando se combina con heren-
cia, los constructores permiten inicializar tanto los atributos de la superclase como los de la subclase, asegurando que
los objetos derivados estén completamente preparados para su uso.

1. ¿Qué es un Constructor?

Un constructor es un método especial que:

1. Se ejecuta automáticamente cuando se crea un objeto.

2. Tiene el mismo nombre que la clase.
3. No tiene un valor de retorno, ni siquiera void.
4. Se utiliza para inicializar los atributos de una clase.

Tipos de Constructores

1. Constructor por Defecto:

• Generado automáticamente si no se declara un constructor en la clase.

• No recibe parámetros.

public class Persona {

public Persona() {
[Link](“Constructor por defecto invocado”);
}
}

2. Constructor Parametrizado:

• Recibe parámetros para inicializar los atributos al momento de crear el objeto.

public class Persona {

private String nombre;
public Persona(String nombre) {
[Link] = nombre;
}
}

2. Constructores en Herencia

Cuando una subclase hereda de una superclase:

1. El constructor de la superclase se invoca automáticamente antes de que se ejecute el constructor de la subclase.

20
 Parte 4: Constructores y herencia.
Utilización avanzada de clases

2. La palabra clave super se utiliza para invocar explícitamente un constructor específico de la superclase.

Invocación Implícita del Constructor

Si no se llama explícitamente al constructor de la superclase, Java invoca el constructor por defecto de la superclase.

Ejemplo

public class Animal {

public Animal() {
[Link](“Constructor de Animal”);
}
}
public class Perro extends Animal {
public Perro() {
[Link](“Constructor de Perro”);
}
}
public class Main {
public static void main(String[] args) {
Perro miPerro = new Perro();
}
}

Salida:

Constructor de Animal
Constructor de Perro

Invocación Explícita del Constructor con super

Si la superclase no tiene un constructor por defecto o deseas invocar un constructor específico, debes usar super.

21
 Parte 4: Constructores y herencia.
Utilización avanzada de clases

Ejemplo

public class Animal {

private String especie;
public Animal(String especie) {
[Link] = especie;
[Link](“Especie: “ + especie);
}
}
public class Perro extends Animal {
public Perro(String especie) {
super(especie); // Llama al constructor de Animal
[Link](“Es un perro.”);
}
}
public class Main {
public static void main(String[] args) {
Perro miPerro = new Perro(“Canino”);
}
}

Salida:

Especie: Canino
Es un perro.

Constructor Parametrizado en la Superclase y Subclase

Cuando tanto la superclase como la subclase tienen constructores parametrizados, se pueden combinar para inicializar
atributos en ambos niveles.

22
 Parte 4: Constructores y herencia.
Utilización avanzada de clases

Ejemplo

public class Empleado {

protected String nombre;
public Empleado(String nombre) {
[Link] = nombre;
}
}
public class Gerente extends Empleado {
private String departamento;
public Gerente(String nombre, String departamento) {
super(nombre); // Llama al constructor de Empleado
[Link] = departamento;
}
public void mostrarInformacion() {
[Link](“Nombre: “ + nombre);
[Link](“Departamento: “ + departamento);
}
}
public class Main {
public static void main(String[] args) {
Gerente gerente = new Gerente(“Laura”, “Recursos Humanos”);
[Link]();
}
}

Salida:

Nombre: Laura
Departamento: Recursos Humanos

3. Reglas Importantes sobre Constructores y Herencia

1. La superclase debe tener un constructor accesible:

• Si no tiene un constructor por defecto, debe llamarse explícitamente uno de sus constructores parametrizados.

2. La palabra clave super:

• Debe ser la primera línea del constructor de la subclase si se utiliza.

• No puede coexistir con this en el mismo constructor.

23
 Parte 4: Constructores y herencia.
Utilización avanzada de clases

3. Constructores no se heredan:

• Aunque los métodos se heredan, los constructores no lo hacen. Las subclases deben definir sus propios cons-
tructores.

4. Beneficios de Constructores en Herencia

1. Inicialización Completa:

Garantiza que tanto los atributos de la superclase como los de la subclase estén correctamente inicializados.

2. Evita Duplicación de Código:

Centraliza la inicialización de atributos comunes en la superclase.

3. Flexibilidad:

Permite personalizar la inicialización en diferentes niveles de la jerarquía de herencia.

5. Ejercicio Guiado

Problema

1. Crea una superclase Vehiculo con:

• Atributos: marca (String) y velocidadMaxima (int).

• Constructor parametrizado para inicializar estos atributos.

2. Crea una subclase Coche que:

• Añada el atributo numeroPuertas (int).

• Use super para inicializar los atributos heredados.

3. Implementa un método mostrarInformacion() en ambas clases para mostrar los detalles completos del objeto.

24
 Parte 4: Constructores y herencia.
Utilización avanzada de clases

6. Preguntas de Evaluación

1. ¿Qué palabra clave se utiliza para invocar un constructor de la superclase?

a) this
b) super
c) extends
d) Ninguna de las anteriores

2. ¿Qué ocurre si una subclase no llama explícitamente al constructor de la superclase?

a) Se llama automáticamente al constructor por defecto de la superclase.

b) No se inicializan los atributos de la superclase.
c) Se genera un error en tiempo de compilación.
d) Se inicializan automáticamente con valores predeterminados.

3. ¿Es posible heredar un constructor de una superclase?

a) Sí, si es público.
b) No, los constructores no se heredan.
c) Sí, si la subclase no tiene constructores propios.
d) No, excepto si se usa super.

4. ¿Dónde debe ubicarse la llamada a super en un constructor?

a) En cualquier parte del constructor.

b) Antes de la declaración de los atributos de la subclase.
c) Debe ser la primera línea del constructor.
d) No es obligatorio llamarla.

25
 Parte 5: Modificadores en clases, atributos y métodos.
Utilización avanzada de clases

Parte 5: Modificadores en clases, atributos y métodos.

Los modificadores de acceso en Java son herramientas esenciales para definir la visibilidad y control de acceso a las
clases, atributos y métodos. Con ellos, podemos establecer reglas sobre quién puede acceder o modificar determina-
das partes del código.

1. Modificadores de Acceso

En Java, los modificadores de acceso determinan la visibilidad de las clases, atributos y métodos. Existen cuatro nive-
les principales:

Modificador Dentro de la Clase Dentro del Paquete En Subclases Desde Fuera

public √ √ √ √
protected √ √ √ ×
(sin modificador) √ √ × ×
private √ × × ×

1.1. public

• Permite que la clase, atributo o método sea accesible desde cualquier lugar.
• Es el modificador más abierto.

Ejemplo: Uso de public

public class Persona {

public String nombre;
public void mostrarNombre() {
[Link](“Nombre: “ + nombre);
}
}
public class Main {
public static void main(String[] args) {
Persona persona = new Persona();
[Link] = “Juan”;
[Link](); // Acceso público
}
}

1.2. private

• Limita el acceso únicamente a la clase donde se declara.

26
 Parte 5: Modificadores en clases, atributos y métodos.
Utilización avanzada de clases

• Es el modificador más restrictivo y se usa para la encapsulación.

Ejemplo: Uso de private

public class Persona {

private String nombre;
public void setNombre(String nombre) {
[Link] = nombre;
}
public String getNombre() {
return nombre;
}
}
public class Main {
public static void main(String[] args) {
Persona persona = new Persona();
[Link](“Ana”); // Acceso a través de un método público
[Link]([Link]());
}
}

Salida:

Ana

1.3. protected

• Permite acceso desde:

• La misma clase.
• Clases dentro del mismo paquete.
• Subclases (incluso si están en un paquete diferente).

27
 Parte 5: Modificadores en clases, atributos y métodos.
Utilización avanzada de clases

Ejemplo: Uso de protected

public class Animal {

protected String especie;
public void mostrarEspecie() {
[Link](“Especie: “ + especie);
}
}
public class Perro extends Animal {
public void ladrar() {
[Link](“El perro de especie “ + especie + “ está ladran-
do.”);
}
}
public class Main {
public static void main(String[] args) {
Perro miPerro = new Perro();
[Link] = “Canino”;
[Link]();
[Link]();
}
}

1.4. Sin Modificador (Default o Package-Private)

• Permite acceso solo desde clases dentro del mismo paquete.

• Es el modificador predeterminado si no se especifica otro.

28
 Parte 5: Modificadores en clases, atributos y métodos.
Utilización avanzada de clases

Ejemplo: Sin Modificador

class Vehiculo {
String marca; // Default
void mostrarMarca() {
[Link](“Marca: “ + marca);
}
}
public class Main {
public static void main(String[] args) {
Vehiculo vehiculo = new Vehiculo();
[Link] = “Toyota”; // Acceso permitido dentro del paquete
[Link]();
}
}

2. Modificadores en Clases

En Java, solo se pueden usar los modificadores public y default (sin modificador) para las clases.

1. Clases public:

• Accesibles desde cualquier lugar.

2. Clases con Default:

• Solo accesibles desde el mismo paquete.

Ejemplo

public class ClasePublica {

// Clase accesible desde cualquier lugar
}
class ClaseDefault {
// Clase accesible solo dentro del paquete
}

29
 Parte 5: Modificadores en clases, atributos y métodos.
Utilización avanzada de clases

3. Modificadores en Métodos

Los métodos pueden usar todos los modificadores de acceso (public, protected, private, default). Además, pue-
den tener otros modificadores:

1. static:

• Pertenece a la clase en lugar de a una instancia específica.

• Se puede llamar sin crear un objeto.

public static void saludar() {

[Link](“Hola”);
}

2. final:

• Evita que el método sea sobrescrito por subclases.

public final void despedir() {

[Link](“Adiós”);
}

3. abstract:

• Declara un método sin implementación (solo en clases abstractas).

public abstract void metodoAbstracto();

4. Modificadores en Atributos

1. final:

• Impide que el valor del atributo sea modificado después de ser inicializado.

public final int MAX_EDAD = 100;

2. static:

• El atributo pertenece a la clase, no a las instancias.

public static String idioma = “Español”;

30
 Parte 5: Modificadores en clases, atributos y métodos.
Utilización avanzada de clases

5. Ejercicio Guiado

Problema

1. Define una clase Persona con los atributos:

• nombre (private), edad (protected), y pais (public).

• Crea métodos getter y setter para nombre.

2. Define una subclase Estudiante que:

• Herede de Persona.
• Implemente un método para mostrar toda la información.

3. En la clase principal:

• Crea un objeto de Estudiante y prueba los modificadores.

31
 Parte 5: Modificadores en clases, atributos y métodos.
Utilización avanzada de clases

6. Preguntas de Evaluación

1. ¿Qué modificador permite acceso desde cualquier lugar?

a) private
b) protected
c) public
d) Sin modificador

2. ¿Qué modificador solo permite acceso dentro de la clase?

a) private
b) protected
c) default
d) public

3. ¿Qué hace un atributo final?

a) Evita que sea heredado.

b) Evita que sea sobrescrito.
c) Evita que sea modificado después de inicializarse.
d) Ninguna de las anteriores.

4. ¿Qué modificador permite acceso a subclases incluso en diferentes paquetes?

a) protected
b) default
c) private
d) public

32
 Parte 6: Sobreescritura de métodos.
Utilización avanzada de clases

Parte 6: Sobreescritura de métodos.

La sobrescritura de métodos (method overriding) es un mecanismo clave en la Programación Orientada a Objetos
(POO) que permite a una subclase proporcionar una implementación específica para un método que ya está definido
en su superclase.

1. ¿Qué es la Sobrescritura de Métodos?

1. Definición:

• La sobrescritura ocurre cuando una subclase redefine un método de la superclase usando el mismo nombre, tipo
de retorno y parámetros.
• Cambia o extiende el comportamiento del método heredado.

2. Características Clave:

• El método en la subclase debe tener la misma firma (nombre, parámetros y tipo de retorno) que el de la supercla-
se.
• No se puede reducir la visibilidad del método (por ejemplo, de public a protected).
• Debe usar la anotación @Override para indicar explícitamente que está sobrescribiendo un método.

1.1. Uso de la Anotación @Override

La anotación @Override asegura que el compilador verifique si el método realmente está sobrescribiendo un método
de la superclase.

33
 Parte 6: Sobreescritura de métodos.
Utilización avanzada de clases

Ejemplo: Uso de @Override

public class Animal {

public void sonido() {
[Link](“El animal hace un sonido.”);
}
}
public class Perro extends Animal {
@Override
public void sonido() {
[Link](“El perro ladra.”);
}
}
public class Main {
public static void main(String[] args) {
Animal miAnimal = new Perro();
[Link](); // Llama al método sobrescrito en Perro
}
}

Salida:

El perro ladra.

34
 Parte 6: Sobreescritura de métodos.
Utilización avanzada de clases

2. Reglas de Sobrescritura

1. Firma del Método:

• La subclase debe mantener el mismo nombre, parámetros y tipo de retorno que el método de la superclase.

2. Visibilidad:

• No se puede reducir la visibilidad del método. Por ejemplo, un método public en la superclase no puede ser
protected o private en la subclase.

3. Modificadores final y static:

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

• Los métodos static no se pueden sobrescribir; en su lugar, se ocultan (hiding).

4. Excepciones:

• La subclase no puede lanzar excepciones más generales que las declaradas en la superclase.

3. Diferencia entre Sobrecarga y Sobrescritura

Característica Sobrecarga de Métodos Sobrescritura de Métodos

Contexto Mismo método en la misma clase. Método en la subclase con el mismo
nombre y firma.
Parámetros Deben ser diferentes en tipo o núme- Deben ser exactamente iguales.
ro.
Tipo de Retorno Puede cambiar. Debe ser el mismo o compatible cova-
riantemente.
Modificadores Puede tener cualquier nivel de visibi- No puede reducir la visibilidad.
lidad.

4. Uso de la Palabra Clave super

En la sobrescritura, se puede usar la palabra clave super para llamar al método de la superclase desde la subclase.

35
 Parte 6: Sobreescritura de métodos.
Utilización avanzada de clases

Ejemplo: Uso de super

public class Animal {

public void sonido() {
[Link](“El animal hace un sonido.”);
}
}
public class Gato extends Animal {
@Override
public void sonido() {
[Link](); // Llama al método de la superclase
[Link](“El gato maúlla.”);
}
}
public class Main {
public static void main(String[] args) {
Gato miGato = new Gato();
[Link]();
}
}

Salida:

El animal hace un sonido.

El gato maúlla.

5. Ejemplo Completo

Ejemplo: Clases de Empleados

1. Crea una superclase Empleado con:

• Atributo nombre.
• Método calcularSalario() que devuelve un valor base.

2. Crea dos subclases:

• EmpleadoTiempoCompleto: Sobrescribe calcularSalario() para devolver un salario fijo.

• EmpleadoPorHoras: Sobrescribe calcularSalario() para devolver un salario basado en horas trabajadas.

36
 Parte 6: Sobreescritura de métodos.
Utilización avanzada de clases

public class Empleado {

protected String nombre;
public Empleado(String nombre) {
[Link] = nombre;
}
public double calcularSalario() {
return 1000; // Salario base
}
public void mostrarInformacion() {
[Link](“Empleado: “ + nombre);
[Link](“Salario: “ + calcularSalario());
}
}
public class EmpleadoTiempoCompleto extends Empleado {
public EmpleadoTiempoCompleto(String nombre) {
super(nombre);
}
@Override
public double calcularSalario() {
return 2000; // Salario fijo para empleados a tiempo completo
}
}
public class EmpleadoPorHoras extends Empleado {
private int horasTrabajadas;
private double tarifaPorHora;
public EmpleadoPorHoras(String nombre, int horasTrabajadas, double tari-
faPorHora) {
super(nombre);
[Link] = horasTrabajadas;
[Link] = tarifaPorHora;
}
@Override
public double calcularSalario() {
return horasTrabajadas * tarifaPorHora;
}
}
public class Main {
public static void main(String[] args) {
Empleado emp1 = new EmpleadoTiempoCompleto(“Ana”);
Empleado emp2 = new EmpleadoPorHoras(“Carlos”, 40, 15);
[Link]();
[Link]();
}

37
 Parte 6: Sobreescritura de métodos.
Utilización avanzada de clases

Salida:

Empleado: Ana
Salario: 2000.0
Empleado: Carlos
Salario: 600.0

6. Ejercicio Guiado

Problema

1. Crea una clase Figura con un método calcularArea().

2. Crea dos subclases:

• Rectangulo: Calcula el área de un rectángulo.

• Circulo: Calcula el área de un círculo.

3. Usa la sobrescritura para personalizar el método calcularArea() en cada subclase.

38
 Parte 6: Sobreescritura de métodos.
Utilización avanzada de clases

7. Preguntas de Evaluación

1. ¿Qué palabra clave se usa para indicar que un método está sobrescribiendo otro?

a) @Override
b) @Overload
c) @Super
d) Ninguna de las anteriores

2. ¿Qué ocurre si un método sobrescrito intenta reducir la visibilidad del método original?

a) Produce un error de compilación.

b) Se permite si no se usa la anotación @Override.
c) Se ejecuta normalmente.
d) Se ignora la sobrescritura.

3. ¿Cuál de los siguientes métodos puede ser sobrescrito?

a) final
b) private
c) static
d) Ninguno de los anteriores

4. ¿Qué se requiere para sobrescribir correctamente un método?

a) Cambiar el tipo de retorno.

b) Mantener la misma firma del método.
c) Reducir el nivel de acceso.
d) Usar static en ambos métodos.

39
 Parte 7: Clases y métodos abstractos y finales
Utilización avanzada de clases

Parte 7: Clases y métodos abstractos y finales

Las clases abstractas y los métodos abstractos son fundamentales en Java para definir comportamientos genéricos
que se implementarán de manera específica en las subclases. Por otro lado, las clases y métodos finales se utilizan
para restringir la herencia y la sobrescritura.

1. Clases Abstractas

1. Definición:

Una clase abstracta es una clase que no se puede instanciar directamente.

• Se utiliza para definir una estructura base para otras clases.

• Puede contener métodos concretos (con implementación) y métodos abstractos (sin implementación).

2. Uso Principal:

• Modelar conceptos genéricos que comparten características comunes.

• Forzar a las subclases a proporcionar implementaciones específicas de los métodos abstractos.

3. Palabra Clave:

Se utiliza abstract para declarar una clase como abstracta.

40
 Parte 7: Clases y métodos abstractos y finales
Utilización avanzada de clases

Ejemplo de Clase Abstracta

public abstract class Figura {

protected String color;
public Figura(String color) {
[Link] = color;
}
// Método abstracto: sin implementación
public abstract double calcularArea();
// Método concreto: con implementación
public void mostrarColor() {
[Link](“Color: “ + color);
}
}
public class Rectangulo extends Figura {
private double largo;
private double ancho;
public Rectangulo(String color, double largo, double ancho) {
super(color);
[Link] = largo;
[Link] = ancho;
}
@Override
public double calcularArea() {
return largo * ancho;
}
}
public class Main {
public static void main(String[] args) {
Rectangulo rectangulo = new Rectangulo(“Rojo”, 5, 3);
[Link]();
[Link](“Área: “ + [Link]());
}
}

Salida:

Color: Rojo
Área: 15.0

41
 Parte 7: Clases y métodos abstractos y finales
Utilización avanzada de clases

Características de las Clases Abstractas

1. No Instanciables:

No se pueden crear objetos directamente de una clase abstracta.

Figura figura = new Figura(“Azul”); // Error de compilación

2. Métodos Abstractos:

• Son métodos sin cuerpo (solo declaración).

• Las subclases deben implementar todos los métodos abstractos de la superclase.

public abstract double calcularArea();

3. Métodos Concretos:

• Las clases abstractas pueden contener métodos con cuerpo que pueden ser utilizados por las subclases.

2. Métodos Abstractos

1. Definición:

Un método abstracto es un método declarado sin cuerpo.

• Solo puede estar en clases abstractas.

• Obliga a las subclases a proporcionar su implementación.

2. Ejemplo:

public abstract class Animal {

public abstract void sonido();
}
public class Perro extends Animal {
@Override
public void sonido() {
[Link](“El perro ladra.”);
}
}

42
 Parte 7: Clases y métodos abstractos y finales
Utilización avanzada de clases

3. Clases Finales

1. Definición:

Una clase final es una clase que no se puede heredar.

• Se utiliza para evitar que otras clases extiendan una clase específica.

2. Palabra Clave:

Se utiliza final para declarar una clase como final.

3. Ejemplo:

public final class Utilidades {

public static void imprimirMensaje(String mensaje) {
[Link](mensaje);
}
}
// Esto generará un error:
public class SubClase extends Utilidades {
// No se puede heredar de una clase final
}

4. Métodos Finales

1. Definición:

Un método final es un método que no puede ser sobrescrito por las subclases.

• Se utiliza para preservar el comportamiento de un método.

43
 Parte 7: Clases y métodos abstractos y finales
Utilización avanzada de clases

2. Ejemplo:

public class Persona {

public final void mostrarIdentidad() {
[Link](“Soy una persona.”);
}
}
public class Estudiante extends Persona {
// Esto generará un error:
@Override
public void mostrarIdentidad() {
[Link](“Soy un estudiante.”);
}
}

5. Diferencias entre Clases Abstractas y Finales

Característica Clases Abstractas Clases Finales

Instanciación No se pueden instanciar. Se pueden instanciar.
Herencia Pueden ser heredadas. No pueden ser heredadas.
Definir una estructura
Propósito Evitar que otras clases hereden.
base para subclases.

6. Ejemplo Completo

Problema: Figuras Geométricas con Restricciones

1. Define una clase abstracta Figura con un método abstracto calcularArea().

2. Crea una subclase Triangulo que implemente el cálculo del área.
3. Define una clase Constantes como final para almacenar valores constantes (como PI).
4. En la clase principal, crea objetos de las subclases y muestra sus áreas.

44
 Parte 7: Clases y métodos abstractos y finales
Utilización avanzada de clases

public abstract class Figura {

protected String nombre;
public Figura(String nombre) {
[Link] = nombre;
}
public abstract double calcularArea();
public void mostrarNombre() {
[Link](“Figura: “ + nombre);
}
}
public class Triangulo extends Figura {
private double base;
private double altura;
public Triangulo(String nombre, double base, double altura) {
super(nombre);
[Link] = base;
[Link] = altura;
}
@Override
public double calcularArea() {
return (base * altura) / 2;
}
}
public final class Constantes {
public static final double PI = 3.14159;
}
public class Main {
public static void main(String[] args) {
Triangulo triangulo = new Triangulo(“Triángulo”, 5, 3);
[Link]();
[Link](“Área: “ + [Link]());
[Link](“Valor de PI: “ + [Link]);
}
}

Salida:

Figura: Triángulo
Área: 7.5
Valor de PI: 3.14159

45
 Parte 7: Clases y métodos abstractos y finales
Utilización avanzada de clases

7. Ejercicio Guiado

Problema

1. Crea una clase abstracta Empleado con el método abstracto calcularSalario().

2. Define una subclase EmpleadoPorHoras que implemente el cálculo del salario basado en horas trabajadas.
3. Define una clase final ConstantesEmpresa para almacenar valores como el salario mínimo.
4. En la clase principal, crea un objeto de EmpleadoPorHoras e imprime su salario.

8. Preguntas de Evaluación

1. ¿Qué ocurre si una clase contiene un método abstracto y no se declara como abstracta?

a) Se genera un error de compilación.

b) Se permite, pero el método no tiene cuerpo.
c) La clase no puede ser heredada.
d) Ninguna de las anteriores.

2. ¿Qué ocurre si una subclase no implementa todos los métodos abstractos de su superclase abstracta?

a) Se permite, pero no se puede instanciar.

b) La subclase debe declararse como abstracta.
c) Ambas respuestas anteriores son correctas.
d) Ninguna de las anteriores.

3. ¿Qué hace un método final?

a) Permite ser sobrescrito.

b) Impide ser sobrescrito.
c) Declara que no tiene cuerpo.
d) Ninguna de las anteriores.

4. ¿Qué característica define una clase abstracta?

a) No se puede heredar.
b) No se puede instanciar directamente.
c) Todos sus métodos deben ser abstractos.
d) Ninguna de las anteriores.

46
 Parte 8: Interfaces. Clases abstractas vs. Interfaces.
Utilización avanzada de clases

Parte 8: Interfaces. Clases abstractas vs. Interfaces.

1. ¿Qué es una Interfaz?

Una interfaz es una estructura que define un conjunto de métodos que una clase debe implementar. A diferencia de
una clase abstracta, una interfaz no contiene atributos ni métodos concretos (hasta Java 8, con algunas excepciones).

1. Definición:

• Una interfaz actúa como un contrato que las clases que la implementan deben cumplir.
• Los métodos en una interfaz son implícitamente abstractos y públicos (no requieren las palabras clave abstract
o public).

2. Palabra Clave:

• Se utiliza la palabra clave interface para definir una interfaz.

• Una clase utiliza la palabra clave implements para implementar una interfaz.1.1. Ejemplo Básico

// Definición de una interfaz

public interface Vehiculo {
void encender();
void apagar();
}
// Implementación de la interfaz
public class Coche implements Vehiculo {
@Override
public void encender() {
[Link](“El coche está encendido.”);
}
@Override
public void apagar() {
[Link](“El coche está apagado.”);
}
}
public class Main {
public static void main(String[] args) {
Coche miCoche = new Coche();
[Link]();
[Link]();
}
}

47
 Parte 8: Interfaces. Clases abstractas vs. Interfaces.
Utilización avanzada de clases

Salida:

El coche está encendido.

El coche está apagado.

1.2. Características de las Interfaces

1. Múltiples Implementaciones:

• Una clase puede implementar múltiples interfaces, superando la limitación de herencia simple.

public interface Volador {

void volar();
}
public interface Nadador {
void nadar();
}
public class Pato implements Volador, Nadador {
@Override
public void volar() {
[Link](“El pato está volando.”);
}
@Override
public void nadar() {
[Link](“El pato está nadando.”);
}
}

2. Métodos por Defecto (Desde Java 8):

• Las interfaces pueden contener métodos concretos con la palabra clave default.

public interface Vehiculo {

default void frenar() {
[Link](“El vehículo está frenando.”);
}
}

3. Métodos Estáticos (Desde Java 8):

• Las interfaces pueden contener métodos estáticos.

48
 Parte 8: Interfaces. Clases abstractas vs. Interfaces.
Utilización avanzada de clases

public interface Utilidades {

static void mostrarMensaje(String mensaje) {
[Link](mensaje);
}
}

2. Diferencias entre Clases Abstractas e Interfaces

Aspecto Clases Abstractas Interfaces

Instanciación No se pueden instanciar. No se pueden instanciar.
Herencia Permite heredar de Una clase puede implemen-
una sola clase. tar múltiples interfaces.
Atributos Puede tener atributos Solo atributos está-
con cualquier modifi- ticos y finales.
cador de acceso.
Métodos Métodos concre- Métodos abstractos, por
tos y abstractos. defecto y estáticos.
Propósito Modelar jerarquías de clases. Definir un contrato de
comportamiento.
2.1. Ejemplo ComparativoClase Abstracta

public abstract class Animal {

protected String nombre;
public Animal(String nombre) {
[Link] = nombre;
}
public abstract void sonido();
}

Interfaz

public interface Volador {

void volar();
}

49
 Parte 8: Interfaces. Clases abstractas vs. Interfaces.
Utilización avanzada de clases

Uso Combinado

public class Pajaro extends Animal implements Volador {

public Pajaro(String nombre) {
super(nombre);
}
@Override
public void sonido() {
[Link](nombre + “ canta.”);
}
@Override
public void volar() {
[Link](nombre + “ está volando.”);
}
}

3. Ventajas y Limitaciones de las Interfaces

Ventajas

1. Herencia Múltiple:

• Una clase puede implementar múltiples interfaces, permitiendo combinar comportamientos.

2. Desacoplamiento:

• Facilita el diseño de sistemas modulares al definir contratos claros.

3. Compatibilidad:

• Las interfaces pueden ser implementadas por cualquier clase, sin importar su jerarquía.

Limitaciones

1. Falta de Estado Compartido:

• No se pueden definir atributos no estáticos.

2. Comportamiento General:

• Las interfaces no pueden contener lógica común para ser reutilizada directamente (salvo métodos por defecto).

50
 Parte 8: Interfaces. Clases abstractas vs. Interfaces.
Utilización avanzada de clases

4. Ejemplo Completo

Problema: Vehículos con Diferentes Capacidades

1. Define una interfaz Vehiculo con los métodos arrancar() y detener().

2. Define dos interfaces adicionales:

• Volador: Método volar().

• Nadador: Método nadar().

3. Implementa dos clases:

• Avion, que implemente Vehiculo y Volador.

• Barco, que implemente Vehiculo y Nadador.

51
 Parte 8: Interfaces. Clases abstractas vs. Interfaces.
Utilización avanzada de clases

public interface Vehiculo {

void arrancar();
void detener();
}
public interface Volador {
void volar();
}
public interface Nadador {
void nadar();
}
public class Avion implements Vehiculo, Volador {
@Override
public void arrancar() {
[Link](“El avión está arrancando.”);
}
@Override
public void detener() {
[Link](“El avión está deteniéndose.”);
}
@Override
public void volar() {
[Link](“El avión está volando.”);
}
}
public class Barco implements Vehiculo, Nadador {
@Override
public void arrancar() {
[Link](“El barco está arrancando.”);
}
@Override
public void detener() {
[Link](“El barco está deteniéndose.”);
}
@Override
public void nadar() {
[Link](“El barco está navegando.”);
}
}
public class Main {
public static void main(String[] args) {
Avion miAvion = new Avion();
Barco miBarco = new Barco();
[Link]();

52
 Parte 8: Interfaces. Clases abstractas vs. Interfaces.
Utilización avanzada de clases

[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
}
}

Salida:

El avión está arrancando.

El avión está volando.
El avión está deteniéndose.
El barco está arrancando.
El barco está navegando.
El barco está deteniéndose.

5. Ejercicio Guiado

Problema

1. Define una interfaz Empleado con los métodos trabajar() y descansar().

2. Crea una interfaz adicional Freelancer con el método cotizarProyecto().
3. Implementa una clase Desarrollador que combine ambas interfaces.

53
 Parte 8: Interfaces. Clases abstractas vs. Interfaces.
Utilización avanzada de clases

6. Preguntas de Evaluación

1. ¿Qué palabra clave se usa para implementar una interfaz?

a) extends
b) implements
c) interface
d) Ninguna de las anteriores

2. ¿Qué tipo de métodos se pueden definir en una interfaz?

a) Métodos concretos únicamente.

b) Métodos abstractos, por defecto y estáticos.
c) Solo métodos abstractos.
d) Métodos finales.

3. ¿Puede una clase implementar más de una interfaz?

a) Sí.
b) No.
c) Solo si no tiene métodos abstractos.
d) Ninguna de las anteriores.

54
 Conclusión del Bloque: Utilización avanzada de clases
Utilización avanzada de clases

Conclusión del Bloque: Utilización avanzada de clases

En este bloque, hemos explorado conceptos avanzados que son fundamentales para el diseño y la implementación de
sistemas orientados a objetos en Java. Estos conceptos proporcionan herramientas y estrategias para modelar relacio-
nes, comportamientos y restricciones en las clases y sus interacciones.

1. Resumen de los Puntos Clave

1. Relaciones entre Clases y Composición

• Las relaciones entre clases permiten conectar entidades en un diseño lógico.

• Composición y agregación modelan relaciones “tiene un”, mientras que la herencia representa relaciones “es un”.

2. Herencia y Jerarquías

• Herencia permite reutilizar y extender el comportamiento de clases existentes.

• Superclases y subclases establecen una jerarquía clara para organizar el código y fomentar la reutilización.
• El uso de constructores en herencia asegura una inicialización adecuada en todos los niveles.

3. Modificadores en Clases, Atributos y Métodos

• Los modificadores de acceso (public, private, protected, default) controlan la visibilidad y el acceso al código.
• Los modificadores como final y static agregan restricciones y propiedades especiales a los métodos y atributos.

4. Sobrescritura y Sobrecarga

• Sobrescritura permite personalizar el comportamiento de métodos heredados mediante @Override.

• Sobrecarga permite crear múltiples versiones de un método con diferentes firmas.

5. Clases Abstractas y Métodos Finales

• Las clases abstractas proporcionan una estructura base para las subclases, definiendo métodos abstractos y con-
cretos.
• Los métodos finales y las clases finales restringen la modificación y la herencia, respectivamente.

6. Interfaces

• Las interfaces definen un contrato de comportamiento que las clases deben implementar.
• Java permite combinar múltiples interfaces, facilitando la herencia múltiple.
• Desde Java 8, las interfaces pueden incluir métodos por defecto y estáticos.

55
 Conclusión del Bloque: Utilización avanzada de clases
Utilización avanzada de clases

2. Ventajas del Uso Avanzado de Clases

1. Modularidad:

• Facilita la separación de responsabilidades, mejorando la legibilidad y mantenibilidad del código.

2. Flexibilidad y Reutilización:

• Las interfaces y la herencia permiten adaptar y reutilizar código en diferentes contextos.

3. Encapsulación:

• Los modificadores de acceso controlan cómo y dónde se puede interactuar con las clases y sus miembros.

4. Extensibilidad:

• Las jerarquías de clases bien diseñadas permiten extender funcionalidades de manera eficiente.

5. Consistencia:

• Los contratos definidos por interfaces garantizan que las implementaciones cumplan con las especificaciones
establecidas.

3. Ejercicio Final del Bloque

Problema

Diseña un sistema para gestionar un zoológico utilizando los conceptos del bloque:

1. Define una clase abstracta Animal con:

• Atributos: nombre y edad.

• Método abstracto hacerSonido().
• Método concreto mostrarInformacion() para imprimir los atributos.

2. Crea subclases que hereden de Animal:

• Perro: Implementa el método hacerSonido() para imprimir “El perro ladra”.

• Gato: Implementa el método hacerSonido() para imprimir “El gato maúlla”.

3. Define una interfaz Domestico con el método jugar().

• Haz que Perro y Gato implementen esta interfaz.

4. En la clase principal:

• Crea una lista de animales.

• Muestra su información y sus sonidos.
• Llama al método jugar() para los animales domésticos.

56
 Conclusión del Bloque: Utilización avanzada de clases
Utilización avanzada de clases

Código Propuesto

import [Link];
public abstract class Animal {
protected String nombre;
protected int edad;
public Animal(String nombre, int edad) {
[Link] = nombre;
[Link] = edad;
}
public abstract void hacerSonido();
public void mostrarInformacion() {
[Link](“Nombre: “ + nombre + “, Edad: “ + edad);
}
}
public interface Domestico {
void jugar();
}
public class Perro extends Animal implements Domestico {
public Perro(String nombre, int edad) {
super(nombre, edad);
}
@Override
public void hacerSonido() {
[Link](“El perro ladra.”);
}
@Override
public void jugar() {
[Link](nombre + “ está jugando con una pelota.”);
}
}
public class Gato extends Animal implements Domestico {
public Gato(String nombre, int edad) {
super(nombre, edad);
}
@Override
public void hacerSonido() {
[Link](“El gato maúlla.”);
}
@Override
public void jugar() {
[Link](nombre + “ está jugando con un ovillo de lana.”);
}

57
 Conclusión del Bloque: Utilización avanzada de clases
Utilización avanzada de clases

}
public class Main {
public static void main(String[] args) {
ArrayList<Animal> animales = new ArrayList<>();
[Link](new Perro(“Rex”, 5));
[Link](new Gato(“Luna”, 3));
for (Animal animal : animales) {
[Link]();
[Link]();
if (animal instanceof Domestico) {
((Domestico) animal).jugar();
}
[Link](“---”);
}
}
}

Salida:

Nombre: Rex, Edad: 5

El perro ladra.
Rex está jugando con una pelota.
---
Nombre: Luna, Edad: 3
El gato maúlla.
Luna está jugando con un ovillo de lana.
---

58
 Conclusión del Bloque: Utilización avanzada de clases
Utilización avanzada de clases

4. Preguntas de Evaluación

1. ¿Qué palabra clave se utiliza para implementar una interfaz en Java?

a) extends
b) implements
c) interface
d) Ninguna de las anteriores

2. ¿Qué tipo de métodos puede contener una clase abstracta?

a) Métodos concretos únicamente.

b) Métodos abstractos únicamente.
c) Métodos concretos y abstractos.
d) Solo métodos estáticos.

3. ¿Cuál es la diferencia clave entre una clase abstracta y una interfaz?

a) Una interfaz no puede contener métodos concretos.

b) Una clase abstracta permite heredar de múltiples clases.
c) Una interfaz define un contrato de comportamiento, mientras que una clase abstracta puede contener lógica
común.
d) No hay diferencia.

4. ¿Qué ocurre si una subclase no implementa un método abstracto de su superclase?

a) Produce un error de compilación.

b) Se permite, pero el método no puede ser llamado.
c) La subclase debe declararse como abstracta.
d) Ambas respuestas a) y c) son correctas.

59