Menu

Java-sammensætning - Hvad er sammensætning (Has-A) i Java

  • Vigtigste
  • Andet
  • Java-sammensætning - Hvad er sammensætning (Has-A) i Java

java composition what is composition java

Denne Java Composition-tutorial forklarer, hvad der er Composition and Aggregation i Java og forskellene mellem dem:

I de sidste par tutorials diskuterede vi arv i Java detaljeret. Arv i Java er en type 'IS-A' -forhold, der indikerer, at et objekt 'er en slags' et andet objekt. For eksempel, en bil er en type eller type køretøj.

Objektorienteret programmering giver en anden type forhold kaldet “HAS-A” -forholdet. I denne vejledning vil vi diskutere has-a-forholdet detaljeret.

=> Besøg her for at lære Java fra bunden.

Komposition (Has-A) i Java

Hvad du lærer:

Java-kompositionsvejledning

Forholdet 'has-a' i Java kaldes Sammensætning . Ved at bruge 'has-a' -forhold eller -sammensætning sikrer vi genanvendelighed af koder i vores programmer.

Så ved at få vores programmer til at bruge 'has-a' forhold, hvad vi laver her er, at vi får vores program til at bruge en forekomst af en klasse direkte i stedet for at 'udvide' den fra en anden klasse, som vi gør i tilfælde af arv.

Nedenstående diagram viser både 'is-a' og 'has-a' forhold i Java.

Har - en relation

Som det fremgår af ovenstående diagram, deler bil og køretøj 'IS-A' forholdet, da en bil er et køretøj. Derfor opretter vi et bilobjekt ud fra det eksisterende køretøjsobjekt ved at tilføje flere egenskaber til det.

I diagrammet deler bil og motor 'Has-a'-forholdet. En bil har altid en motor. Så hvad vi gør her er, at vi ikke udvider motorobjektets egenskaber, men vi bruger motorobjektet direkte. Dette gøres i Java ved hjælp af komposition.

Derfor er arv og komposition sammen med indkapsling, abstraktion og polymorfisme også vigtige træk ved objektorienteret programmering (OOP).

Forholdet mellem 'has-a' bestemmer normalt, om et bestemt objekt har et andet objekt. Så hvad vi gør her er, at vi genbruger et objekt og dermed reducerer dobbeltkopiering såvel som fejl. Dette skyldes, at vi bruger et fuldt udviklet og testet objekt i vores klasse.

Lad os starte med diskussionen af ​​en speciel relation kaldet 'Association' i Java, hvorfra vi henter komposition og andre relationer.

Association i Java

Associering i Java kan defineres som en relation, der eksisterer mellem to individuelle klasser ved hjælp af deres separate objekter. Association i Java kan have følgende relationer.

  • En til en: Et objekt associeret med nøjagtigt et objekt.
  • En-til-mange: Et objekt kan associeres med mange objekter.
  • Mange-til-en: Mange objekter kan knyttes til et objekt.
  • Mange-til-mange: Mere end et objekt tilknyttet mere end et andet objekt.

Når et forhold er etableret, kommunikerer de indeholdende objekter (objekter, der har andre objekter som deres medlemmer) med det indeholdte objekt for at genbruge deres egenskaber og egenskaber. Foreningen har to former, dvs. sammensætning og sammenlægning.

Nedenstående figur viser dette:

Komposition og aggregering

Som det fremgår af ovenstående diagram, inkluderer foreningen sammensætning og aggregering. Sammensætning er et mere specifikt udtryk, og aggregering er mere generelt end sammensætning. Disse former er baseret på, hvilken type forhold de understøtter.

Inden vi går videre til komposition og sammenlægning, lad os implementere et Java-program for at demonstrere foreningen 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:

Association Ex Output

Ovenstående program viser en tilknytning i Java. Her har vi en klassekonto, der har et banknavn og kontonummer som private medlemmer. Dernæst har vi en medarbejderklasse. Vi ved, at enhver medarbejder vil have et kontonummer til deponering af løn osv.

Så hvad vi gør er, i stedet for at skrive en anden klasse eller metode til at læse i medarbejderens bankkontooplysninger, genbruger vi direkte den eksisterende kontoklasse. Med andre ord forbinder vi et kontoobjekt med medarbejderen, så vi får medarbejderens bankkontooplysninger. Ovenstående eksempel gør nøjagtigt dette.

Sammensætning i Java

Sammensætningen er en form for forening. Sammensætningen kan defineres som en forening, hvor en klasse indeholder en anden klasse, og denne indeholdte klasse afhænger af den indeholdende klasse på en sådan måde, at den ikke kan eksistere uafhængigt.

Vi har set et eksempel på et forhold mellem has og forhold ovenfor. I det havde vi en bilgenstand, der har en motor. Dette er et eksempel på sammensætning. I dette kan en motor ikke eksistere uafhængigt uden en bil.

Kompositionen er mere begrænset sammenlignet med Aggregation. Kompositionen er ikke en Java-funktion. Det betragtes hovedsageligt som en designteknik.

Følgende diagram viser et kompositionseksempel.

sammensætningseksempel

I dette har en medarbejder en bankkonto. Vi ved, at en bankkonto ikke kan eksistere uden en kontoindehaver. Uden en kontoindehaver bliver det sovende.

hvile api interview spørgsmål og svar

Vi kan bruge komposition til at modellere objekter, der har andre objekter som medlemmer, og disse objekter har 'has-a' -forhold imellem sig.

I komposition er et objekt indeholdt i et andet objekt, derfor når det indeholdende objekt ødelægges; det andet objekt ødelægges også

Så vi kan se sammensætningsforholdet som et 'del af en helhed' -forhold, hvori en del eksisterer ikke uden hel . Derfor, når det hele ødelægges, slettes delen også. Det betyder, at det hele har et stærkere forhold til delen.

Eksempel på Java-sammensætning

Nedenfor er programmet til at demonstrere komposition.

Det system, vi brugte her, er repræsenteret som nedenfor.

Sammensætningseksempel

Så i dette program har vi tre klasser som vist ovenfor. Honda er en bil, så den strækker sig fra klassen bil. CarEngine Object bruges i Honda-klasse.

Programmet er angivet nedenfor.

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:

Output - Sammensætningseksempel

Således viser output egenskaberne hos Honda-biler. Det viser også output fra en metode fra CarEngine-klassen, som vi har brugt som medlem af Honda-klassen ved hjælp af komposition.

Dette program viste, hvordan vi kan bruge komposition i et Java-program.

Aggregering i Java

Aggregation er en anden form for tilknytning i Java. Men i tilfælde af sammenlægning tillader det kun envejsforholdet mellem objekterne. For eksempel, en medarbejder har en hjemmeadresse. Men omvendt, hjemmeadressen har ansatte, lyder det ikke rigtigt.

Tilsvarende har en studerende en adresse, men 'adresse har en studerende' giver ikke mening. Ligesom komposition viser aggregering også forholdet 'has-a'. Dette betyder, at en klasse indeholder et objekt fra en anden klasse.

Nedenstående diagram repræsenterer et samlet eksempel.

Aggregationseksempel

Ovenstående eksempel kan fortolkes således, at kollegiet har personale og studerende.

Så hvornår skal vi gå til Aggregation?

Vi bør bruge aggregering, når der ikke er behov for at bruge et 'is-a' forhold eller arv. Hvis vi kan opretholde 'is-a' -forholdet i et objekts applikation eller levetid, kan vi implementere arv til genbrug af kode.

Ellers er det bedst at bruge aggregering til genanvendelighed af kode. Lad os nu implementere et eksempel på aggregering i Java.

Eksempletsystemet, vi har brugt, er som følger:

eksempel aggregering

Her har vi en 'Institute' klasse. Instituttet kan have forskellige afdelinger eller grene. Hver gren har til gengæld flere studerende. I dette program tæller vi det samlede antal studerende på hele instituttet. Vi bruger aggregering til dette formål. Klasseinstituttet indeholder filialobjektet.

Filialobjektet har et studenterobjekt. Så i instituttklassen ved hjælp af filialobjektet tæller vi det samlede antal studerende. Til dette formål bruger vi en liste over filialer i et institut.

Java-programmet er angivet nedenfor.

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:

Aggregering i Java - output

Derfor er aggregering og sammensætning to former for tilknytning, som vi har diskuteret her. Når vi ikke har brug for eller ikke kan repræsentere 'is-a' forhold mellem objekter, kan vi gå efter komposition, hvis vi ønsker et stærkere forhold mellem objekter eller aggregering, hvis vi ønsker et envejsforhold.

Både aggregering og sammensætning hjælper os med at genbruge kode i Java.

Forskelle mellem aggregering vs sammensætning

Både sammensætning og aggregering er dele af foreningen, der skildrer et 'has-a' forhold. Begge teknikker er ikke Java-funktioner og har ikke en direkte måde at implementere på, men kan implementeres ved hjælp af Java-kode.

Sammensætning og aggregering giver os mulighed for at genbruge koden. Koden genanvendelighed reducerer fejl i koden og gør også applikationen mere stabil.

Nedenfor er nogle forskelle mellem aggregering og komposition.

AggregeringSammensætning
Aggregering tillader underordnede eller indeholdte objekter at eksistere uafhængigt. For eksempel i et forhold, hvor skolen har medarbejdere, hvis vi sletter skolen, forbliver medarbejderne og kan fungere alene.I komposition kan det indeholdte objekt ikke eksistere uafhængigt. For eksempel en bil har motor. Hvis vi sletter bil, kan motorklassen ikke fungere alene.
Aggregering er et 'has-a' forhold.Kompositionen er en form for 'has-a' -forhold, men betragtes som en del-af-en-hel-relation.
Aggregationen har kun en til en forening.Komposition tillader andre forhold, der leveres i foreningen.
Aggregationen har en svag sammenhæng mellem objekter.Kompositionen har en stærk sammenhæng mellem objekter.

Sammensætning vs. Arv

SammensætningArv
Kompositionen skildrer forholdet mellem 'Has-A'.Arv repræsenterer 'Is-A' forhold.
Lettere at ændre implementeringen af ​​indeholdende objekter.Når en implementering ændrer hele hierarkiet af arv.
Har en dynamisk eller kørende tidsbinding.Har en statisk eller kompilerende tidsbinding.
Front-end klasse interface kan let ændres uden at påvirke back-end klasser.Eventuelle ændringer i metoder eller prototyper påvirker alle klasser.
Kompositionen bruges, når vi ikke behøver at tilføje flere egenskaber eller funktioner til et eksisterende objekt.Arv bruges, når flere funktioner skal føjes til nedarvede klasser.

Ofte stillede spørgsmål

Q # 1) Hvad er forskellen mellem 'IS - A' og 'HAS - A' forhold?

Svar: I objektorienteret programmering repræsenterer IS-A-relationer arv, hvor en barneklasse 'er en slags' en overordnet klasse. Has-a-forholdet er et 'part-of-a - whole' forhold, der er repræsenteret ved komposition og aggregering. Arv er en statisk binding, mens sammensætning er dynamisk binding.

Q # 2) Hvad er aggregering og sammensætning i Java?

Svar: I sammensætning er de to objekter tæt koblet, dvs. når objektet (indeholdende objekt), der ejer et andet objekt (indeholdt objekt) ødelægges, ødelægges det andet objekt automatisk, da det ikke kan fungere uafhængigt alene.

I Aggregation kan det indeholdende og det indeholdte objekt fungere uafhængigt. Dette skyldes, at et objekt i Aggregation bruger et andet objekt.

Q # 3) Hvorfor bruger vi komposition i Java?

Svar: Sammensætning giver os mulighed for at genbruge den eksisterende kode og derved reducere kodens kompleksitet og reducerer også fejlene i koden. Ved hjælp af komposition kan vi kun genbruge det, vi har brug for fra objektet, og også kontrollere dets synlighed.

Spørgsmål nr. 4) Hvad er brugen af ​​Association?

Svar: Association repræsenterer 'has-a' -forholdet i Java. Tilknytning i Java bruges, når et objekt skal bruge funktionaliteten og tjenesterne til et andet objekt. Sammensætning og aggregering er to former for tilknytning.

Spørgsmål nr. 5) Er sammensætning bedre end arv?

Svar: Det afhænger af OOP-systemet, at vi koder. Hvis vi kan repræsentere objekterne med IS-A-forhold gennem hele dets levetid i applikationen, er arv en bedre mulighed. Når vi ønsker at genbruge koden og ikke kan repræsentere objektsystemet med IS-A-forholdet, er sammensætningen bedre.

Også når vi ofte vil skifte front-end klasser uden at forstyrre back-end klasser, så er sammensætningen bedre, fordi i tilfælde af arv påvirker små ændringer for det meste hele arvshierarkiet.

Konklusion

I denne vejledning har vi diskuteret HAS-A-forholdet i Java. Komposition og aggregering er de former, der implementerer 'HAS-A' forholdet. Vi har sammenlignet begge disse implementeringer.

hvordan man tester for SQL-injektion

Mens begge indeholder objekter af en anden klasse, ejer kompositionen objektet, mens aggregering simpelthen bruger objektet. Vi har også sammenlignet sammensætningen og arven i Java.

=> Tjek her for at se AZ af Java-træningsvejledninger.

Anbefalet læsning

^