Polymorphisme: Pourquoi utiliser " List list = new ArrayList "au lieu de"ArrayList list = new ArrayList"? [dupliquer]

cela s'appelle la programmation À l'interface. Cela sera utile au cas où vous souhaiteriez passer à une autre mise en œuvre de List à l'avenir. Si vous voulez quelques méthodes dans ArrayList alors vous devriez programmer à l'implémentation qui est ArrayList a = new ArrayList() .

cela est également utile lors de l'exposition d'une interface publique. Si vous avez une méthode comme celle-ci,

public ArrayList getList();

alors vous décidez de le changer en,

public LinkedList getList();

toute personne qui faisait ArrayList list = yourClass.getList() devra changer son code. D'autre part, si vous le faites,

public List getList();

changer l'implémentation ne change rien pour les utilisateurs de votre API.

je pense que la réponse de @tsatiz est plutôt juste (programmation vers une interface plutôt qu'une implémentation). Cependant, en programmant sur l'interface vous ne perdrez aucune fonctionnalité . Laissez-moi vous expliquer.



Si vous déclarez votre variable comme une List<type> list = new ArrayList<type> vous ne perdez pas réellement n'importe quelle fonctionnalité de L'ArrayList. Tout ce que vous devez faire est de jeter votre list à un ArrayList . Voici un exemple:

List<String> list = new ArrayList<String>();
((ArrayList<String>) list).ensureCapacity(19);

en fin de compte, je pense que tsatiz a raison car une fois que vous lancez sur un ArrayList, vous ne codez plus sur une interface. Cependant, c'est toujours une bonne pratique de coder d'abord à une interface et, si cela devient plus tard nécessaire, de coder à une implémentation si vous le devez.

Espère que ça aide!

cela vous permet d'écrire quelque chose comme:

void doSomething() {
    List<String>list = new ArrayList<String>();
    //do something
}

plus Tard, vous pouvez le modifier:

void doSomething() {
    List<String>list = new LinkedList<String>();
    //do something
}

sans devoir changer le reste de la méthode.

Cependant, si vous souhaitez utiliser un CopyOnWriteArrayList par exemple, vous devez le déclarer comme tel, et non comme une Liste de si vous vouliez utiliser ses méthodes supplémentaires (addIfAbsent par exemple):

void doSomething() {
    CopyOnWriteArrayList<String>list = new CopyOnWriteArrayList<String>();
    //do something, for example:
    list.addIfAbsent("abc");
}

j'utilise cette construction chaque fois que je ne veux pas ajouter de complexité au problème. C'est juste une Liste, pas besoin de dire quel genre de liste c'est, car ça n'a pas d'importance pour le problème. J'utilise souvent Collection pour la plupart de mes solutions, car à la fin, la plupart du temps, pour le reste du logiciel, ce qui importe vraiment, c'est le contenu qu'il contient, et je ne veux pas ajouter de nouveaux objets à la Collection.

d'Ailleurs, vous utilisez cette construction quand vous pensez que vous pouvez voulez modifier la mise en oeuvre de la liste que vous utilisez. Disons que vous utilisiez la construction avec un ArrayList, et que votre problème n'était pas sûr. Maintenant, vous voulez être thread-safe, et pour une partie de votre solution, vous changez d'utiliser un Vecteur, par exemple. Quant aux autres utilisations de cette liste, peu importe qu'il s'agisse d'un Araryliste ou D'un vecteur, juste une liste, aucune nouvelle modification ne sera nécessaire.

je suppose que le cœur de votre question est pourquoi program to an interface, not to an implementation

simplement parce qu'une interface vous donne plus d'abstraction, et rend le code plus flexible et résiliente aux changements, parce que vous pouvez utiliser différents implémentations de la même interface (dans ce cas, vous pouvez changer l'implémentation de votre liste en une liste de liens au lieu d'une liste de tableaux ) sans changer son client.

en général, vous voulez programmer contre une interface. Cela vous permet d'échanger l'implémentation à tout moment. C'est très utile surtout quand vous passez une implémentation que vous ne connaissez pas.

cependant, il y a certaines situations où vous préférez utiliser la mise en œuvre concrète. Par exemple quand serialize dans GWT.