Programación orientada a objetos

1.1 Del código fuente a la ejecución

• Código fuente → compilación (traducción a código máquina/objeto por un compilador) o interpretación (ejecución por un intérprete, que muchas veces traduce antes a bytecode en vez de leer línea a línea).
• Compilados (C, C++, Rust): suelen ser rápidos y dependientes de la plataforma de destino. Interpretados (Python, JavaScript, PHP): suelen ser portables y más lentos. Son estrategias de implementación, no propiedades del lenguaje: CPython compila a bytecode y los motores de JavaScript y PHP pueden usar JIT.
• Híbridos / bytecode: Java y C# compilan a bytecode que ejecuta una máquina virtual (Java a bytecode para la JVM; C# a CIL para el CLR: no son lo mismo); "compila una vez, ejecuta en cualquier parte". A menudo con JIT (Just-In-Time).

1.2 Tipado y paradigmas

• Tipado estático (se comprueba en compilación: Java, C++) vs dinámico (en ejecución: Python, JS). Fuerte (limita las operaciones entre tipos incompatibles, p. ej. Python) vs débil (hace más conversiones implícitas, p. ej. JavaScript). La frontera es graduada: hasta los lenguajes «fuertes» admiten promociones numéricas implícitas (en Java, int → double).
• Ejemplos de tipado: débil (conversiones implícitas entre tipos, p. ej. "5" + 1 en PHP o JavaScript; C también opera tipos distintos sin avisar) frente a fuerte (Java y Python no mezclan tipos incompatibles sin una conversión explícita). PHP es el ejemplo clásico de lenguaje de tipado débil. Hay que decir lenguaje y versión: "5" + 1 da 6 en PHP, "51" en JavaScript, un TypeError en Python y "51" en Java (concatenación de cadenas, no conversión numérica). C también admite conversiones, con diagnósticos según el compilador y sus opciones.
• Paradigmas: imperativo/estructurado (secuencia, C), orientado a objetos (Java, C++, Python), funcional (Haskell, y rasgos en JS/Python), declarativo (SQL). Un lenguaje puede ser multiparadigma. En el declarativo se dice qué se quiere y no cómo: lógico (Prolog), funcional (Haskell) y consultas (SQL); Java, C y PHP son imperativos. PHP (imperativo, OO, funcional y reflexivo), Java (imperativo, OO, reflexivo y genérico), Python (imperativo, OO, reflexivo y funcional) y Ruby (OO, imperativo, funcional y reflexivo) son multiparadigma.
• Programación estructurada: el teorema de Böhm-Jacopini (1966) demuestra que cualquier programa se puede escribir con solo tres estructuras de control: secuencia, selección (condicional) e iteración (bucle), sin saltos GOTO. «Booleano» es un tipo de dato, no una estructura de control.
• Niveles: código máquina (binario, lo ejecuta la CPU), ensamblador (bajo nivel: instrucciones simbólicas ligadas a una arquitectura) y alto nivel (Java, Python, PHP: independientes de la máquina, se compilan o interpretan).

1.3 Estructuras de datos

Una estructura de datos organiza varios valores en memoria para poder consultarlos y modificarlos con eficiencia. Se clasifican por la forma de relacionar sus elementos y por si su tamaño es fijo o crece:

Estructura	Tipo	Cómo se accede	Ejemplo
Array (vector)	Lineal y estática (tamaño fijo en el modelo convencional; un Array de JavaScript o una lista dinámica sí cambian de longitud)	Por posición (índice)	Las 24 horas del día
Lista	Lineal y dinámica	Recorriéndola desde el principio, o por posición según la implementación	Lista de reproducción
Pila	Lineal y dinámica; LIFO (Last In, First Out: el último en entrar es el primero en salir)	Solo por la cima	Deshacer (undo)
Cola	Lineal y dinámica; FIFO (First In, First Out: el primero en entrar es el primero en salir)	Se entra por el final y se sale por el principio	Cola de impresión
Árbol	No lineal y dinámica: jerarquía con una raíz, ramas y hojas	Desde la raíz	Carpetas de un disco
Grafo	No lineal y dinámica: nodos (vértices) unidos por aristas	Siguiendo las aristas	Red de routers

Tipos abstractos de datos (TAD). Un TAD es una colección de datos y de operaciones definida por una especificación independiente de cualquier representación; se puede describir en lenguaje natural, en pseudocódigo o en un lenguaje de programación. Permite encapsular la lógica y dar abstracción a las capas superiores. En Java, la interfaz especifica las operaciones del TAD y es la clase la que las implementa (no al revés). Hay que separar el TAD de su representación: una pila, una cola, un árbol o un grafo se pueden representar con memoria fija (un array) o dinámica (nodos enlazados).

• Pila: LIFO con push (apilar), pop (desapilar) y peek (ver la cima), siempre por un único extremo. Se implementa con un array o con una estructura dinámica (lista enlazada).
• Cola: FIFO; se inserta por el final (enqueue) y se extrae por el principio (dequeue). Se implementa con array (circular) o con lista enlazada; no es LIFO ni permite insertar por cualquier extremo (eso es una bicola o deque). Una lista con enlace al siguiente y al anterior es una lista doblemente enlazada.
• Árboles: binario de búsqueda (cada nodo tiene a la izquierda claves menores y a la derecha mayores); árbol B (multicamino y equilibrado, con todas las hojas al mismo nivel; es el de los índices de las bases de datos); árbol 2-3-4 (un árbol B de orden 4: los nodos son 2-nodos, 3-nodos o 4-nodos, con 2, 3 o 4 hijos en los nodos internos —las hojas tienen cero—, no es un árbol binario (un nodo guarda varias claves) aunque mantiene las claves ordenadas, y se reestructura al descender o ascender según el algoritmo, sin dejar hojas a distinto nivel). En el binario de búsqueda hay que decidir cómo tratar las claves duplicadas (rechazarlas o ponerlas siempre a un lado).
• Grafos: nodos (vértices) y aristas, dirigidos o no, ponderados o no; se guardan con matriz o lista de adyacencia. Se recorren en profundidad (DFS, con pila o recursión) o en anchura (BFS, con cola); son algoritmos de búsqueda en grafos.
• Algoritmos de ordenación: burbuja (O(n²), simple), quicksort (O(n log n) de media) y mergesort (O(n log n), por mezcla). No son de grafos. Al citar la complejidad se indica el caso (mejor, medio, peor), la memoria y la estabilidad: quicksort es O(n²) en el peor caso y no es estable; mergesort es estable pero necesita memoria auxiliar O(n).

⚠ Cae en examen. Un árbol es un tipo de datos estructurado, dinámico y no lineal; pilas, colas y listas son lineales. Pila = LIFO, cola = FIFO; ambas se pueden implementar con arrays o con estructuras dinámicas. DFS/BFS recorren grafos; quicksort, mergesort y burbuja ordenan.

⚠ Cae en examen. Compilado (C/C++) vs interpretado (Python/JS) vs bytecode/JVM (Java). Tipado estático (compilación) vs dinámico (ejecución). POO es un paradigma.