java composition what is composition java
Questo tutorial sulla composizione di Java spiega cos'è la composizione e l'aggregazione in Java e le differenze tra loro:
Nell'ultimo paio di tutorial, abbiamo discusso in dettaglio dell'ereditarietà in Java. L'ereditarietà in Java è un tipo di relazione 'IS-A' che indica che un oggetto 'è una specie di' un altro oggetto. Per esempio, un'auto è un tipo o un tipo di veicolo.
La programmazione orientata agli oggetti fornisce un altro tipo di relazione chiamata relazione 'HAS-A'. In questo tutorial, discuteremo in dettaglio la relazione ha-a.
=> Visita qui per imparare Java da zero.
Cosa imparerai:
- Tutorial sulla composizione di Java
- Associazione in Java
- Differenze tra aggregazione e composizione
- Composizione vs. Eredità
- Conclusione
Tutorial sulla composizione di Java
Viene chiamata la relazione 'ha-a' in Java Composizione . Utilizzando la relazione o la composizione 'ha-a' garantiamo la riusabilità del codice nei nostri programmi.
Quindi, facendo in modo che i nostri programmi utilizzino la relazione 'ha-a', ciò che stiamo facendo qui è che facciamo in modo che il nostro programma utilizzi un'istanza di una classe direttamente invece di 'estenderla' da un'altra classe come facciamo in caso di ereditarietà.
Il diagramma seguente mostra le relazioni 'è-a' e 'ha-a' in Java.
Come si vede dal diagramma sopra, Auto e Veicolo condividono la relazione 'IS-A' in quanto un'auto è un veicolo. Quindi creiamo un oggetto auto dall'oggetto veicolo esistente aggiungendovi più caratteristiche.
Nel diagramma, Auto e Motore condividono la relazione 'Ha-a'. Un'auto ha sempre un motore. Quindi quello che facciamo qui è che non estendiamo le proprietà dell'oggetto Engine ma usiamo l'oggetto Engine direttamente. Questo viene fatto in Java usando la composizione.
Quindi, insieme all'incapsulamento, all'astrazione e al polimorfismo, anche l'ereditarietà e la composizione sono caratteristiche importanti della programmazione orientata agli oggetti (OOP).
Le relazioni 'ha-a' di solito determinano se un determinato oggetto ha un altro oggetto. Quindi quello che facciamo qui è riutilizzare un oggetto e quindi ridurre la duplicazione del codice e gli errori. Questo perché utilizziamo un oggetto completamente sviluppato e testato nella nostra classe.
Cominciamo con la discussione di una relazione speciale chiamata 'Associazione' in Java da cui deriviamo la composizione e altre relazioni.
Associazione in Java
L'associazione in Java può essere definita come una relazione che esiste tra due classi individuali utilizzando i loro oggetti separati. L'associazione in Java può avere le seguenti relazioni.
- Uno a uno: Un oggetto associato esattamente a un oggetto.
- Uno-a-molti: Un oggetto può essere associato a molti oggetti.
- Molti a uno: Molti oggetti possono essere associati a un oggetto.
- Molti a molti: Più di un oggetto associato a più di un altro oggetto.
Quando viene stabilita una relazione, gli oggetti contenitore (oggetti che hanno altri oggetti come membri) comunicano con l'oggetto contenuto per riutilizzare le loro proprietà e caratteristiche. L'associazione ha due forme, ovvero composizione e aggregazione.
La figura seguente mostra questo:
Come si vede dal diagramma sopra, l'Associazione include Composizione e aggregazione. La composizione è un termine più specifico e l'aggregazione è più generale della composizione. Questi moduli si basano sul tipo di relazioni che supportano.
Prima di passare alla composizione e all'aggregazione, implementiamo un programma Java per dimostrare l'associazione in 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()); } }Produzione:
Il programma precedente mostra un'associazione in Java. Qui, abbiamo un conto di classe che ha un nome di banca e un numero di conto come membri privati. Successivamente, abbiamo una classe Employee. Sappiamo che ogni dipendente avrà un numero di conto per depositare lo stipendio, ecc.
Quindi quello che facciamo è, invece di scrivere un'altra classe o metodo da leggere nei dettagli del conto bancario del dipendente, riutilizziamo direttamente la classe Account esistente. In altre parole, associamo un oggetto Account al dipendente in modo da ottenere i dettagli del conto bancario del dipendente. L'esempio sopra fa esattamente questo.
Composizione In Java
La composizione è una forma di associazione. La composizione può essere definita come un'associazione in cui una classe contiene un'altra classe e questa classe contenuta dipende dalla classe contenente in modo tale che non può esistere indipendentemente.
Abbiamo visto un esempio di una relazione ha-una sopra. In questo, avevamo un oggetto auto che ha un motore. Questo è un esempio di composizione. In questo, un motore non può esistere indipendentemente senza un'auto.
La composizione è più limitata rispetto all'aggregazione. La composizione non è una funzionalità Java. È considerata principalmente una tecnica di progettazione.
Il diagramma seguente mostra un esempio di composizione.
gateway predefinito non disponibile Windows 10 2019
In questo, un dipendente ha un conto bancario. Sappiamo che un conto bancario non può esistere senza un titolare del conto. Senza un titolare del conto, diventa dormiente.
Possiamo usare la composizione per modellare oggetti che hanno altri oggetti come suoi membri e questi oggetti hanno una relazione 'ha-un' tra di loro.
Nella composizione, un oggetto è contenuto in un altro oggetto, quindi quando l'oggetto contenitore viene distrutto; anche l'altro oggetto viene distrutto
Quindi possiamo vedere la relazione di composizione come una relazione 'parte di un tutto' in cui il parte non esiste senza il totale . Quindi, quando l'intero viene distrutto, anche la parte viene eliminata. Ciò significa che il tutto ha una relazione più forte con la parte.
Esempio di composizione Java
Di seguito è riportato il programma per dimostrare la composizione.
Il sistema che abbiamo usato qui è rappresentato come di seguito.
Quindi in questo programma abbiamo tre classi come mostrato sopra. Honda è un'auto quindi si estende dalla classe Car. L'oggetto CarEngine viene utilizzato nella classe Honda.
Di seguito viene fornito il programma.
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(); } }Produzione:
Così l'output mostra le proprietà delle vetture Honda. Mostra anche l'output di un metodo dalla classe CarEngine che abbiamo usato come membro della classe Honda usando la composizione.
Questo programma ha mostrato come possiamo usare la composizione in un programma Java.
Aggregazione in Java
L'aggregazione è un'altra forma di associazione in Java. Ma nel caso dell'aggregazione, consente solo la relazione unidirezionale tra gli oggetti. Per esempio, un dipendente ha un indirizzo di casa. Ma viceversa, l'indirizzo di casa ha dipendenti, non suona bene.
Allo stesso modo, uno studente ha un indirizzo ma 'l'indirizzo ha uno studente' non ha senso. Come la composizione, anche l'aggregazione rappresenta la relazione 'ha-a'. Ciò significa che una classe contiene un oggetto di un'altra classe.
Il diagramma seguente rappresenta un esempio di aggregazione.
L'esempio sopra può essere interpretato come il College ha personale e studenti.
Quindi, quando esattamente dovremmo scegliere l'aggregazione?
Dovremmo usare l'aggregazione quando non è necessario utilizzare una relazione o eredità 'è-un'. Se riusciamo a mantenere la relazione 'è-un' per tutta l'applicazione o la durata di un oggetto, possiamo implementare l'ereditarietà per il riutilizzo del codice.
In caso contrario, è meglio utilizzare l'aggregazione per la riutilizzabilità del codice. Implementiamo ora un'aggregazione di esempio in Java.
Il sistema di esempio che abbiamo utilizzato è il seguente:
Qui abbiamo un corso 'Istituto'. L'istituto può avere vari dipartimenti o filiali. Ogni ramo a sua volta ha diversi studenti. In questo programma, conteremo il numero totale di studenti dell'intero istituto. Usiamo l'aggregazione per questo scopo. La classe Institute contiene l'oggetto Branch.
L'oggetto ramo ha un oggetto studente. Quindi nella classe Institute che utilizza l'oggetto Branch contiamo il numero totale di studenti. A tal fine, utilizziamo un elenco di filiali in un istituto.
Di seguito viene fornito il programma 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()); } } Produzione:
Quindi aggregazione e composizione sono due forme di associazione che abbiamo discusso qui. Quando non abbiamo bisogno o non possiamo rappresentare la relazione 'è-un' tra gli oggetti, allora possiamo optare per la composizione se vogliamo una relazione più forte tra gli oggetti o l'aggregazione se vogliamo una relazione unidirezionale.
Sia l'aggregazione che la composizione ci aiutano a riutilizzare il codice in Java.
Differenze tra aggregazione e composizione
Sia la composizione che l'aggregazione sono parti dell'Associazione che rappresentano una relazione 'ha-a'. Entrambe le tecniche non sono funzionalità Java e non hanno un modo diretto per l'implementazione ma possono essere implementate utilizzando il codice Java.
Composizione e aggregazione ci consentono di riutilizzare il codice. La riusabilità del codice riduce i bug nel codice e rende anche l'applicazione più stabile.
quale delle seguenti è una fase nella sdlc?
Di seguito sono elencate alcune differenze tra aggregazione e composizione.
| Aggregazione | Composizione |
|---|---|
| L'aggregazione consente agli oggetti figlio o agli oggetti contenuti di esistere in modo indipendente. Per esempio in una relazione in cui la scuola ha dipendenti, se eliminiamo la scuola, i dipendenti rimarranno e potranno funzionare autonomamente. | Nella composizione, l'oggetto contenuto non può esistere indipendentemente. Per esempio una macchina ha il motore. Se cancelliamo Car, la classe del motore non può funzionare da sola. |
| L'aggregazione è una relazione 'ha-un'. | La composizione è una forma di relazione 'ha-un' ma vista come relazione parte di un tutto '. |
| L'aggregazione ha solo un'associazione uno a uno. | La composizione consente altri rapporti previsti nell'associazione. |
| L'aggregazione ha una debole associazione tra gli oggetti. | La composizione ha una forte associazione tra gli oggetti. |
Composizione vs. Eredità
| Composizione | Eredità |
|---|---|
| La composizione raffigura la relazione 'Has-A'. | L'ereditarietà rappresenta la relazione 'È-A'. |
| Più facile cambiare l'implementazione degli oggetti contenenti. | Quando un'implementazione cambia, l'intera gerarchia di ereditarietà cambia. |
| Ha un'associazione temporale dinamica o di esecuzione. | Ha un'associazione in fase di compilazione o statica. |
| L'interfaccia della classe front-end può essere modificata facilmente senza influire sulle classi back-end. | Qualsiasi modifica nei metodi o nei prototipi influisce su tutte le classi. |
| La composizione viene utilizzata quando non è necessario aggiungere più caratteristiche o funzionalità a un oggetto esistente. | L'ereditarietà viene utilizzata quando è necessario aggiungere più funzionalità alle classi ereditate. |
Domande frequenti
D # 1) Qual è la differenza tra la relazione 'È - A' e 'HA - A'?
Risposta: Nella programmazione orientata agli oggetti, le relazioni IS-A rappresentano l'ereditarietà in cui una classe figlia 'è una specie di' classe genitore. La relazione Has-a è una relazione 'parte di un tutto' che è rappresentata dalla composizione e dall'aggregazione. L'ereditarietà è un'associazione statica mentre la composizione è un'associazione dinamica.
D # 2) Che cos'è l'aggregazione e la composizione in Java?
Risposta: In Composition, i due oggetti sono strettamente accoppiati, ovvero quando l'oggetto (oggetto contenente) che possiede un altro oggetto (oggetto contenuto) viene distrutto, l'altro oggetto viene automaticamente distrutto poiché non può funzionare in modo indipendente da solo.
In Aggregation, l'oggetto contenitore e l'oggetto contenuto possono funzionare indipendentemente. Questo perché, in Aggregation, un oggetto utilizza un altro oggetto.
D # 3) Perché usiamo la composizione in Java?
Risposta: La composizione ci consente di riutilizzare il codice esistente riducendo così la complessità del codice e riduce anche i bug nel codice. Usando la composizione possiamo riutilizzare solo ciò di cui abbiamo bisogno dall'oggetto e anche controllarne la visibilità.
Q # 4) A cosa serve l'associazione?
Risposta: L'associazione rappresenta la relazione 'ha-a' in Java. L'associazione in Java viene utilizzata quando un oggetto deve utilizzare la funzionalità ei servizi di un altro oggetto. La composizione e l'aggregazione sono due forme di associazione.
D # 5) La composizione è migliore dell'ereditarietà?
Risposta: Dipende dal sistema OOP che stiamo codificando. Se possiamo rappresentare gli oggetti con una relazione IS-A per tutta la sua durata nell'applicazione, l'ereditarietà è un'opzione migliore. Quando vogliamo riutilizzare il codice e non possiamo rappresentare il sistema a oggetti con la relazione IS-A, la composizione è migliore.
Inoltre, quando vogliamo cambiare frequentemente le classi di front-end senza disturbare le classi di back-end, la composizione è migliore perché nel caso dell'ereditarietà, lievi modifiche influenzano principalmente l'intera gerarchia di ereditarietà.
Conclusione
In questo tutorial, abbiamo discusso la relazione HAS-A in Java. Composizione e aggregazione sono le forme che implementano la relazione 'HAS-A'. Abbiamo confrontato entrambe queste implementazioni.
Sebbene entrambi contengano oggetti di un'altra classe, la composizione possiede l'oggetto mentre l'aggregazione utilizza semplicemente l'oggetto. Abbiamo anche confrontato la composizione e l'ereditarietà in Java.
=> Controlla qui per vedere i tutorial di formazione su Java dalla A alla Z.
Lettura consigliata
- Tutorial Java SWING: contenitore, componenti e gestione degli eventi
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- TreeMap in Java - Tutorial con esempi di Java TreeMap
- Tutorial Java Float con esempi di programmazione
- Java String con String Buffer e String Builder Tutorial
- Distribuzione Java: creazione ed esecuzione di file JAR Java
- Java Class Vs Object - Come utilizzare la classe e l'oggetto in Java
- Nozioni di base su Java: sintassi Java, classe Java e concetti principali di Java