Comprendre les génériques en Java : un exemple de panier d'achat avec des classes personnalisées

Les génériques Java sont essentiels pour écrire du code réutilisable et sécurisé. Ils permettent la création de classes, de méthodes et d'interfaces capables de gérer différents types de données, améliorant ainsi la robustesse et la flexibilité du code. Cet article illustre les génériques à l'aide d'un exemple de panier qui stocke différents types de fruits, représentés par des classes personnalisées.

---

Pourquoi des génériques ? Les limites des tableaux

Les tableaux Java sont spécifiques à un type ; un tableau d'un type ne peut pas contenir d'éléments d'un autre :

<code class="language-java">String[] fruits = new String[3];
fruits[0] = "Apple";  // Correct
fruits[1] = 123;      // Compile-time error</code>

Ce type de sécurité est bénéfique, mais les tableaux manquent de flexibilité. Créer un panier pour divers fruits (bananes, pommes, raisins) à l'aide de tableaux nécessiterait une manipulation manuelle fastidieuse.

Les génériques offrent une solution : des structures de données flexibles mais de type sécurisé. Construisons cela, en commençant par des classes Fruit personnalisées.

---

Étape 1 : Définir les classes de fruits

Nous définirons une classe de base Fruit et des sous-classes pour Banana, Apple et Grape, chacune avec des propriétés uniques.

<code class="language-java">// Base class for fruits
public abstract class Fruit {
    private String name;

    public Fruit(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// Specific fruit classes
public class Banana extends Fruit {
    public Banana() {
        super("Banana");
    }
}

public class Apple extends Fruit {
    public Apple() {
        super("Apple");
    }
}

public class Grape extends Fruit {
    public Grape() {
        super("Grape");
    }
}</code>

Justification abstraite de la classe

La classe Fruit est abstraite pour fournir des fonctionnalités communes (comme name) et établir une structure d'héritage claire. Une interface peut être préférable si plusieurs héritages ou des contrats plus simples sont nécessaires. Cela mérite une discussion plus approfondie !

---

Étape 2 : Créer un panier générique

Maintenant, construisons une classe ShoppingCart utilisant des génériques pour contenir n'importe quel type de fruit tout en maintenant la sécurité des types.

<code class="language-java">import java.util.ArrayList;

public class ShoppingCart<T extends Fruit> { // Restricts to Fruit and subclasses
    private ArrayList<T> items = new ArrayList<>();

    public void addItem(T item) {
        items.add(item);
    }

    public void removeItem(T item) {
        items.remove(item);
    }

    public void displayItems() {
        for (T item : items) {
            System.out.println(item.getName());
        }
    }
}</code>

T extends Fruit garantit que seul Fruit ou ses descendants peuvent être ajoutés, évitant ainsi les erreurs de type.

---

Étape 3 : Utiliser le panier

Voyons comment utiliser ShoppingCart avec nos objets fruités.

<code class="language-java">public class Main {
    public static void main(String[] args) {
        ShoppingCart<Fruit> fruitCart = new ShoppingCart<>();

        // Adding fruits
        fruitCart.addItem(new Banana());
        fruitCart.addItem(new Apple());
        fruitCart.addItem(new Grape());

        // Displaying contents
        System.out.println("Shopping Cart:");
        fruitCart.displayItems();

        // Removing an item
        fruitCart.removeItem(new Apple()); // Removal based on object equality (equals() can be overridden)
        System.out.println("\nAfter removing Apple:");
        fruitCart.displayItems();
    }
}</code>

---

Avantages des génériques

1. Sécurité des types : La restriction T empêche l'ajout de types incorrects.
2. Flexibilité : Le chariot gère tout Fruit type, favorisant la réutilisation.
3. Pas de diffusion : La récupération d'éléments ne nécessite aucune diffusion, ce qui réduit les erreurs d'exécution.

---

Conclusion

Cette Fruit hiérarchie et ShoppingCart exemple démontrent la puissance et la flexibilité des génériques Java. Les génériques améliorent la clarté et la maintenabilité du code, ce qui les rend inestimables pour les développeurs Java à tous les niveaux.

---

? Références

• Documentation des génériques Java
• Java efficace (Joshua Bloch)

? Connectez-vous avec moi

• LinkedIn
• GitHub
• Portefeuille

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!