¿Qué son las generalizaciones (Genéricos) en…

Las genéricos son un mecanismo en los lenguajes de programación que permite crear componentes (clases, interfaces, métodos/funciones) que trabajan con diferentes tipos de datos, sin perder la seguridad de tipos y sin necesidad de realizar conversiones de tipos (casting).

Los principales objetivos del uso de los genéricos:

Mejorar la seguridad de tipos: El compilador verifica los tipos en tiempo de compilación, detectando errores antes de ejecutar el programa.
Mejorar la legibilidad del código: Es claro con qué tipos de datos trabaja un componente.
Reutilización de código: Se puede crear un solo componente que funcione con diferentes tipos, en lugar de escribir varias versiones.
Reducir las conversiones de tipos: Elimina la necesidad de conversiones explícitas, haciendo el código más limpio y menos propenso a errores ClassCastException (en lenguajes donde esto aplica, por ejemplo, Java).

Ejemplos de uso de los genéricos:

Colecciones: Listas (List), conjuntos (Set), mapas (Map) pueden almacenar elementos de un tipo específico, garantizando que no se ingresen elementos de otro tipo.
Métodos/funciones: Un método puede trabajar con parámetros o devolver un valor de tipo universal.
Clases/interfaces: Se pueden crear estructuras de datos universales o patrones de comportamiento.

Ejemplo en Java:

// Clase genérica Pair
public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }
}

// Uso
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // No es necesario hacer casting
int num = pair.getSecond();   // No es necesario hacer casting

// Pair<String, Integer> wrongPair = new Pair<>(123, "Hello"); // Error de compilación: tipos incompatibles

Ejemplo en C#:

// Clase genérica Pair
public class Pair<T, U>
{
    public T First { get; set; }
    public U Second { get; set; }

    public Pair(T first, U second)
    {
        First = first;
        Second = second;
    }
}

// Uso
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // No es necesario hacer casting
int num = pair.Second;   // No es necesario hacer casting

// var wrongPair = new Pair<string, int>(123, "Hello"); // Error de compilación: tipos incompatibles

Ejemplo en TypeScript:

// Función genérica para obtener el primer elemento de un array
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Uso
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber tiene tipo number

let words: string[] = ["a", "b", "c"];
let firstWord = getFirstElement(words);   // firstWord tiene tipo string

// let mixedArray: (number | string)[] = [1, "a", 2];
// let firstMixed = getFirstElement(mixedArray); // firstMixed tiene tipo number | string

De esta forma, los genéricos son una herramienta poderosa para crear código flexible, seguro en tipos y reutilizable.

¿Qué son las generalizaciones (Genéricos) en programación?