Quelle est la principale différence entre `HashMap map = new HashMap();` et `Map map = new HashMap();` en Java ?

Distinction entre HashMap et Map en Java

Lors de la définition de cartes en Java, les utilisateurs peuvent rencontrer des variations telles que :

HashMap<String, Object> map = new HashMap<String, Object>();
Map<String, Object> map = new HashMap<String, Object>();

Sous-jacent Object

Malgré ces différences, les deux déclarations de map aboutissent au même objet sous-jacent : un HashMap. La distinction réside dans l'interface par laquelle on accède à l'objet.

Différence d'interface

Dans le premier cas, le type d'interface est HashMap, fournissant accès direct aux méthodes spécifiques à HashMap. Dans le deuxième cas, le type d'interface est Map, offrant une interface plus générique au HashMap sous-jacent.

Codage vers les interfaces

Généralement, il Il est recommandé de coder sur l'interface la plus abstraite (Map ici) plutôt que sur une implémentation spécifique (HashMap). Cela permet une certaine flexibilité dans la modification de l'implémentation sous-jacente sans casser le code existant.

Exemple de rupture de contrat

Considérons une classe Foo avec deux HashMaps :

class Foo {
    private HashMap<String, Object> things;
    private HashMap<String, Object> moreThings;

    // Getters and methods using HashMaps
}

Une sous-classe SpecialFoo utilise des choses et plus de choses via des méthodes qui attendent HashMaps :

class SpecialFoo extends Foo {
    // Methods using HashMaps
}

Si Foo est mis à jour ultérieurement pour utiliser TreeMaps au lieu de HashMaps, la signature de type des choses et plus change. En conséquence, SpecialFoo tombe en panne car il attend des HashMaps mais reçoit maintenant des TreeMaps.

Solution : Déclarer les collections comme interfaces

Pour éviter de telles ruptures de contrat, déclarez les collections comme l'interface la plus abstraite possible :

class Foo {
    private Map<String, Object> things;
    private Map<String, Object> moreThings;

    // Getters and methods using Maps
}

Cette approche garantit que SpecialFoo ne se brisera pas si Foo's changements de mise en œuvre.

Avantages du codage pour les interfaces

• Flexibilité et maintenabilité accrues
• Risque réduit de rupture de contrat
• Adhésion aux principes de conception de logiciels (par exemple, encapsulation, dépendance) inversion)

Par conséquent, même si les deux déclarations de carte peuvent sembler différentes, elles aboutissent au même objet sous-jacent. Les meilleures pratiques imposent de coder sur l'interface la plus abstraite pour préserver la flexibilité et éviter les ruptures de code.

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!