java composition what is composition java
Denna Java-komposition-handledning förklarar vad som är komposition och aggregering i Java och skillnaderna mellan dem:
I de senaste para handledningarna diskuterade vi arv i Java i detalj. Arv i Java är en typ av 'IS-A' -förhållande som indikerar att ett objekt 'är ett slags' ett annat objekt. Till exempel, en bil är en typ eller typ av fordon.
Objektorienterad programmering ger en annan typ av relation som kallas ”HAS-A” -relationen. I den här handledningen kommer vi att diskutera has-a-relationen i detalj.
=> Besök här för att lära dig Java från grunden.
Vad du kommer att lära dig:
- Java Composition Tutorial
- Association i Java
- Skillnader mellan Aggregation Vs Composition
- Sammansättning Vs. Arv
- Slutsats
Java Composition Tutorial
”Has-a” -förhållandet i Java kallas Sammansättning . Genom att använda ”has-a” -förhållande eller komposition säkerställer vi återanvändbar kod i våra program.
Så genom att våra program använder 'has-a' -förhållande, är det vi gör här att vi får vårt program att använda en förekomst av en klass direkt istället för att 'utvidga' den från en annan klass som vi gör i fall av arv.
Nedanstående diagram visar både 'is-a' och 'has-a' -relationer i Java.
Som framgår av ovanstående diagram delar bil och fordon ”IS-A” -förhållandet eftersom en bil är ett fordon. Därför skapar vi ett bilobjekt från det befintliga fordonsobjektet genom att lägga till fler egenskaper till det.
I diagrammet delar bil och motor 'Has-a' -förhållandet. En bil har alltid en motor. Så vad vi gör här är att vi inte utökar egenskaperna för motorobjektet utan vi använder motorobjektet direkt. Detta görs i Java med hjälp av komposition.
Följaktligen, tillsammans med inkapsling, abstraktion och polymorfism, är arv och komposition också viktiga funktioner i objektorienterad programmering (OOP).
Relationerna ”har-a” avgör vanligtvis om ett visst objekt har ett annat objekt. Så vad vi gör här är att vi återanvänder ett objekt och därmed minskar koddubblering och fel. Detta beror på att vi använder ett helt utvecklat och testat objekt i vår klass.
Låt oss börja med diskussionen om en speciell relation som kallas 'Association' på Java som vi härleder komposition och andra relationer från.
Association i Java
Förening i Java kan definieras som en relation som existerar mellan två individuella klasser med hjälp av sina separata objekt. Förening i Java kan ha följande relationer.
- En till en: Ett objekt associerat med exakt ett objekt.
- En till många: Ett objekt kan associeras med många objekt.
- Många till en: Många objekt kan associeras med ett objekt.
- Många till många: Mer än ett objekt associerat med mer än ett annat objekt.
När ett förhållande upprättas kommunicerar de innehållande objekten (objekt som har andra objekt som sina medlemmar) med det innehållna objektet för att återanvända deras egenskaper och egenskaper. Föreningen har två former, dvs. sammansättning och aggregering.
Nedanstående figur visar detta:
Som framgår av ovanstående diagram inkluderar föreningen sammansättning och aggregering. Sammansättning är en mer specifik term och aggregering är mer allmän än sammansättning. Dessa former baseras på vilken typ av relationer de stöder.
Innan vi går vidare till komposition och aggregering, låt oss implementera ett Java-program för att demonstrera föreningen i 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()); } }Produktion:
Ovanstående program visar en förening i Java. Här har vi ett klasskonto som har ett banknamn och kontonummer som privata medlemmar. Därefter har vi en anställdsklass. Vi vet att varje anställd kommer att ha ett kontonummer för att sätta in lön etc.
Så vad vi gör är att vi istället för att skriva en annan klass eller metod för att läsa i anställdens bankkontouppgifter, återanvänder den befintliga kontoklassen direkt. Med andra ord kopplar vi ett kontoobjekt till den anställde så att vi får anställdens bankkontouppgifter. Ovanstående exempel gör exakt detta.
Sammansättning i Java
Sammansättningen är en form av förening. Kompositionen kan definieras som en förening där en klass innehåller en annan klass och denna innehållna klass beror på den innehållande klassen på ett sådant sätt att den inte kan existera oberoende.
Vi har sett ett exempel på en has-a-relation ovan. I det hade vi ett bilföremål som har en motor. Detta är ett exempel på komposition. I detta kan en motor inte existera oberoende utan bil.
Sammansättningen är mer begränsad jämfört med Aggregation. Kompositionen är inte en Java-funktion. Det anses främst vara en designteknik.
Följande diagram visar ett kompositionsexempel.
hur man öppnar swf-filer i krom
I detta har en anställd ett bankkonto. Vi vet att ett bankkonto inte kan existera utan en kontoinnehavare. Utan kontoinnehavare blir det vilande.
Vi kan använda komposition för att modellera objekt som har andra objekt som dess medlemmar och dessa objekt har 'has-a' -förhållande mellan sig.
I komposition ingår ett objekt i ett annat objekt, alltså när det innehållande objektet förstörs; det andra objektet förstörs också
Så vi kan se kompositionsförhållandet som ett 'part-of-a-whole' -förhållande där del existerar inte utan hela . Följaktligen, när hela förstörs, raderas delen också. Detta innebär att helheten har en starkare relation med delen.
Exempel på Java-sammansättning
Nedan följer programmet för att demonstrera komposition.
Systemet vi använde här representeras som nedan.
Så i det här programmet har vi tre klasser som visas ovan. Honda är en bil så den sträcker sig från klassen bil. CarEngine Object används i Honda-klass.
Programmet ges nedan.
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(); } }Produktion:
Således visar produktionen egenskaperna hos Honda-bilar. Det visar också resultatet av en metod från CarEngine-klassen som vi har använt som medlem i Honda-klassen med hjälp av komposition.
Detta program visade hur vi kan använda komposition i ett Java-program.
Aggregering i Java
Aggregation är en annan form av förening i Java. Men vid aggregering tillåter det bara envägsförhållandet mellan objekten. Till exempel, en anställd har en hemadress. Men tvärtom, hemadressen har anställda, låter inte rätt.
På samma sätt har en student en adress men 'adress har en student' är inte meningsfullt. Precis som kompositionen visar aggregering också ”has-a” -förhållandet. Det betyder att en klass innehåller ett objekt från en annan klass.
Nedanstående diagram representerar ett aggregeringsexempel.
Ovanstående exempel kan tolkas så att högskolan har personal och studenter.
Så när ska vi gå till Aggregation?
Vi bör använda aggregering när det inte finns något behov av att använda ett ”is-a” -förhållande eller arv. Om vi kan upprätthålla 'is-a' -förhållandet under ett objekts hela applikation eller livstid kan vi implementera arv för kodåteranvändning.
Annars är det bäst att använda aggregering för återanvändbar kod. Låt oss nu implementera ett exempel på aggregering i Java.
Exemplet systemet vi har använt är som följer:
Här har vi en ”Institute” -klass. Institutet kan ha olika avdelningar eller filialer. Varje gren har i sin tur flera studenter. I detta program räknar vi det totala antalet studenter i hela institutet. Vi använder aggregering för detta ändamål. Klassinstitutet innehåller filialobjektet.
Filialobjektet har ett studentobjekt. Så i institutklassen med hjälp av filialobjektet räknar vi det totala antalet studenter. För detta ändamål använder vi en lista över filialer i ett institut.
Java-programmet ges nedan.
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()); } } Produktion:
Därför är aggregering och sammansättning två former av associering som vi har diskuterat här. När vi inte behöver eller inte kan representera 'is-a' -förhållande mellan objekt kan vi gå till komposition om vi vill ha en starkare relation mellan objekt eller aggregering om vi vill ha en enkelriktad relation.
Både aggregering och sammansättning hjälper oss att återanvända kod i Java.
Skillnader mellan Aggregation Vs Composition
Både sammansättning och aggregering är delar av föreningen som skildrar en 'has-a' relation. Båda teknikerna är inte Java-funktioner och har inte ett direkt sätt att implementera utan kan implementeras med Java-kod.
Sammansättning och aggregering tillåter oss att återanvända koden. Kodåteranvändbarhet minskar buggarna i koden och gör också applikationen mer stabil.
Nedan listas några skillnader mellan aggregering och komposition.
| Aggregering | Sammansättning |
|---|---|
| Aggregering tillåter underordnade objekt eller innehållsföremål att existera självständigt. Till exempel i ett förhållande där skolan har anställda, om vi tar bort skolan, kommer de anställda att förbli och kan fungera på egen hand. | I komposition kan det inneslutna objektet inte existera självständigt. Till exempel en bil har motor. Om vi tar bort bil kan inte motorklassen fungera på egen hand. |
| Aggregering är en 'has-a' relation. | Kompositionen är en form av förhållande 'har-a' men ses som en del-av-en-hel-relation. |
| Aggregationen har endast en till en förening. | Komposition tillåter andra relationer som tillhandahålls i föreningen. |
| Aggregeringen har en svag koppling mellan objekt. | Kompositionen har en stark koppling mellan objekt. |
Sammansättning Vs. Arv
| Sammansättning | Arv |
|---|---|
| Kompositionen skildrar förhållandet ”Has-A”. | Arv representerar 'Is-A' -förhållandet. |
| Lättare att ändra implementeringen av innehållande objekt. | När en implementering ändras förändras hela hierarkin av arv. |
| Har en dynamisk eller kör tidsbindande. | Har en statisk eller kompilerande tidsbindning. |
| Front-end klassgränssnittet kan enkelt ändras utan att det påverkar backend-klasserna. | Alla förändringar i metoder eller prototyper påverkar alla klasser. |
| Kompositionen används när vi inte behöver lägga till fler egenskaper eller funktioner till ett befintligt objekt. | Arv används när fler funktioner ska läggas till i ärvda klasser. |
Vanliga frågor
F # 1) Vad är skillnaden mellan 'IS - A' och 'HAS - A' relation?
Svar: I objektorienterad programmering representerar IS-A-relationer arv där en barnklass 'är ett slags' en föräldraklass. Has-a-förhållandet är ett ”part-of-a-whole” -förhållande som representeras av komposition och aggregering. Arv är en statisk bindning medan komposition är dynamisk bindning.
F # 2) Vad är aggregering och komposition i Java?
Svar: I sammansättning är de två föremålen tätt kopplade, dvs. när objektet (innehållande objekt) som äger ett annat objekt (innehållet objekt) förstörs, förstörs det andra objektet automatiskt eftersom det inte kan fungera självständigt på egen hand.
I Aggregation kan det innehållande och det inneslutna objektet fungera oberoende. Detta beror på att ett objekt i Aggregation använder ett annat objekt.
F # 3) Varför använder vi komposition i Java?
Svar: Sammansättning gör det möjligt för oss att återanvända den befintliga koden, vilket minskar kodens komplexitet och minskar även buggarna i koden. Med hjälp av komposition kan vi bara återanvända det vi behöver från objektet och även kontrollera dess synlighet.
F # 4) Vad är användningen av Association?
Svar: Association representerar ”has-a” -förhållandet i Java. Förening i Java används när ett objekt behöver använda funktionaliteten och tjänsterna för ett annat objekt. Sammansättning och aggregering är två former av associering.
F # 5) Är sammansättning bättre än arv?
Svar: Det beror på OOP-systemet att vi kodar. Om vi kan representera objekten med IS-A-förhållande under hela dess livstid i applikationen är arv ett bättre alternativ. När vi vill återanvända koden och inte kan representera objektsystemet med IS-A-förhållandet är kompositionen bättre.
Dessutom, när vi ofta vill ändra front-end-klasser utan att störa back-end-klasserna, är kompositionen bättre eftersom det i fall av arv påverkar små förändringar mestadels hela arvshierarkin.
Slutsats
I denna handledning har vi diskuterat HAS-A-förhållandet i Java. Sammansättning och aggregering är de former som implementerar ”HAS-A” -förhållandet. Vi har jämfört båda dessa implementeringar.
Medan båda innehåller objekt av en annan klass äger kompositionen objektet medan aggregering helt enkelt använder objektet. Vi har också jämfört kompositionen och arvet i Java.
bästa gratis nedladdningssidor för musik för Android-telefoner
=> Kolla här för att se A-Z av Java-träningsövningar.
Rekommenderad läsning
- Java SWING-handledning: Container, komponenter och händelsehantering
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
- TreeMap In Java - Handledning med Java TreeMap-exempel
- Java Float Tutorial med programmeringsexempel
- Java String med String Buffer och String Builder Tutorial
- Java-distribution: Skapande och utförande av Java JAR-fil
- Java Class Vs Object - Hur man använder klass och objekt i Java
- Java Basics: Java Syntax, Java Class och Core Java Concepts