java composition what is composition java
Ce didacticiel Java Composition explique ce que sont la composition et l'agrégation en Java et les différences entre eux:
Dans les deux derniers didacticiels, nous avons discuté en détail de l'héritage en Java. L’héritage en Java est un type de relation «IS-A» qui indique qu’un objet est une sorte d’autre objet. Par exemple, une voiture est un type ou un type de véhicule.
La programmation orientée objet fournit un autre type de relation appelée relation «HAS-A». Dans ce didacticiel, nous aborderons en détail la relation has-a.
=> Visitez ici pour apprendre Java à partir de zéro.
Ce que vous apprendrez:
- Tutoriel de composition Java
- Association en Java
- Différences entre l'agrégation et la composition
- Composition Vs. Héritage
- Conclusion
Tutoriel de composition Java
La relation «has-a» en Java s’appelle Composition . En utilisant une relation ou une composition «has-a», nous garantissons la réutilisabilité du code dans nos programmes.
Ainsi, en faisant en sorte que nos programmes utilisent la relation «has-a», ce que nous faisons ici est que nous faisons en sorte que notre programme utilise directement une instance d’une classe au lieu de l’étendre à partir d’une autre classe comme nous le faisons en cas d’héritage.
Le diagramme ci-dessous illustre les relations «is-a» et «has-a» en Java.
Comme le montre le diagramme ci-dessus, la voiture et le véhicule partagent la relation «IS-A» car une voiture est un véhicule. Par conséquent, nous créons un objet voiture à partir de l'objet véhicule existant en lui ajoutant plus de caractéristiques.
Dans le diagramme, la voiture et le moteur partagent la relation «Has-a». Une voiture a toujours un moteur. Donc, ce que nous faisons ici, c'est que nous n'étendons pas les propriétés de l'objet Engine mais nous utilisons directement l'objet Engine. Cela se fait en Java en utilisant la composition.
Par conséquent, avec l'encapsulation, l'abstraction et le polymorphisme, l'héritage et la composition sont également des caractéristiques importantes de la programmation orientée objet (POO).
Les relations «has-a» déterminent généralement si un certain objet a un autre objet. Donc, ce que nous faisons ici est de réutiliser un objet et de réduire ainsi la duplication de code ainsi que les erreurs. C'est parce que nous utilisons un objet entièrement développé et testé dans notre classe.
Commençons par la discussion d'une relation spéciale appelée 'Association' en Java à partir de laquelle nous dérivons la composition et d'autres relations.
Association en Java
L'association en Java peut être définie comme une relation qui existe entre deux classes individuelles en utilisant leurs objets séparés. L'association en Java peut avoir les relations suivantes.
- Un par un: Un objet associé à exactement un objet.
- Un-à-plusieurs: Un objet peut être associé à plusieurs objets.
- Plusieurs à un: De nombreux objets peuvent être associés à un objet.
- Plusieurs à plusieurs: Plus d'un objet associé à plus d'un autre objet.
Lorsqu'une relation est établie, les objets contenant (objets qui ont d'autres objets comme membres) communiquent avec l'objet contenu pour réutiliser leurs propriétés et caractéristiques. L'association a deux formes à savoir la composition et l'agrégation.
La figure ci-dessous montre ceci:
Comme le montre le diagramme ci-dessus, l'Association inclut la composition et l'agrégation. La composition est un terme plus spécifique et l'agrégation est plus générale que la composition. Ces formulaires sont basés sur le type de relations qu'ils soutiennent.
Avant de passer à la composition et à l'agrégation, implémentons un programme Java pour démontrer l'association en Java.
import java.io.*; // class Account class Account { private String bank_name; private long Account_number; // initialize bank name and account number Account(String bank_name, long Account_number) { this.bank_name = bank_name; this.Account_number = Account_number; } //read bank name public String getBankName() { returnthis.bank_name; } //read account number public long getAccountNumber() { returnthis.Account_number; } } // employee class class Employee { private String emp_name; // initialize employee name Employee(String emp_name) { this.emp_name = emp_name; } //read employee name public String getEmployeeName() { return this.emp_name; } } // Associate both the classes class Main { public static void main (String() args) { Employee emp = new Employee('Andrew'); Account acc = new Account('Citi Bank', 13319); System.out.println(emp.getEmployeeName() + ' has an account with ' + acc.getBankName() + ' with Account Number:' + acc.getAccountNumber()); } }Production:
Le programme ci-dessus montre une association en Java. Ici, nous avons un compte de classe qui a un nom de banque et un numéro de compte en tant que membres privés. Ensuite, nous avons une classe Employee. Nous savons que chaque employé aura un numéro de compte pour déposer son salaire, etc.
Ainsi, au lieu d'écrire une autre classe ou méthode pour lire les coordonnées bancaires de l'employé, nous réutilisons directement la classe Account existante. En d’autres termes, nous associons un objet Compte à l’employé afin d’obtenir les coordonnées bancaires de l’employé. L'exemple ci-dessus fait exactement cela.
Composition en Java
La composition est une forme d'association. La composition peut être définie comme une association dans laquelle une classe contient une autre classe et cette classe contenue dépend de la classe contenante de telle manière qu'elle ne peut pas exister indépendamment.
Nous avons vu un exemple de relation has-a ci-dessus. En cela, nous avions un objet voiture qui a un moteur. Ceci est un exemple de composition. En cela, un moteur ne peut exister indépendamment sans voiture.
La composition est plus restreinte par rapport à l'agrégation. La composition n'est pas une fonctionnalité Java. Il est principalement considéré comme une technique de conception.
Le diagramme suivant montre un exemple de composition.
comment ouvrir le fichier bin sur android
En cela, un employé a un compte bancaire. Nous savons qu'un compte bancaire ne peut exister sans titulaire de compte. Sans titulaire de compte, il devient dormant.
Nous pouvons utiliser la composition pour modéliser des objets qui ont d’autres objets comme membres et ces objets ont une relation «has-a» entre eux.
En composition, un objet est contenu dans un autre objet, donc lorsque l'objet contenant est détruit; l'autre objet est également détruit
Ainsi, nous pouvons considérer la relation de composition comme une relation «faisant partie d'un tout» dans laquelle le partie n'existe pas sans le entier . Par conséquent, lorsque le tout est détruit, la pièce est également supprimée. Cela signifie que le tout a une relation plus forte avec la pièce.
Exemple de composition Java
Ci-dessous est le programme pour démontrer la composition.
Le système que nous avons utilisé ici est représenté ci-dessous.
Donc, dans ce programme, nous avons trois classes comme indiqué ci-dessus. Honda est une voiture donc elle s'étend de la voiture de classe. L'objet CarEngine est utilisé dans la classe Honda.
Le programme est donné ci-dessous.
class CarEngine { public void startEngine(){ System.out.println('Car Engine Started.'); } public void stopEngine(){ System.out.println('Car Engine Stopped.'); } } class Car { private String color; private int max_Speed; public void carDetails(){ System.out.println('Car Color= '+color + '; Max Speed= ' + max_Speed); } //set car color public void setColor(String color) { this.color = color; } //set car max_Speed public void setMaxSpeed(int max_Speed) { this.max_Speed = max_Speed; } } class Honda extends Car{ public void HondaStart(){ CarEngine Honda_Engine = new CarEngine(); //composition Honda_Engine.startEngine(); } } public class Main { public static void main(String() args) { Honda HondaCity = new Honda(); HondaCity.setColor('Silver'); HondaCity.setMaxSpeed(180); HondaCity.carDetails(); HondaCity.HondaStart(); } }Production:
Ainsi, la sortie montre les propriétés des voitures Honda. Il montre également la sortie d'une méthode de la classe CarEngine que nous avons utilisée en tant que membre de la classe Honda en utilisant la composition.
Ce programme a montré comment nous pouvons utiliser la composition dans un programme Java.
Agrégation en Java
L'agrégation est une autre forme d'association en Java. Mais dans le cas de l'agrégation, il ne permet que la relation unidirectionnelle entre les objets. Par exemple, un employé a une adresse personnelle. Mais vice versa, l'adresse du domicile a des employés, cela ne sonne pas bien.
De même, un élève a une adresse, mais 'l'adresse a un élève' n'a pas de sens. Comme la composition, l'agrégation décrit également la relation «a un». Cela signifie qu'une classe contient un objet d'une autre classe.
Le diagramme ci-dessous représente un exemple d'agrégation.
L'exemple ci-dessus peut être interprété comme le Collège a du personnel et des étudiants.
Alors, quand exactement devrions-nous opter pour l'agrégation?
Nous devrions utiliser l'agrégation lorsqu'il n'est pas nécessaire d'utiliser une relation ou un héritage «est-un». Si nous pouvons maintenir la relation «est-un» tout au long de l’application ou de la durée de vie d’un objet, nous pouvons mettre en œuvre l’héritage pour la réutilisation du code.
Sinon, il est préférable d'utiliser l'agrégation pour la réutilisation du code. Implémentons maintenant un exemple d'agrégation en Java.
Le système d'exemple que nous avons utilisé est le suivant:
Ici, nous avons une classe «Institut». L'institut peut avoir différents départements ou branches. Chaque branche compte à son tour plusieurs étudiants. Dans ce programme, nous compterons le nombre total d'étudiants dans tout l'institut. Nous utilisons l'agrégation à cette fin. La classe Institute contient l'objet Branch.
L'objet de branche a un objet étudiant. Ainsi, dans la classe Institute utilisant l'objet Branch, nous comptons le nombre total d'étudiants. Pour cela, nous utilisons une liste de branches dans un institut.
Le programme Java est donné ci-dessous.
import java.io.*; import java.util.*; // Class Student class Student { String student_name; int student_id ; String student_dept; //Initialize Student class members Student(String student_name, int student_id, String student_dept) { this.student_name = student_name; this.student_id = student_id; this.student_dept = student_dept; } } //Branch class indiates the branch or department to which the student belongs class Branch { String Branch_name; private List students; //Each branch contain students //Initialize class members Branch(String Branch_name, List students) { this.Branch_name = Branch_name; this.students = students; } //return list of students public List getStudents() { return students; } } //Institure class contains branches which in turn have students class Institute { String instituteName; private List branches; //each institure have various branches //initialize members Institute(String instituteName, List branches) { this.instituteName = instituteName; this.branches = branches; } // count and return number of all students in the institute public int getAllStudentsInInstitute() { int noOfStudents = 0; List students; for(Branch branch : branches) { students = branch.getStudents(); for(Student s : students) { noOfStudents++; } } return noOfStudents; } } //Aggregate all the classes=> Institute (contains) branches (contains) Students class Main { public static void main (String() args) { //declare student objects Student s1 = new Student('Megan', 1, 'CSE'); Student s2 = new Student('Mia', 2, 'CSE'); Student s3 = new Student('John', 1, 'ETC'); Student s4 = new Student('Finn', 2, 'ETC'); // List of CSE Students. List cse_students = new ArrayList(); cse_students.add(s1); cse_students.add(s2); //List of ETC Students List etc_students = new ArrayList(); etc_students.add(s3); etc_students.add(s4); //declare Branch objects Branch CSE = new Branch('CSE', cse_students); Branch ETC = new Branch('ETC', etc_students); //make list of branches List branches = new ArrayList(); branches.add(CSE); branches.add(ETC); // creating an object of Institute. Institute institute = new Institute('NIT', branches); //display total number of students System.out.print('Total students in NIT institute: '); System.out.print(institute.getAllStudentsInInstitute()); } } Production:
L'agrégation et la composition sont donc deux formes d'association dont nous avons discuté ici. Lorsque nous n'avons pas besoin ou ne pouvons pas représenter la relation «est-un» entre les objets, nous pouvons opter pour la composition si nous voulons une relation plus forte entre les objets ou l'agrégation si nous voulons une relation à sens unique.
L'agrégation et la composition nous aident à réutiliser le code en Java.
Différences entre l'agrégation et la composition
La composition et l'agrégation font toutes deux partie de l'association qui dépeint une relation «a-un». Les deux techniques ne sont pas des fonctionnalités Java et n'ont pas de moyen direct de mise en œuvre, mais peuvent être implémentées à l'aide de code Java.
La composition et l'agrégation nous permettent de réutiliser le code. La réutilisabilité du code réduit les bogues dans le code et rend également l'application plus stable.
Voici quelques différences entre l'agrégation et la composition.
| Agrégation | Composition |
|---|---|
| L'agrégation permet aux objets enfants ou aux objets contenus d'exister indépendamment. Par exemple dans une relation où l'école a des employés, si nous supprimons l'école, les employés resteront et pourront fonctionner seuls. | En composition, l'objet contenu ne peut pas exister indépendamment. Par exemple une voiture a un moteur. Si nous supprimons Car, la classe Engine ne peut pas fonctionner seule. |
| L’agrégation est une relation «a un». | La composition est une forme de relation «a un» mais considérée comme faisant partie d’un tout. |
| L'agrégation a une à une association seulement. | La composition permet d'autres relations fournies dans l'association. |
| L'agrégation a une faible association entre les objets. | La composition a une forte association entre les objets. |
Composition Vs. Héritage
| Composition | Héritage |
|---|---|
| La composition dépeint la relation «A-A». | L’héritage représente la relation «Est-A». |
| Plus facile de changer l'implémentation des objets contenant. | Lorsqu'une implémentation change, toute la hiérarchie d'héritage change. |
| A une liaison de temps dynamique ou d'exécution. | A une liaison statique ou au moment de la compilation. |
| L'interface de classe front-end peut être modifiée facilement sans impact sur les classes back-end. | Toute modification des méthodes ou des prototypes affecte toutes les classes. |
| La composition est utilisée lorsque nous n'avons pas besoin d'ajouter plus de caractéristiques ou de fonctionnalités à un objet existant. | L'héritage est utilisé lorsque d'autres fonctionnalités doivent être ajoutées aux classes héritées. |
Questions fréquemment posées
Q # 1) Quelle est la différence entre la relation «IS - A» et «HAS - A»?
Répondre: Dans la programmation orientée objet, les relations IS-A représentent l’héritage dans lequel une classe enfant «est une sorte de» classe parent. La relation Has-a est une relation «partie d'un tout» qui est représentée par la composition et l'agrégation. L'héritage est une liaison statique tandis que Composition est une liaison dynamique.
Q # 2) Qu'est-ce que l'agrégation et la composition en Java?
déclarer un tableau de chaînes en java
Répondre: Dans Composition, les deux objets sont étroitement couplés, c'est-à-dire que lorsque l'objet (objet contenant) qui possède un autre objet (objet contenu) est détruit, alors l'autre objet est automatiquement détruit car il ne peut pas fonctionner indépendamment de lui-même.
Dans l'agrégation, l'objet contenant et l'objet contenu peuvent fonctionner indépendamment. En effet, dans l'agrégation, un objet utilise un autre objet.
Q # 3) Pourquoi utilisons-nous la composition en Java?
Répondre: La composition nous permet de réutiliser le code existant, réduisant ainsi la complexité du code et réduisant également les bogues dans le code. En utilisant la composition, nous pouvons réutiliser uniquement ce dont nous avons besoin de l'objet et contrôler sa visibilité.
Q # 4) À quoi sert l'association?
Répondre: L'association représente la relation «has-a» en Java. L'association en Java est utilisée lorsqu'un objet doit utiliser les fonctionnalités et les services d'un autre objet. La composition et l'agrégation sont deux formes d'association.
Q # 5) La composition est-elle meilleure que l'héritage?
Répondre: Cela dépend du système POO que nous codons. Si nous pouvons représenter les objets avec une relation IS-A tout au long de sa durée de vie dans l'application, l'héritage est une meilleure option. Lorsque nous voulons réutiliser le code et ne pouvons pas représenter le système d'objets avec la relation IS-A, la composition est meilleure.
De plus, lorsque nous voulons changer fréquemment de classes frontales sans déranger les classes back-end, la composition est meilleure car dans le cas de l'héritage, de légères modifications affectent principalement toute la hiérarchie d'héritage.
Conclusion
Dans ce tutoriel, nous avons discuté de la relation HAS-A en Java. La composition et l’agrégation sont les formes qui mettent en œuvre la relation «HAS-A». Nous avons comparé ces deux implémentations.
Alors que les deux contiennent des objets d'une autre classe, la composition possède l'objet tandis que l'agrégation utilise simplement l'objet. Nous avons également comparé la composition et l'héritage en Java.
=> Vérifiez ici pour voir de A à Z des didacticiels de formation Java.
lecture recommandée
- Tutoriel Java SWING: Conteneur, composants et gestion des événements
- Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques
- TreeMap en Java - Tutoriel avec des exemples de TreeMap Java
- Tutoriel Java Float avec des exemples de programmation
- Tutoriel Java String avec String Buffer et String Builder
- Déploiement Java: création et exécution d'un fichier JAR Java
- Objet Java Class Vs - Comment utiliser une classe et un objet en Java
- Principes de base de Java: syntaxe Java, classe Java et principaux concepts Java