Explication détaillée du mécanisme composite en Java

Cet article présente principalement les informations pertinentes sur les exemples détaillés du mécanisme composite en Java. J'espère qu'à travers cet article, vous pourrez comprendre la différence entre l'héritage et la composition et appliquer le mécanisme de composition. Les amis dans le besoin pourront s'y référer.

Explication détaillée d'exemples de mécanisme composite en Java

Les défauts d'héritage

Les défauts d'héritage sont causés par sa fonction trop puissante. L'héritage rend la sous-classe dépendante de l'implémentation de la superclasse. De ce point de vue, elle ne respecte pas le principe d'encapsulation.
Une fois que la superclasse change avec une version, la sous-classe peut être cassée, même si son code n'a pas changé du tout.

Afin d'expliquer plus précisément, en supposant que nous utilisons maintenant HashSet dans notre programme, nous devons ajouter une fonction pour compter le nombre d'éléments qui ont été ajoutés à ce HashSet depuis sa création.

Sans connaître les défauts de l'héritage, nous avons conçu une classe qui a hérité de HashSet, ajouté un attribut addCount pour les statistiques et remplacé les méthodes add et addAll dans la méthode Modifier la valeur de addCount,

Le code est le suivant :

public class InstrumentedHashSet<E> extends HashSet<E> { 
  // The number of attempted element insertions 
  private int addCount = 0; 
 
  public InstrumentedHashSet() { 
  } 
 
  public InstrumentedHashSet(int initCap, float loadFactor) { 
    super(initCap, loadFactor); 
  } 
 
  @Override public boolean add(E e) { 
    addCount++; 
    return super.add(e); 
  } 
 
  @Override public boolean addAll(Collection<? extends E> c) { 
    addCount += c.size(); 
    return super.addAll(c); 
  } 
 
  public int getAddCount() { 
    return addCount; 
  } 
 
}

Cette classe semble raisonnable, mais elle ne fonctionne pas correctement :

public static void main(String[] args) { 
  InstrumentedHashSet<String> s = 
    new InstrumentedHashSet<String>(); 
  s.addAll(Arrays.asList("Snap", "Crackle", "Pop"));   
  System.out.println(s.getAddCount()); // expect 3 but 6 
}

Comme seuls trois éléments ont été insérés, nous nous attendions à ce que la méthode getAddCount renvoie 3, mais en fait, elle a renvoyé 6. Qu'est-ce qui ne va pas ?

En fait, dans HashSet, la méthode addAll est implémentée sur la base de la méthode add. Par conséquent, utiliser addAll pour ajouter trois éléments appellera addAll une fois et ajoutera trois fois.

En regardant notre méthode de substitution, nous comprendrons pourquoi getAddCount renvoie 6.

Bien sûr, vous direz que puisque HashSet est implémenté comme ceci, nous n'avons pas besoin de remplacer la méthode addAll. Oui, c'est vrai.

Mais bien que cela puisse fonctionner normalement, son exactitude dépend du fait que la méthode addll de HashSet est implémentée sur la méthode add.

Une fois que la super classe modifie les détails d'implémentation, nos fonctionnalités peuvent être affectées.

En général, l'héritage présente trois défauts naturels, qui vont rendre le logiciel très fragile :

1) Si la sous-classe appelle la méthode de la classe parent, alors elle se formera une dépendance sur la classe parent. Une fois la classe parent modifiée, la sous-classe peut ne pas fonctionner correctement.

2) Si la classe parent ajoute une nouvelle méthode et que la sous-classe fournit déjà une méthode avec la même signature mais une valeur de retour différente, alors la sous-classe ne pourra pas compiler.
3) Utiliser l'héritage alors que cela ne devrait pas être fait exposera des API inutiles aux sous-classes. À cet égard, la plate-forme Java a commis des erreurs.Un exemple typique est que Properties hérite de HashTable, ce qui est déraisonnable. La liste de propriétés n'est pas une table de hachage, mais les propriétés du code Java héritent de HashTable. crée une instance Properties, il existe un put. Il existe deux méthodes, setProperties et getProperties. Les méthodes put et get ne doivent pas être exposées aux utilisateurs.
Parce que dans Propriétés, la clé et la valeur doivent être une chaîne, tandis que HashMap peut être d'autres types ou même des objets.

public class TestProperty { 
  public static void main(String[] args) { 
    Properties properties = new Properties(); 
    properties.setProperty("aaa", "aaa"); 
    properties.put("aaa", new TestPropertyObj()); 
    System.out.println(properties.getProperty("aaa")); // null 
    System.out.println(properties.get("aaa")); // com.hzy.effjava.chp3.item16.TestProperty$TestPropertyObj@5f4fcc96 
  } 
  static class TestPropertyObj { 
     
  } 
}

Alternatives composites à l'héritage

La section précédente a parlé des lacunes de l'héritage. Dans cette section, examinons la solution à ce problème : la composition.

Nous avons d'abord besoin d'une classe qui contient un objet Set. Cette classe implémente l'interface Set. La méthode d'implémentation appelle la méthode correspondante de l'objet Set détenu, nous l'appelons donc également Class :

public class ForwardingSet<E> implements Set<E> { 
  private final Set<E> s; 
  public ForwardingSet(Set<E> s) { this.s = s; } 
 
  public void clear()        { s.clear();      } 
  public boolean contains(Object o) { return s.contains(o); } 
  public boolean isEmpty()     { return s.isEmpty();  } 
  public int size()         { return s.size();   } 
  public Iterator<E> iterator()   { return s.iterator(); } 
  public boolean add(E e)      { return s.add(e);   } 
  public boolean remove(Object o)  { return s.remove(o);  } 
  public boolean containsAll(Collection<?> c) 
                  { return s.containsAll(c); } 
  public boolean addAll(Collection<? extends E> c) 
                  { return s.addAll(c);   } 
  public boolean removeAll(Collection<?> c) 
                  { return s.removeAll(c);  } 
  public boolean retainAll(Collection<?> c) 
                  { return s.retainAll(c);  } 
  public Object[] toArray()     { return s.toArray(); } 
  public <T> T[] toArray(T[] a)   { return s.toArray(a); } 
  @Override public boolean equals(Object o) 
                    { return s.equals(o); } 
  @Override public int hashCode()  { return s.hashCode(); } 
  @Override public String toString() { return s.toString(); } 
}

Ensuite, nous pouvons concevoir une classe avec des fonctions statistiques. Il nous suffit d'hériter de la classe de transfert que nous venons de créer, puis de compter. Il suffit d'écrire la logique. code :

public class InstrumentedSet<E> extends ForwardingSet<E> { 
  private int addCount = 0; 
 
  public InstrumentedSet(Set<E> s) { 
    super(s); 
  } 
 
  @Override public boolean add(E e) { 
    addCount++; 
    return super.add(e); 
  } 
  @Override public boolean addAll(Collection<? extends E> c) { 
    addCount += c.size(); 
    return super.addAll(c); 
  } 
  public int getAddCount() { 
    return addCount; 
  } 
 
  public static void main(String[] args) { 
    InstrumentedSet<String> s = 
      new InstrumentedSet<String>(new HashSet<String>()); 
    s.addAll(Arrays.asList("Snap", "Crackle", "Pop"));   
    System.out.println(s.getAddCount()); 
  } 
}

Cette méthode d'implémentation évite tous les problèmes mentionnés dans la section précédente Puisque l'héritage n'est pas utilisé, il n'est pas utilisé. Selon la logique d'implémentation. de la super classe, il n'y a pas lieu de s'inquiéter de l'impact sur nous des nouvelles méthodes ajoutées par la super classe.

Et il y a un autre avantage à écrire de cette façon. Cette classe peut ajouter des fonctions statistiques à toutes les classes qui implémentent l'interface Set, pas seulement HashSet, mais aussi d'autres Sets tels que TreeSet.

En fait, c'est le mode de décoration. InstrumentedSet modifie Set et lui ajoute un attribut de comptage.

Résumé

L'héritage détruira l'encapsulation de la classe, rendant la sous-classe très fragile et facilement endommagée.

Utilisez la méthode composée pour modifier la super classe afin de rendre la sous-classe plus robuste et plus puissante.

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!