La différence entre l'Héritage et la Composition

Ils sont absolument différentes. L'héritage est un "est-un" relation. La Composition est un "a-un".

Vous n'composition de disposer d'une instance d'une autre classe C comme un champ de votre classe, au lieu de l'étendre C. Un bon exemple de cas où la composition aurait été beaucoup mieux que l'héritage est java.util.Stack, qui s'étend actuellement java.util.Vector. Ce qui est maintenant considéré comme une faute. Une pile "est-PAS-un" vecteur; vous ne devriez pas être autorisé à insérer et supprimer des éléments de manière arbitraire. Il aurait été de la composition à la place.

Malheureusement il est trop tard pour rectifier cette erreur de conception, puisque la modification de la hiérarchie d'héritage, maintenant casser la compatibilité avec le code existant. Avait Stack utilisé composition à la place de l'héritage, il peut toujours être modifié pour utiliser une autre structure de données sans violer l'API.

Je recommande fortement Josh Bloch livre Efficace Java 2nd Edition

• Article 16: Favoriser la composition au cours de l'héritage
• Article 17: la Conception et le document de l'héritage ou de l'autre de l'interdire

Bonne conception orientée objet n'est pas sur-le généreusement l'extension de classes existantes. Votre premier réflexe doit être de composer à la place.

---

Voir aussi:

• Composition rapport à l'Héritage: Un examen Comparatif de Deux Façons Fondamentales de Relier les Classes

La façon dont l'héritage peut-il être dangereux ?

Permet de prendre un exemple

public class X{    
   public void do(){    
   }    
}    
Public Class Y extends X{
   public void work(){    
       do();    
   }
}

1) en clair dans le code ci-dessus , la Classe Y a un très fort couplage avec la classe de X. Si rien ne change dans la super-classe X , Y peut rompre de façon spectaculaire. Supposons que Dans l'avenir la classe X met en œuvre une méthode de travail avec les dessous de la signature

public int work(){
}

Est fait dans la classe X, mais il fera de la classe Y uncompilable. DONC, cette forme de dépendance peut aller jusqu'à n'importe quel niveau et il peut être très dangereux. Chaque fois que super-classe peut ne pas avoir une visibilité complète de code à l'intérieur de l'ensemble de ses sous-classes et sous-classe peut être continuer à observer ce qui se passe dans la super-classe de tous les temps. Nous devons donc éviter cette forte et inutile de couplage.

Comment la composition permet de résoudre ce problème?

Permet de voir en révisant le même exemple

public class X{
    public void do(){
    }
}

Public Class Y{
    X x = new X();    
    public void work(){    
        x.do();
    }
}

Ici, nous créons de référence de la classe X dans Y de la classe et de l'invocation de la méthode de la classe X par la création d'une instance de la classe X.
Maintenant, tout ce que le couplage fort est allé. Super-classe et sous-classe sont très indépendants les uns des autres maintenant. Les Classes peuvent librement faire des modifications qui ont été dangereux dans l'héritage de la situation.

2) Deuxième très bon parti de la composition en ce qu'Il prévoit l'appel de méthode de flexibilité, par exemple :

class X implements R
{}
class Y implements R
{}

public class Test{    
    R r;    
}

Dans la classe de Test à l'aide de r référence que je peux appeler des méthodes de X et Y de la classe. Cette flexibilité n'a jamais été là, dans l'héritage

3) un Autre grand avantage : les tests Unitaires

public class X {
    public void do(){
    }
}

Public Class Y {
    X x = new X();    
    public void work(){    
        x.do();    
    }    
}

Dans l'exemple ci-dessus, si l'état de x instance n'est pas connu, il peut facilement se moque de lui à l'aide de quelques données de test et toutes les méthodes peuvent être facilement testés. Ce n'était pas possible dans l'héritage que vous ont été fortement tributaire de la superclasse pour obtenir l'état de l'instance et d'exécuter n'importe quelle méthode.

4) une Autre bonne raison pourquoi on devrait éviter l'héritage est que Java ne supporte pas l'héritage multiple.

Prenons un exemple pour comprendre ceci :

Public class Transaction {
    Banking b;
    public static void main(String a[])    
    {    
        b = new Deposit();    
        if(b.deposit()){    
            b = new Credit();
            c.credit();    
        }
    }
}

Bon à savoir :

1. composition est facile à réaliser au moment de l'exécution, tandis que l'héritage donne ses caractéristiques au moment de la compilation

2. composition est également connu comme A-UNE relation et l'héritage est également connu comme UN rapport

Donc prenez l'habitude de toujours préférant la composition au cours de l'héritage, pour diverses raisons ci-dessus.

Héritage apporte EST-UN relation. Composition apporte A-UNE relation.
Modèle de stratégie d'expliquer que la Composition doit être utilisé dans les cas où il y a des familles d'algorithmes de la définition d'un comportement particulier.
Exemple classique étant d'un canard de la classe qui implémente un comportement de vol d'.

public interface Flyable{
 public void fly();
}

public class Duck {
 Flyable fly;

 public Duck(){
  fly = new BackwardFlying();
 }
}

Ainsi, nous pouvons avoir plusieurs classes qui implémentent volant
par exemple:

public class BackwardFlying implements Flyable{
  public void fly(){
    Systemout.println("Flies backward ");
  }
}
public class FastFlying implements Flyable{
  public void fly(){
    Systemout.println("Flies 100 miles/sec");
  }
}

Avait-il été pour l'héritage, nous avons deux classes différentes d'oiseaux qui mettent en œuvre la volée en fonction, encore et encore. Donc, l'héritage et la composition sont complètement différents.

Sont la Composition et l'Héritage de la même manière?

Ils ne sont pas les mêmes.

Composition : Il permet à un groupe d'objets doivent être traités de la même façon qu'une seule instance d'un objet. L'intention d'un composite est de "composer" des objets dans une structure d'arbre à représentent la partie-ensemble de hiérarchies

L'héritage: Une classe hérite des champs et des méthodes à partir de l'ensemble de ses super-classes, qu'elle soit directe ou indirecte. Une sous-classe peut remplacer les méthodes qu'il hérite, ou il peut masquer des champs ou méthodes qu'il hérite.

Si je veux mettre en œuvre la composition de modèles, comment puis-je le faire en Java?

Wikipédia l'article est assez bon pour mettre en œuvre composite modèle en java.

Des Participants Clés:

Composant:

1. Est l'abstraction de tous les composants, y compris composite ceux
2. Déclare l'interface pour les objets dans le composition

Feuille:

1. Représente les objets de la feuille dans le composition
2. Met en œuvre tous les Composant méthodes

Composite:

1. Représente un composite Component (composant à avoir des enfants)
2. Met en œuvre des méthodes pour manipuler les enfants
3. Implémente toutes les méthodes du Composant, généralement en déléguant à ses enfants

Exemple de Code pour comprendre Composite modèle:

import java.util.List;
import java.util.ArrayList;
interface Part{
public double getPrice();
public String getName();
}
class Engine implements Part{
String name;
double price;
public Engine(String name,double price){
this.name = name;
this.price = price;
}
public double getPrice(){
return price;
}
public String getName(){
return name;
}
}
class Trunk implements Part{
String name;
double price;
public Trunk(String name,double price){
this.name = name;
this.price = price;
}
public double getPrice(){
return price;
}
public String getName(){
return name;
}
}
class Body implements Part{
String name;
double price;
public Body(String name,double price){
this.name = name;
this.price = price;
}
public double getPrice(){
return price;
}
public String getName(){
return name;
}
}
class Car implements Part{
List<Part> parts;
String name;
public Car(String name){
this.name = name;
parts = new ArrayList<Part>();
}
public void addPart(Part part){
parts.add(part);
}
public String getName(){
return name;
}
public String getPartNames(){
StringBuilder sb = new StringBuilder();
for ( Part part: parts){
sb.append(part.getName()).append(" ");
}
return sb.toString();
}
public double getPrice(){
double price = 0;
for ( Part part: parts){
price += part.getPrice();
}
return price;
}   
}
public class CompositeDemo{
public static void main(String args[]){
Part engine = new Engine("DiselEngine",15000);
Part trunk = new Trunk("Trunk",10000);
Part body = new Body("Body",12000);
Car car = new Car("Innova");
car.addPart(engine);
car.addPart(trunk);
car.addPart(body);
double price = car.getPrice();
System.out.println("Car name:"+car.getName());
System.out.println("Car parts:"+car.getPartNames());
System.out.println("Car price:"+car.getPrice());
}
}

de sortie:

Car name:Innova
Car parts:DiselEngine Trunk Body
Car price:37000.0

Explication:

1. Partie est une feuille
2. Voiture contient de nombreuses Pièces
3. Différents Pièces de la voiture ont été ajoutés à la Voiture
4. Le prix de Voiture = somme de ( Prix de chaque Partie )

Consultez ci-dessous la question pour les Pros et les Inconvénients de Composition et d'Héritage.

Préférez la composition au cours de l'héritage?

En Mot Simple Agrégation des moyens A Une Relation ..

Composition est un cas particulier de l'agrégation. Une manière plus précise, une restriction de l'agrégation est appelé composition. Lorsqu'un objet contient l'autre objet, si l'objet ne peut pas exister sans l'existence de l'objet conteneur, puis il est appelé composition.
Exemple: Une classe contient des étudiants. Un étudiant ne peut pas exister sans une classe. Il existe de composition entre la classe et les élèves.

Pourquoi Utiliser L'Agrégation

Réutilisabilité Code

Lors De L'Utilisation De L'Agrégation

La réutilisation de Code est également mieux assurée par l'agrégation lorsqu'il n'existe pas une Relation

Héritage

L'héritage est une Relation de Parent-Enfant d'Hérédité Est Une Relation

L'héritage en java est un mécanisme dans lequel un objet acquiert toutes les propriétés et le comportement de l'objet parent.

L'utilisation de l'héritage en Java
1 Code De Réutilisabilité.
2 Ajouter un élément Supplémentaire dans la Classe Enfant ainsi que la redéfinition de Méthode (donc polymorphisme d'exécution peut être atteint).

Héritage entre deux classes, où une classe étend une autre classe établit "EST UN" de la relation.

Composition sur l'autre extrémité contient une instance d'une autre classe dans votre classe établit "A Un" de la relation. Composition en java, est utile car il est techniquement facilite l'héritage multiple.

Je pense que cet exemple explique clairement les différences entre héritage et composition.

Dans cet exemple, le problème est résolu en utilisant l'héritage et la composition. L'auteur accorde une attention au fait que, dans héritage, un changement dans la super-classe peut causer des problèmes dans une classe dérivée, qui en hériter.

Là aussi vous pouvez voir la différence dans la représentation lorsque vous utilisez un UML pour l'héritage ou la composition.

http://www.javaworld.com/article/2076814/core-java/inheritance-versus-composition--which-one-should-you-choose-.html

Composition des moyens de création d'un objet à une classe qui a la relation avec la classe particulière.
Supposons que l'Étudiant a la relation avec les Comptes;

Un Héritage est, c'est la classe précédente avec la fonction étendue. Que signifie cette nouvelle classe est la classe Ancienne avec quelques fonctionnalités étendues.
Supposons que l'Étudiant est un Étudiant, mais à Tous les Élèves de l'Homme. Donc, il y a une relation avec l'étudiant et de l'homme. C'est l'Héritage.

L'héritage signifie la réutilisation de l'ensemble des fonctionnalités d'une classe, d'Ici ma classe ont pour utiliser toutes les méthodes de la super-classe et les élèves de ma classe sera titely couplé avec la super-classe et le code seront dupliquées dans les deux classes dans le cas de l'héritage.

Mais nous pouvons surmonter tous ces problèmes lorsque nous utilisons la composition de parler avec une autre classe . la composition est de déclarer un attribut d'une autre classe dans ma classe à qui nous voulons parler. et les fonctionnalités que nous voulons à partir de cette classe, nous pouvons obtenir l'aide de cet attribut.