🧬

Les Génériques <T>

Écrire du code qui fonctionne avec n'importe quel type ! Une seule fois, réutilisable partout. C'est la puissance des génériques.

Démo interactive

La boîte générique Box<T>

Le T est un type que tu choisis. Sélectionne un type : la boîte se remplit du contenu correspondant et son étiquette Box<T> devient concrète. Une seule classe, tous les types, en sécurité.

Choisis un type pour remplir la boîte.

🍪 Analogie : Le Moule Universel

❌ Sans génériques

Tu as besoin d'une boîte pour ranger des strings ? Crée StringBox. Pour des nombres ? Crée NumberBox. Pour des users ? Crée UserBox...

📦📦📦📦📦

= Code dupliqué !

✅ Avec génériques

Crée une seule Box<T> ! T = le type que tu veux. Instancie Box<String>, Box<Int>, etc.

📦<T>

= Un seul code, tous les types !

📦 Démo Visuelle : Box<T>

La même "boîte" peut contenir différents types :

T ? Template

→

String 📝 "Hello"

Number 🔢 42

User 👤 alice

<T> est un placeholder (paramètre de type). À l'utilisation, T est remplacé par le type réel !

🎮 Démo Interactive : Choisis le Type

List<

❓

// Choisis un type pour voir le résultat

📝 Syntaxe des Génériques

📦 Classe Générique

public class Box<T> {
    private T content;

    public void set(T item) {
        this.content = item;
    }

    public T get() {
        return content;
    }
}

// Utilisation
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String value = stringBox.get(); // Pas de cast !

Box<Integer> intBox = new Box<>();
intBox.set(42);

🔧 Méthode Générique

public static <T> T getFirst(List<T> list) {
    return list.isEmpty() ? null : list.get(0);
}

// Le type est inféré automatiquement
String first = getFirst(List.of("a", "b", "c"));

📦 Classe Générique

class Box<T> {
    private content: T;

    set(item: T): void {
        this.content = item;
    }

    get(): T {
        return this.content;
    }
}

// Utilisation
const stringBox = new Box<string>();
stringBox.set("Hello");

const numBox = new Box<number>();
numBox.set(42);

🔧 Fonction Générique

function identity<T>(arg: T): T {
    return arg;
}

// Type inféré
const str = identity("hello");  // string
const num = identity(42);        // number

// Ou explicite
const explicit = identity<boolean>(true);

🔷 TypeScript : Les génériques permettent de garder le typage fort tout en étant flexible. Très utilisé dans les libs comme React (useState<T>) !

📦 Type Générique (Go 1.18+)

type Box[T any] struct {
    content T
}

func (b *Box[T]) Set(item T) {
    b.content = item
}

func (b *Box[T]) Get() T {
    return b.content
}

// Utilisation
stringBox := Box[string]{}
stringBox.Set("Hello")

intBox := Box[int]{}
intBox.Set(42)

🔧 Fonction Générique

func GetFirst[T any](slice []T) (T, bool) {
    if len(slice) == 0 {
        var zero T
        return zero, false
    }
    return slice[0], true
}

first, ok := GetFirst([]string{"a", "b"})

🐹 Go : Génériques ajoutés en Go 1.18 (2022). Utilise [T any] au lieu de <T>. any = sans contrainte.

📦 Classe Générique (Python 3.12+)

from typing import Generic, TypeVar

# Python 3.9-3.11
T = TypeVar('T')

class Box(Generic[T]):
    def __init__(self):
        self.content: T | None = None

    def set(self, item: T) -> None:
        self.content = item

    def get(self) -> T:
        return self.content

# Python 3.12+ (syntaxe simplifiée)
class Box[T]:
    content: T | None = None

# Utilisation
string_box: Box[str] = Box()
string_box.set("Hello")

🐍 Python : Les types sont des hints (indications), pas enforced au runtime ! Utile pour les IDE, mypy, et la documentation.

🔒 Contraintes sur les Types

Parfois, on veut limiter T à certains types. Par exemple : "T doit être comparable" ou "T doit être un nombre".

🔒

Java : extends

// T doit implémenter Comparable
public <T extends Comparable<T>>
    T max(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
}

🔒

TypeScript : extends

// T doit avoir une prop 'length'
function logLength<T extends {length: number}>
    (item: T): void {
    console.log(item.length);
}

🔒

Go : interface constraint

// T doit être un nombre
type Number interface {
    int | float64
}

func Sum[T Number](nums []T) T { ... }

🔒

Python : TypeVar bound

# T doit être une subclass de Animal
from typing import TypeVar
T = TypeVar('T', bound=Animal)

def feed(animal: T) -> T:
    animal.eat()
    return animal

⚖️ Avec vs Sans Génériques

Aspect	❌ Sans génériques	✅ Avec génériques
Type safety	Cast manuel, erreurs au runtime	Vérifié à la compilation
Duplication	StringList, IntList, UserList...	List<T> une seule fois
Lisibilité	`Object item = list.get(0);`	`String item = list.get(0);`
IDE support	Autocomplétion limitée	Suggestions typées
Refactoring	Risqué, erreurs cachées	Sûr, erreurs visibles

🎯 Exemples Concrets d'Usage

📦 Collections


                        List<User>

                        Map<String, Config>

                        Set<Permission>

⚡ Async/Promises


                        Promise<Response>

                        Future<Data>

                        CompletableFuture<Result>

🔧 React Hooks


                        useState<number>(0)

                        useRef<HTMLInputElement>()

                        useContext<ThemeContext>()

🌐 API Responses


                        ApiResponse<User[]>

                        Result<Data, Error>

                        Optional<Config>

🧠

Mode Survie : Génériques

Une erreur = Game Over ! 10 questions aléatoires.

🎉

Félicitations !

Tu as terminé le parcours Fondamentaux de la Programmation ! Des variables aux génériques, tu maîtrises maintenant les concepts essentiels.

🔄 Revoir depuis le début 🏠 Retour au Hub