Paradigmas de Programación

Tabla Resumen

1. Paradigma Imperativo

El programa es una secuencia de instrucciones que modifican el estado del sistema.

• Base de casi todos los demás paradigmas.
• El programador describe paso a paso cómo llegar al resultado.

int suma = 0;
suma = suma + 5;
suma = suma * 2;

2. Paradigma Procedimental

Extensión del imperativo que organiza el código en procedimientos o funciones reutilizables.

• Favorece la modularidad y reutilización.
• Flujo de ejecución guiado por llamadas a subrutinas.

int calcularArea(int base, int altura) {
    return base * altura;
}

3. Paradigma Estructurado

Subconjunto del procedimental que elimina el uso de goto en favor de estructuras de control claras.

• Usa bloques: secuencia, selección (if/else), iteración (for/while).
• Mejora la legibilidad y mantenibilidad del código.

4. Paradigma Orientado a Objetos (OOP)

El programa se organiza como un conjunto de objetos que encapsulan estado (atributos) y comportamiento (métodos).

Cuatro pilares:

┌────────────────────────────────────────────────────┐
│  ENCAPSULACIÓN   │ Ocultar estado interno           │
│  HERENCIA        │ Reutilizar comportamiento         │
│  POLIMORFISMO    │ Un método, múltiples formas       │
│  ABSTRACCIÓN     │ Modelar entidades del mundo real  │
└────────────────────────────────────────────────────┘

class Animal {
    String nombre;
    void hablar() { System.out.println("..."); }
}
class Perro extends Animal {
    void hablar() { System.out.println("Guau"); }  // Polimorfismo
}

OOP por Prototipos (JavaScript)

En lugar de clases, los objetos heredan directamente de otros objetos (prototipo).

const animal = { hablar() { console.log("..."); } };
const perro = Object.create(animal);
perro.hablar = () => console.log("Guau");

5. Paradigma Funcional

El programa es una composición de funciones puras (sin efectos secundarios).

Conceptos clave:

# Función pura + ciudadanos de primera clase
cuadrado = lambda x: x ** 2
resultado = list(map(cuadrado, [1, 2, 3]))  # [1, 4, 9]

6. Paradigma Genérico

Permite escribir código parametrizado por tipos, reutilizable para distintos tipos de datos sin duplicación.

// Java Generics
List<String> nombres = new ArrayList<>();
List<Integer> numeros = new ArrayList<>();

// C++ Templates
template<typename T>
T maximo(T a, T b) { return a > b ? a : b; }

7. Paradigma Concurrente

Diseñado para la ejecución simultánea de tareas (hilos, procesos).

• Gestiona sincronización, exclusión mutua y comunicación entre procesos.
• Presente en Java (Thread, synchronized), C# (async/await), C++ (std::thread).

Thread t = new Thread(() -> System.out.println("Hilo paralelo"));
t.start();

8. Paradigma Reflexivo

Capacidad del programa de inspeccionar y modificar su propia estructura en tiempo de ejecución.

# Python - reflexión
clase = type(objeto)          # Obtener tipo
metodos = dir(objeto)         # Listar métodos
getattr(objeto, "nombre")     # Acceder a atributo dinámicamente

// Java - Reflection API
Class<?> c = obj.getClass();
Method m = c.getMethod("miMetodo");
m.invoke(obj);

9. Paradigma Dirigido por Eventos

El flujo del programa está determinado por eventos (acciones del usuario, mensajes, señales).

• Muy usado en interfaces gráficas y aplicaciones web.
• El código define listeners/handlers que reaccionan a eventos.

document.getElementById("btn").addEventListener("click", () => {
    console.log("Botón pulsado");
});

10. Paradigma Asíncrono

Permite que tareas largas se ejecuten sin bloquear el hilo principal, usando callbacks, promesas o async/await.

async function cargarDatos() {
    const datos = await fetch("https://api.ejemplo.com/datos");
    return datos.json();
}

Lenguajes y sus Paradigmas

Comparativa: OOP vs Funcional

Árbol de Relaciones entre Paradigmas

DECLARATIVO ─────────────────────────────────────────────┐
                                                          │
IMPERATIVO                                                │
    ├── Procedimental                                     │
    │       └── Estructurado                              │
    ├── Orientado a Objetos                               │
    │       ├── OOP por Clases (Java, C++, C#, Python)    │
    │       └── OOP por Prototipos (JavaScript)           │
    ├── Funcional ──────────────────────────────────────► (también declarativo)
    ├── Genérico
    ├── Concurrente
    ├── Reflexivo
    ├── Dirigido por Eventos
    └── Asíncrono

⚠️ La mayoría de los lenguajes modernos son multiparadigma: permiten combinar estilos según la necesidad del problema.

Resumen en 3 puntos

1. Los paradigmas son estilos o enfoques para estructurar y razonar sobre el código. No son excluyentes: un mismo lenguaje puede soportar varios (multiparadigma).

2. Los tres paradigmas más importantes en oposiciones son: Imperativo (base de casi todo), OOP (objetos con encapsulación, herencia, polimorfismo y abstracción) y Funcional (funciones puras, inmutabilidad, ciudadanos de primera clase).

3. JavaScript es el lenguaje más "especial" de la tabla: usa herencia por prototipos (no por clases al estilo Java/C#), tiene funciones de primera clase como ciudadanos nativos, y su modelo asíncrono y dirigido por eventos es parte central del lenguaje (event loop).