java composition what is composition java
Aquest tutorial de Composició de Java explica què és Composició i agregació a Java i les diferències entre ells:
En el darrer parell de tutorials, vam parlar detalladament de l’herència a Java. L’herència a Java és un tipus de relació “IS-A” que indica que un objecte ‘és una mena’ d’un altre objecte. Per exemple, un cotxe és un tipus o tipus de vehicle.
La programació orientada a objectes proporciona un altre tipus de relació anomenada relació “HAS-A”. En aquest tutorial, parlarem detalladament de la relació que té.
=> Visiteu aquí per aprendre Java des de zero.
Què aprendreu:
- Tutorial de composició de Java
- Associació a Java
- Diferències entre l'agregació i la composició
- Composició vs. Herència
- Conclusió
Tutorial de composició de Java
Es diu la relació 'té-a' a Java Composició . Mitjançant la utilització de la relació o composició 'has-a', garantim la reutilització del codi als nostres programes.
Per tant, fent que els nostres programes facin servir una relació 'té-a', el que estem fent aquí és que fem que el nostre programa faci servir una instància d'una classe directament en lloc de 'ampliar-la' des d'una altra classe, com ho fem en cas d'herència.
El diagrama següent mostra tant les relacions ‘és-a’ com ‘té-a’ a Java.
Com es pot veure a l’esquema anterior, Car and Vehicle comparteix la relació ‘IS-A’ ja que un vehicle és un vehicle. Per tant, creem un objecte de cotxe a partir de l'objecte de vehicle existent afegint-hi més característiques.
Al diagrama, Car and Engine comparteixen la relació 'Has-a'. Un cotxe sempre té un motor. Per tant, el que fem aquí és que no ampliem les propietats de l’objecte Engine, sinó que l’utilitzem directament. Això es fa a Java mitjançant la composició.
Per tant, juntament amb l’encapsulació, l’abstracció i el polimorfisme, l’herència i la composició també són característiques importants de la programació orientada a objectes (OOP).
Les relacions 'té-a' solen determinar si un objecte determinat té un altre objecte. Per tant, el que fem aquí és reutilitzar un objecte i, per tant, reduir la duplicació de codi, així com els errors. Això es deu al fet que utilitzem un objecte completament desenvolupat i provat a la nostra classe.
Comencem amb el debat sobre una relació especial anomenada 'Associació' a Java de la qual derivem la composició i altres relacions.
Associació a Java
L’associació a Java es pot definir com una relació que existeix entre dues classes individuals mitjançant els seus objectes separats. L’associació a Java pot tenir les relacions següents.
- Un a un: Un objecte associat a un objecte exactament.
- Un a molts: Un objecte es pot associar a molts objectes.
- Molts a un: Es poden associar molts objectes a un objecte.
- Molts a molts: Més d'un objecte associat a més d'un altre objecte.
Quan s'estableix una relació, els objectes contenidors (objectes que tenen altres objectes com a membres) es comuniquen amb l'objecte contingut per reutilitzar les seves propietats i característiques. L’associació té dues formes: composició i agregació.
La figura següent mostra això:
Tal com es veu al diagrama anterior, l'Associació inclou Composició i agregació. La composició és un terme més específic i l’agregació és més general que la composició. Aquests formularis es basen en el tipus de relacions que admeten.
Abans de passar a Composició i agregació, implementem un programa Java per demostrar l’associació a 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()); } }Sortida:
El programa anterior mostra una associació a Java. Aquí tenim un compte de classe que té un nom bancari i un número de compte com a membres privats. A continuació, tenim una classe d'empleats. Sabem que cada empleat tindrà un número de compte per ingressar salaris, etc.
Per tant, el que fem és, en lloc d’escriure una altra classe o mètode per llegir a les dades del compte bancari de l’empleat, reutilitzem directament la classe de compte existent. Dit d’una altra manera, associem un objecte de compte amb l’empleat per obtenir les dades del compte bancari de l’empleat. L'exemple anterior ho fa exactament.
Composició a Java
La composició és una forma d’associació. La composició es pot definir com una associació en què una classe conté una altra classe i aquesta classe continguda depèn de la classe contenidora de manera que no pugui existir de forma independent.
Hem vist un exemple de relació que té una relació anterior. En això, teníem un objecte de cotxe que tenia un motor. Aquest és un exemple de composició. En això, un motor no pot existir independentment sense un cotxe.
La composició és més restringida en comparació amb l'agregació. La composició no és una característica de Java. Es considera principalment una tècnica de disseny.
El diagrama següent mostra un exemple de composició.
Quin és el millor descarregador de YouTube gratuït?
En aquest cas, un empleat té un compte bancari. Sabem que no pot existir un compte bancari sense un titular del compte. Sense un titular del compte, queda inactiu.
Podem utilitzar la composició per modelar objectes que tinguin altres objectes com a membres i aquests objectes tinguin una relació “entre si”.
En la composició, un objecte està contingut en un altre objecte, per tant, quan l'objecte contenidor es destrueix; l’altre objecte també es destrueix
Per tant, podem veure la relació de composició com una relació 'part-de-tot-un' en la qual el part no existeix sense sencera . Per tant, quan es destrueix el conjunt, també s’elimina la peça. Això significa que el conjunt té una relació més forta amb la peça.
Exemple de composició de Java
A continuació es mostra el programa per demostrar la composició.
El sistema que hem utilitzat aquí es representa a continuació.
Així doncs, en aquest programa, tenim tres classes tal com es mostra més amunt. Honda és un cotxe, de manera que s’estén des de la classe Cotxe. CarEngine Object s’utilitza a la classe Honda.
El programa es presenta a continuació.
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(); } }Sortida:
Així, la sortida mostra les propietats dels cotxes Honda. També mostra la sortida d’un mètode de la classe CarEngine que hem utilitzat com a membre de la classe Honda mitjançant composició.
Aquest programa va mostrar com podem utilitzar la composició en un programa Java.
programari de cracker de contrasenya descàrrega gratuïta de la versió completa
Agregació a Java
L’agregació és una altra forma d’associació a Java. Però en el cas de l’agregació, només permet la relació unidireccional entre els objectes. Per exemple, un empleat té una adreça de casa. Però viceversa, l'adreça de casa té empleats, no sona bé.
De la mateixa manera, un estudiant té una adreça, però 'l'adreça té un estudiant' no té sentit. Igual que la composició, l'agregació també representa la relació 'té-a'. Això significa que una classe conté un objecte d'una altra classe.
El diagrama següent representa un exemple d’agregació.
L'exemple anterior es pot interpretar ja que el Col·legi té personal i estudiants.
Llavors, quan hauríem d’anar a l’agregació?
Hauríem d’utilitzar l’agregació quan no hi hagi necessitat d’utilitzar una relació o una herència “is-a”. Si podem mantenir la relació 'és-a' al llarg de l'aplicació o la vida d'un objecte, podem implementar l'herència per a la reutilització del codi.
En cas contrari, és millor utilitzar l'agregació per a la reutilització del codi. Implantem ara un exemple d’agregació a Java.
L’exemple de sistema que hem utilitzat és el següent:
Aquí tenim una classe d’Institut. L'Institut pot tenir diversos departaments o sucursals. Cada sucursal té al seu torn diversos estudiants. En aquest programa, comptabilitzarem el nombre total d’alumnes de tot l’institut. Utilitzem l'agregació amb aquest propòsit. La classe Institute conté l'objecte Branch.
L'objecte branca té un objecte estudiant. Així doncs, a la classe d’Institut que utilitza l’objecte Branch comptem el nombre total d’alumnes. Amb aquest propòsit, fem servir una llista d’oficines d’un institut.
A continuació es mostra el programa Java.
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()); } } Sortida:
Per tant, l’agregació i la composició són dues formes d’associació que hem comentat aquí. Quan no necessitem o no podem representar una relació 'és-a' entre objectes, podem optar per la composició si volem una relació més forta entre objectes o agregació si volem una relació unidireccional.
Tant l'agregació com la composició ens ajuden a reutilitzar el codi a Java.
Diferències entre l'agregació i la composició
Tant la composició com l’agregació són parts de l’Associació que representa una relació ‘té-a’. Les dues tècniques no són funcions de Java i no tenen una manera directa d’implementar-les, sinó que es poden implementar mitjançant codi Java.
La composició i l’agregació ens permeten reutilitzar el codi. La reutilització del codi redueix els errors del codi i també fa que l’aplicació sigui més estable.
A continuació es detallen algunes diferències entre l'agregació i la composició.
| Agregació | Composició |
|---|---|
| L’agregació permet que els objectes fills o objectes continguts existeixin de forma independent. Per exemple en una relació en què l'escola tingui empleats, si suprimim l'escola, els empleats romandran i podran funcionar sols. | En la composició, l'objecte contingut no pot existir de forma independent. Per exemple un cotxe té motor. Si suprimim Car, la classe Engine no pot funcionar sola. |
| L’agregació és una relació que té. | La composició és una forma de relació 'té-a', però es veu com una relació de part d'un tot. |
| L’agregació només té una associació individual. | La composició permet altres relacions proporcionades a l’associació. |
| L’agregació té una feble associació entre objectes. | La composició té una forta associació entre objectes. |
Composició vs. Herència
| Composició | Herència |
|---|---|
| La composició representa la relació ‘Has-A’. | L’herència representa una relació ‘Is-A’. |
| És més fàcil canviar la implementació dels objectes contenidors. | Quan una implementació canvia tota la jerarquia de l'herència. |
| Té una vinculació de temps dinàmica o d'execució. | Té una vinculació de temps estàtica o de compilació. |
| La interfície de classe frontal es pot canviar fàcilment sense afectar les classes de fons. | Qualsevol canvi en els mètodes o prototips afecta totes les classes. |
| La composició s’utilitza quan no cal afegir més característiques o característiques a un objecte existent. | L’herència s’utilitza quan s’han d’afegir més funcions a les classes heretades. |
Preguntes freqüents
P # 1) Quina diferència hi ha entre la relació 'IS - A' i 'HAS - A'?
Resposta: A la programació orientada a objectes, les relacions IS-A representen una herència en què una classe infantil 'és una mena de' una classe pare. La relació Has-a és una relació 'part de tot' que es representa mitjançant la composició i l'agregació. L’herència és un enllaç estàtic mentre que la composició és un enllaç dinàmic.
Q # 2) Què és l'agregació i la composició a Java?
Resposta: En Composició, els dos objectes estan fortament acoblats, és a dir, quan es destrueix l’objecte (objecte que conté) que posseeix un altre objecte (objecte contingut), l’altre objecte es destrueix automàticament ja que no pot funcionar independentment per si mateix.
A l'agregació, l'objecte contingut i l'objecte contingut poden funcionar de manera independent. Això es deu al fet que, a l'agregació, un objecte utilitza un altre objecte.
P # 3) Per què fem servir Composició a Java?
Resposta: La composició ens permet reutilitzar el codi existent reduint la complexitat del codi i també redueix els errors del codi. Mitjançant la composició podem reutilitzar només allò que necessitem de l’objecte i també controlar-ne la visibilitat.
Q # 4) Quin ús té l'Associació?
Resposta: L’associació representa la relació ‘té-a’ a Java. L’associació a Java s’utilitza quan un objecte necessita utilitzar la funcionalitat i els serveis d’un altre objecte. La composició i l’agregació són dues formes d’associació.
P # 5) La composició és millor que l’herència?
Resposta: Depèn del sistema OOP que estem codificant. Si podem representar els objectes amb relació IS-A al llarg de la seva vida a l'aplicació, l'herència és una opció millor. Quan volem reutilitzar el codi i no podem representar el sistema d'objectes amb la relació IS-A, la composició és millor.
A més, quan volem canviar freqüentment les classes front-end sense molestar les classes back-end, la composició és millor perquè en el cas de l’herència els lleugers canvis afecten majoritàriament a tota la jerarquia de l’herència.
Conclusió
En aquest tutorial, hem parlat de la relació HAS-A a Java. La composició i l’agregació són les formes que implementen la relació ‘HAS-A’. Hem comparat aquestes dues implementacions.
Tot i que tots dos contenen objectes d'una altra classe, la composició és propietària de l'objecte, mentre que l'agregació simplement utilitza l'objecte. També hem comparat la composició i l'herència a Java.
=> Consulteu aquí per veure tutorials de formació A-Z de Java.
Lectura recomanada
- Tutorial Java SWING: Gestió de contenidors, components i esdeveniments
- Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java
- TreeMap a Java: tutorial amb exemples de Java TreeMap
- Tutorial Java Float amb exemples de programació
- Java String amb buffer de cadenes i tutorial de Generador de cadenes
- Desplegament de Java: creació i execució del fitxer JAR de Java
- Objecte Java Class Vs: com s'utilitza la classe i l'objecte a Java
- Conceptes bàsics de Java: sintaxi de Java, Java Class i conceptes bàsics de Java