Polimorfismo e Interfaces en Java
Conceptos de Programación
Orientada a Objetos
¿Qué es una Interfaz?
• Contrato que define métodos sin
implementar.
• Implementada por clases que definen el
comportamiento.
• Sintaxis: interface Vehiculo { void acelerar(); }
• Permite herencia múltiple de
comportamiento.
¿Qué es una interfaz?
• Una interfaz en Java define un contrato que
las clases deben cumplir.
• Contiene métodos abstractos (sin
implementación).
• Permite lograr la abstracción y el
polimorfismo.
• Una clase puede implementar múltiples
interfaces.
Ejemplo de interfaz
// Definición de la interfaz
interface Vehiculo {
void arrancar();//Metodos
void detener();
}
// Implementación por la clase Coche
class Coche implements Vehiculo {
public void arrancar() {
[Link]("El coche arranca con llave");
}
public void detener() {
[Link]("El coche se detiene con freno");
}
}
Ejemplo de interfaz
// Implementación por la clase Bicicleta
class Bicicleta implements Vehiculo {
public void arrancar() {
[Link]("La bicicleta comienza a pedalear");
}
public void detener() {
[Link]("La bicicleta se detiene con freno de
mano");
}
}
Ejemplo de interfaz
// Clase principal
public class EjemploInterface {
public static void main(String[] args) {
Vehiculo miVehiculo;
miVehiculo = new Coche();
[Link](); // Salida: El coche arranca con llave
[Link](); // Salida: El coche se detiene con freno
miVehiculo = new Bicicleta();
[Link](); // Salida: La bicicleta comienza a pedalear
[Link](); // Salida: La bicicleta se detiene con freno de
//. mano
}
}
Ventajas
• Código más flexible y reutilizable
• Facilita el uso de colecciones de objetos
• Mejora la organización del código
• Permite el desarrollo orientado a contratos
(interfaces)
¿Una clase puede implementar varias
interfaces?
• En Java, una clase puede implementar
múltiples interfaces.
• Esto permite heredar comportamientos de
distintas fuentes.
• Se utiliza la palabra clave 'implements'.
• La clase debe sobrescribir todos los métodos
de las interfaces.
Definición de Interfaces
interface Volador {
void volar();
}
interface Nadador {
void nadar();
}
Implementación de Múltiples
Interfaces
class Pato implements Volador, Nadador {
public void volar() {
[Link]("El pato vuela");
}
public void nadar() {
[Link]("El pato nada");
}
}
Uso de la Clase con Múltiples
Interfaces
public class Main {
public static void main(String[] args) {
Pato pato = new Pato();
[Link]();
[Link]();
}
}
Interfaces Comunes de la API de
Java
Interfaces mas comunes
Métodos comunes de Collection
• add(E e)
• remove(Object o)
• size()
• isEmpty()
• contains(Object o)
• iterator()
• clear()
Interface: [Link]
• Una colección ordenada que puede contener
elementos duplicados.
• Implementaciones comunes: ArrayList,
LinkedList.
• Permite acceso por índice.
• Métodos clave: add(), get(), remove(), size().
Uso de ArrayList y LinkedList en
Java
Ejemplo con métodos
¿Qué son ArrayList y LinkedList?
• ArrayList: Implementación de lista basada en
un arreglo dinámico.
• LinkedList: Implementación de lista basada en
nodos enlazados.
• Ambas implementan la interfaz List en Java.
• Permiten almacenar y manipular colecciones
de datos.
Ejemplo con ArrayList
import [Link];
public class EjemploArrayList {
public static void main(String[] args) {
ArrayList<String> nombres = new ArrayList<>();
// Método add()
[Link]("Ana");
[Link]("Pedro");
// Método get()
[Link]("Primer nombre: " + [Link](0));
]
}
Ejemplo con LinkedList
import [Link];
public class EjemploLinkedList {
public static void main(String[] args) {
LinkedList<String> ciudades = new LinkedList<>();
// Método add()
[Link]("Panamá");
[Link]("Madrid");
// Método remove()
[Link]("Madrid");
[Link](ciudades);
}
}
Comparación entre ArrayList y
LinkedList
• ArrayList es más eficiente para búsquedas
(acceso por índice).
• LinkedList es más eficiente para inserciones y
eliminaciones.
• Ambas son útiles dependiendo del contexto.
Interface: [Link]
• Conjunto que no permite elementos
duplicados.
• Implementaciones comunes: HashSet,
TreeSet.
• No garantiza orden específico (HashSet).
• Métodos clave: add(), contains(), remove().
HashSet y TreeSet en Java
Colecciones en Java - Ejemplos
prácticos
HashSet en Java
• Implementa la interfaz Set
• No permite elementos duplicados
• No garantiza el orden de los elementos
• Opera con tablas hash (rápido acceso)
Ejemplo: HashSet
import [Link];
public class EjemploHashSet {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
[Link]("Manzana");
[Link]("Banana");
[Link]("Pera");
[Link](set);
}
}
TreeSet en Java
• Implementa la interfaz NavigableSet
• No permite elementos duplicados
• Mantiene los elementos ordenados de forma
natural
• Se implementa con un árbol rojo-negro (Red-
Black Tree)
Ejemplo: TreeSet
import [Link];
public class EjemploTreeSet {
public static void main(String[] args) {
TreeSet<Integer> numeros = new TreeSet<>();
[Link](30);
[Link](10);
[Link](20);
[Link](10); // duplicado
[Link](numeros);
}
}
Comparación HashSet vs TreeSet
• HashSet:
• No garantiza orden
• Mayor rendimiento
• TreeSet:
• Mantiene orden natural
• Menor rendimiento comparado con HashSet
Interface: [Link]
• Estructura de clave-valor.
• Cada clave es única y se asocia a un valor.
• Implementaciones comunes: HashMap,
TreeMap.
• Métodos clave: put(), get(), remove(),
containsKey().
HashMap y TreeMap en Java
Colecciones en Java - Mapas con
ejemplos prácticos
HashMap en Java
• Implementa la interfaz Map
• Almacena pares clave-valor
• No permite claves duplicadas
• Permite valores nulos
• No garantiza el orden de los elementos
• Opera con tablas hash (acceso rápido)
Ejemplo: HashMap
import [Link];
public class EjemploHashMap {
public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
[Link](1, "Uno");
[Link](2, "Dos");
[Link](3, "Tres");
[Link](2, "Dos repetido"); // reemplaza valor
[Link](map);
}
}
TreeMap en Java
• Implementa la interfaz NavigableMap
• Almacena pares clave-valor
• No permite claves duplicadas
• Ordena las claves de forma natural (o con
Comparator)
• No permite claves nulas
Ejemplo: TreeMap
import [Link];
public class EjemploTreeMap {
public static void main(String[] args) {
TreeMap<Integer, String> map = new TreeMap<>();
[Link](3, "Tres");
[Link](1, "Uno");
[Link](2, "Dos");
[Link](map);
}
}
Comparación HashMap vs TreeMap
• HashMap:
• No garantiza orden
• Permite una clave nula
• Mayor rendimiento
• TreeMap:
• Mantiene las claves ordenadas
• No permite claves nulas
• Menor rendimiento comparado con HashMap
Interface: [Link]
• Permite definir el orden natural de objetos.
• Se implementa para que objetos puedan ser
ordenados.
• Método clave: compareTo(T o).
Interface: [Link]
• La interfaz Comparable en Java se utiliza
para definir el orden natural de los objetos de
una clase.
•
Pertenece al paquete [Link], por lo que no
necesitas importarla explícitamente.
Interface: [Link]
Definición:
public interface Comparable<T> {
int compareTo(T o);
}
• La interfaz tiene un solo
método, compareTo(T o), que compara el
objeto actual con otro del mismo tipo.
Interface: [Link]
• Cómo funciona:
• Devuelve un número negativo si el objeto
actual es menor que el objeto pasado.
• Devuelve 0 si son iguales.
• Devuelve un número positivo si el objeto
actual es mayor.
Interface: [Link]
• Permite definir diferentes criterios de
ordenamiento.
• Útil para ordenar objetos sin modificar su
clase.
• Método clave: compare(T o1, T o2).
• Ejemplo: [Link](lista, comparador);
Interface: [Link]
• Definicion:
public interface Comparator<T> {
int compare(T o1, T o2);
}
Interface: [Link]
• Tiene un método principal:
• int compare(T o1, T o2)
Compara dos objetos:
– Devuelve negativo si o1 < o2
– Devuelve 0 si son iguales
– Devuelve positivo si o1 > o2
Interface: [Link]
Mejoras a las Interfaces en Java
SE 8
Interfaces Funcionales, Métodos
Default y Estáticos
Interfaces Funcionales
• Una interfaz funcional tiene un único método
abstracto.
• Se puede usar con expresiones lambda.
• Anotación: @FunctionalInterface.
• Ejemplo:
• Runnable,
• Comparator,
• Callable.
Métodos Default
• Permiten definir métodos con implementación
en interfaces.
• No obligan a que las clases implementadoras
los sobrescriban.
• Se usan con la palabra clave: default.
• Ayudan a extender interfaces sin romper
compatibilidad.
Métodos Estáticos en Interfaces
• Se pueden declarar métodos estáticos en
interfaces desde Java 8.
• Sólo se pueden invocar desde la propia
interfaz.
• Útiles para utilidades relacionadas con la
interfaz.
• No son heredados por clases
implementadoras.
Ejemplo de Código
@FunctionalInterface
interface Operacion {
int aplicar(int a, int b);
default void saludar() {
[Link]("Hola desde interfaz");
}
static void info() {
[Link]("Método estático");
}
}
Ejemplo de Código
@FunctionalInterface
nctionalInterface
@Fu
interface Operacion {
int aplicar(int a, int b);//metodo con retorno
}
public class Calculadora {
public static void main(String[] args) {
// Implementación usando expresión lambda
Operacion suma = (a, b) -> a + b;
Operacion multiplicacion = (a, b) -> a * b;
int resultado1 = [Link](10, 5); // 15
int resultado2 = [Link](10, 5); // 50
[Link]("Suma: " + resultado1);
[Link]("Multiplicación: " + resultado2);
}
}
Explicación rápida:
• @FunctionalInterface asegura que solo haya un
método abstracto, lo que permite usar lambdas.
• Aquí Operacion es una interfaz funcional.
• En main, se crean dlambdas: suma y
multiplicació[Link] operaciones con
• Se ejecutan mediante el método aplicar.
Interfaz Runnable en Java
Ejecutar código en hilos (threads)
¿Qué es Runnable?
• Runnable es una interfaz funcional en
[Link].
• Define una única operación: void run().
• Se usa para representar tareas que pueden
ejecutarse en un hilo.
• Permite separar el código de ejecución del
control del hilo.
Ejemplo Clásico de Runnable
class MiTarea implements Runnable {
public void run() {
[Link]("Ejecutando en un hilo");
}
}
public class Main {
public static void main(String[] args) {
Thread hilo = new Thread(new MiTarea());
[Link]();
}
}
Usando Runnable con Threads
• Se pasa una instancia de Runnable al
constructor de Thread.
• Luego se invoca el método start() para iniciar
el hilo.
• El método run() contiene el código a ejecutar.
Runnable con Expresión Lambda
public class Main {
public static void main(String[] args) {
Runnable tarea = () ->
[Link]("Desde hilo lambda"); //Imp
new Thread(tarea).start();
}
}
¿Qué es una expresión lambda?
• Es una forma mas facil de escribir una funcion
sin tener que escribir too el codigo del metodo
• Se integra desde JDK8 para usar en prog.
funcional
• Es una forma concisa de representar una
función anónima.
¿Qué es una expresión lambda?
Introducidas en Java SE 8 para facilitar
programación funcional.
Se conoce tambien como funciones anonimas
Para poder ser utilzada es necesario
implementar interfaces Funcionales
Sintaxis de las expresiónes lambda
Sin parametros: ()->Sentencia
Con un parametro: parametro->Sentencia
Con mas de un parametro:
(parametro1, parametro2)->Sentencia
Con mas de una sentencia:
(parametro)->{Sentencia1 ;
Sentencia2 ; }
Sintaxis de las expresiónes lambda
El lado izquierdo de la expresion representa los
parametro(Ninguno, uno o mas que se pasa a la
sentencia).
Parametro->Sentencia
Para poder ser utilzada es necesario
implementar interfaces Funcionales
interfaces Funcionales
• Es una interfaz que solo posee un solo método
abstracto (metodo que solo se declara pero no
se implementa)
• Usa Anotación opcional
• @FunctionalInterface
No es obligatoria, pero el compilador
verificará que la interfaz cumple la condición.
Interfaz Comparator en Java
Ordenamiento personalizado de
objetos
¿Qué es Comparator?
• Es una interfaz funcional en [Link].
• Permite definir el orden de objetos sin
modificar su clase.
• Método principal: int compare(T o1, T o2).
• Muy útil con colecciones y el método
[Link]().
Ventajas de Comparator
• Permite múltiples criterios de ordenamiento.
• Puede usarse con clases que no controlamos
(sin modificar).
• Compatible con expresiones lambda desde
Java 8.
• Más flexible que Comparable.
Ejemplo de Comparator
• import [Link].*;
// Clase Persona
class Persona {
String nombre;
int edad;
Persona(String nombre, int edad) {
[Link] = nombre;
[Link] = edad;
}
public String toString() {
return nombre + " (" + edad + " años)";
}
}
Comparator
// Comparator tradicional: ordenar por edad
class ComparadorEdad implements Comparator<Persona> {
public int compare(Persona p1, Persona p2) {
return [Link]([Link], [Link]);
}
}
public class Main {
public static void main(String[] args) {
List<Persona> personas = new ArrayList<>();
[Link](new Persona("Ana", 30));
[Link](new Persona("Luis", 25));
[Link](new Persona("Carlos", 40));
Comparator
// Ordenar usando Comparator tradicional
[Link](personas, new ComparadorEdad());
[Link]("Ordenados por edad (tradicional):");
for (Persona p : personas) {
[Link](p);
}
// Ordenar por nombre usando lambda
[Link]((p1, p2) -> [Link]([Link]));
[Link]("\nOrdenados por nombre (lambda):");
for (Persona p : personas) {
[Link](p);
}
}
}
¿Qué muestra este ejemplo?
• Se define un Comparator personalizado que
ordena personas por edad.
• También se muestra cómo usar una expresión
lambda para ordenar por nombre.
• El método compare compara los atributos
deseados.
Uso de Comparator con Lambda
List<Persona> personas = new ArrayList<>();
[Link](new Persona("Ana", 30));
[Link](new Persona("Luis", 25));
// Ordenar por edad usando lambda
[Link]((p1, p2) -> [Link] - [Link]);
for (Persona p : personas) {
[Link]([Link] + ": " + [Link]);
}
Interfaz Callable en Java
Tareas que retornan resultados o
lanzan excepciones
¿Qué es Callable?
• Es una interfaz genérica de
[Link].
• Representa una tarea que devuelve un
resultado y puede lanzar excepciones.
• Similar a Runnable, pero con retorno y
manejo de excepciones.
• Método único: V call() throws Exception.
Uso con ExecutorService
• Callable se usa comúnmente con
ExecutorService.
• El método submit() devuelve un Future que
contiene el resultado.
• [Link]() obtiene el resultado, bloqueando
si es necesario.
Ejemplo de uso de Callable
import [Link].*;
public class EjemploCallable {
public static void main(String[] args) throws Exception {
ExecutorService executor =
[Link]();
Callable<String> tarea = () -> "Resultado de la tarea";
Future<String> futuro = [Link](tarea);
[Link]([Link]());
[Link]();
}
}
Explicacion
• Se importan clases del
paquete [Link], necesarias para
concurrencia con hilos (threads) y tareas.
import [Link].*;
Explicacion
• Creación del ExecutorService
• ExecutorService executor = [Link]();
• Se crea un ejecutor con un solo
hilo (SingleThreadExecutor).
• Este se usa para ejecutar tareas en segundo
plano.
Explicacion
• 3. Definición de la tarea con Callable
• Callable<String> tarea = () -> "Resultado de la
tarea";
• Se crea una tarea usando la interfaz
funcional Callable.
• A diferencia de Runnable, Callable devuelve
un valor (String en este caso).
• Esta tarea solo devuelve "Resultado de la
tarea" cuando se ejecuta.
Explicacion
• Enviar la tarea al ejecutor.
• Future<String> futuro = [Link](tarea);
• Se envía la tarea al executor.
• submit() devuelve un Future, que es un objeto
que representará el resultado de la tarea
cuando esté listo.
Explicacion
• Obtener el resultado:
• [Link]([Link]());
• [Link]() espera a que la tarea termine y
luego devuelve el resultado ("Resultado de la
tarea").
• Si la tarea aún no ha terminado, este
método bloquea el hilo hasta que lo haga.
Explicacion
• Cerrar el ejecutor:
[Link]();
• Se apaga el executor correctamente para
liberar recursos.
Explicacion
¿Qué hizo el programa con esto?
• Cómo ejecutar tareas en segundo plano
con Callable.
• Cómo usar ExecutorService para ejecutar
tareas.
• Cómo recuperar resultados de esas tareas
con Future.
Interfaz Future
En Java, Future es una interfaz que representa
el resultado de una tarea asincrónica. Es parte
del paquete [Link]
Interfaz Future
¿Qué es Future?
Es un "futuro resultado" que puede no estar
disponible todavía, pero estará
disponible eventualmente.
• Se utiliza junto con ExecutorService cuando se
envía una tarea Callable (o Runnable con valor de
retorno).
• Permite controlar o consultar el estado de una
tarea que se está ejecutando en segundo plano.
Interfaz Future -Metodos
| Método | Descripción
|
| get() | Espera y devuelve el resultado cuando esté
listo. Puede lanzar `InterruptedException` o `ExecutionException`. |
| get (timeout, unit) | Espera solo el tiempo indicado, y lanza
`TimeoutException` si expira. |
| cancel(boolean mayInterruptIfRunning) | Intenta cancelar la ejecución de
la tarea. |
| isDone() | Devuelve `true` si la tarea ya terminó (con éxito,
error o cancelación). |
| isCancelled() | Devuelve `true` si la tarea fue cancelada.
|
Ejemplo
import [Link].*;
public class EjemploFuture {
public static void main(String[] args) throws Exception {
ExecutorService executor =
[Link]();
Callable<String> tarea = () -> {
[Link](2000); // simula trabajo
return "Hola desde el futuro";
};
Ejemplo
Future<String> futuro = [Link](tarea);
[Link]("Esperando resultado...");
String resultado = [Link](); // Espera que termine la
tarea
[Link]("Resultado: " + resultado);
[Link]();
}
}
Explicacion
• En resumen:
• Future se usa para tareas que devuelven un
valor en el futuro.
• Permite controlar su estado y
manejar resultados asincrónicos.
• Es útil para la programación concurrente en
Java.
Explicacion
• ¿Qué significa “asincrónico”?
• Sincrónico: el programa espera a que una
operación termine antes de continuar.
• Asincrónico: el programa no espera, sino
que sigue ejecutándose mientras otra tarea se
completa en segundo plano.
Executor en Java
Manejo de tareas en hilos de forma
flexible
¿Qué es Executor?
• Es una interfaz del paquete
[Link].
• Permite ejecutar tareas en segundo plano sin
gestionar directamente los hilos.
• Se usa como una alternativa a crear y manejar
hilos manualmente.
• Define un solo método: execute(Runnable
command).
ExecutorService
• Es una subinterfaz de Executor.
• Permite manejar tareas asincrónicas con más
control.
• Métodos comunes: submit(), shutdown(),
invokeAll(), etc.
• • Devuelve objetos Future para obtener
resultados.
Ejemplo básico de uso
import [Link].*;
public class EjemploExecutor {
public static void main(String[] args) {
ExecutorService executor =
[Link]();
[Link](() -> [Link]("Tarea
ejecutada"));
[Link]();
}
}
Ejemplo básico de uso
¿Qué pasa aquí?
Se crea un ExecutorService con un solo
hilo (newSingleThreadExecutor).
Se envía una tarea (Runnable) con execute().
El mensaje "Tarea ejecutada" se imprime desde
ese hilo.
shutdown() apaga el executor al terminar.
¿Qué es el Polimorfismo?
• Capacidad de un objeto para tomar muchas
formas.
• Permite que una misma operación actúe de
diferentes maneras según el objeto.
• Facilita la extensibilidad y el mantenimiento
del código.
Tipos de Polimorfismo
1. Polimorfismo en tiempo de compilación
(sobrecarga de métodos)
2. Polimorfismo en tiempo de ejecución
(sobreescritura de métodos)
• Ejemplo:
class Animal { void sonido() { ... } }
class Perro extends Animal { void sonido() {
[Link]("Guau"); } }
Tipos de Polimorfismo
// Clase base
class Animal {
void hacerSonido() {
[Link]("El animal hace un sonido");
}
}
// Subclases que sobrescriben el método
class Perro extends Animal {
void hacerSonido() {
[Link]("El perro dice: Guau guau");
}
}
class Gato extends Animal {
void hacerSonido() {
[Link]("El gato dice: Miau");
}
}
Tipos de Polimorfismo
// Clase principal
public class EjemploPolimorfismo {
public static void main(String[] args) {
Animal miAnimal; // Variable de tipo Animal
miAnimal = new Perro(); // Polimorfismo
[Link](); // Salida: El perro dice: Guau guau
miAnimal = new Gato();
[Link](); // Salida: El gato dice: Miau
}
}