Menu

Skład Java - co to jest kompozycja (Has-A) w Javie

  • Główny
  • Inny
  • Skład Java - co to jest kompozycja (Has-A) w Javie

java composition what is composition java

Wypróbuj Nasz Instrument Do Eliminowania Problemów

Ten samouczek dotyczący kompozycji Java wyjaśnia, czym jest kompozycja i agregacja w języku Java oraz różnice między nimi:

W ostatnich kilku samouczkach szczegółowo omówiliśmy dziedziczenie w Javie. Dziedziczenie w Javie to rodzaj relacji „IS-A”, która wskazuje, że jeden obiekt „jest rodzajem” innego obiektu. Na przykład, samochód to typ lub rodzaj pojazdu.

Programowanie obiektowe zapewnia inny typ relacji zwany relacją „HAS-A”. W tym samouczku szczegółowo omówimy związek typu „ma-a”.

=> Odwiedź tutaj, aby nauczyć się języka Java od podstaw.

Skład (Has-A) w Javie

Czego się nauczysz:

Samouczek dotyczący kompozycji w języku Java

W Javie nazywa się relację „ma-a” Kompozycja . Stosując relację lub kompozycję typu „ma-a”, zapewniamy możliwość ponownego wykorzystania kodu w naszych programach.

Zatem sprawiając, że nasze programy używają relacji „ma-a”, to, co tutaj robimy, polega na tym, że sprawiamy, że nasz program używa instancji klasy bezpośrednio, zamiast „rozszerzać” ją z innej klasy, tak jak robimy to w przypadku dziedziczenia.

Poniższy diagram przedstawia relacje „is-a” i „has-a” w Javie.

Ma - Relacja

Jak widać na powyższym diagramie, samochód i pojazd mają wspólny związek „IS-A”, tak jak samochód jest pojazdem. Dlatego tworzymy obiekt samochodu z istniejącego obiektu pojazdu, dodając do niego więcej charakterystyk.

Na diagramie samochód i silnik mają wspólny związek „Has-a”. Samochód zawsze ma silnik. Więc to, co tutaj robimy, to to, że nie rozszerzamy właściwości obiektu Engine, ale bezpośrednio używamy obiektu Engine. Odbywa się to w Javie przy użyciu kompozycji.

Dlatego wraz z hermetyzacją, abstrakcją i polimorfizmem dziedziczenie i kompozycja są również ważnymi cechami programowania obiektowego (OOP).

Relacje typu „ma-a” zwykle określają, czy dany obiekt ma inny przedmiot. Więc to, co tutaj robimy, to ponowne użycie obiektu, a tym samym zmniejszenie liczby duplikatów kodu oraz błędów. Dzieje się tak, ponieważ używamy w naszej klasie całkowicie opracowanego i przetestowanego obiektu.

Zacznijmy od omówienia specjalnej relacji zwanej „skojarzeniem” w języku Java, z której wyprowadzamy kompozycję i inne zależności.

Skojarzenie w Javie

Skojarzenie w Javie można zdefiniować jako relację istniejącą między dwiema indywidualnymi klasami używającymi ich oddzielnych obiektów. Skojarzenie w Javie może mieć następujące relacje.

  • Jeden na jednego: Jeden obiekt powiązany z dokładnie jednym obiektem.
  • Jeden za dużo: Jeden obiekt może być powiązany z wieloma obiektami.
  • Wiele do jednego: Z jednym obiektem można skojarzyć wiele obiektów.
  • Wiele do wielu: Więcej niż jeden obiekt powiązany z więcej niż jednym innym obiektem.

Po ustanowieniu relacji obiekty zawierające (obiekty, których członkami są inne obiekty) komunikują się z obiektem zawartym w celu ponownego wykorzystania ich właściwości i charakterystyk. Asocjacja ma dwie formy, tj. Skład i agregację.

Poniższy rysunek pokazuje to:

Kompozycja i agregacja

Jak widać na powyższym diagramie, Stowarzyszenie obejmuje Skład i agregację. Kompozycja jest terminem bardziej szczegółowym, a agregacja jest bardziej ogólna niż kompozycja. Formy te są oparte na typie relacji, które obsługują.

Zanim przejdziemy do kompozycji i agregacji, zaimplementujmy program w języku Java, aby zademonstrować powiązanie w języku 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()); } }

Wynik:

Wyjście Ex Association

Powyższy program demonstruje skojarzenie w Javie. Tutaj mamy konto klasowe, które ma nazwę banku i numer konta jako prywatni członkowie. Następnie mamy klasę Pracownik. Wiemy, że każdy pracownik będzie miał numer konta do wpłaty wynagrodzenia itp.

Więc zamiast pisać inną klasę lub metodę do odczytania danych konta bankowego pracownika, bezpośrednio ponownie wykorzystujemy istniejącą klasę konta. Innymi słowy, łączymy obiekt Konto z Pracownikiem, dzięki czemu uzyskujemy dane konta bankowego Pracownika. Powyższy przykład dokładnie to robi.

Kompozycja w Javie

Skład jest jedną z form stowarzyszenia. Kompozycję można zdefiniować jako asocjację, w której jedna klasa zawiera inną klasę, a ta zawarta klasa zależy od klasy zawierającej w taki sposób, że nie może istnieć niezależnie.

Widzieliśmy powyżej przykład relacji ma-a. W tym przypadku mieliśmy samochód z silnikiem. To jest przykład kompozycji. W tym przypadku silnik nie może istnieć samodzielnie bez samochodu.

Kompozycja jest bardziej ograniczona w porównaniu z Agregacją. Kompozycja nie jest funkcją Java. Uważa się to głównie za technikę projektowania.

Poniższy diagram przedstawia przykład kompozycji.

przykład kompozycji

najlepsze pliki do pobrania muzyki mp3 na Androida

W tym przypadku Pracownik ma konto bankowe. Wiemy, że konto bankowe nie może istnieć bez właściciela konta. Bez właściciela konta przechodzi w stan uśpienia.

Możemy użyć kompozycji do modelowania obiektów, których członkami są inne obiekty, a te obiekty mają między sobą relację „ma”.

W kompozycji obiekt jest zawarty w innym obiekcie, a zatem gdy zawierający go obiekt zostaje zniszczony; drugi obiekt również ulega zniszczeniu

Możemy więc postrzegać relację kompozycji jako relację „części całości”, w której część nie istnieje bez cały . W związku z tym, gdy całość zostanie zniszczona, część również zostanie usunięta. Oznacza to, że całość ma silniejszy związek z częścią.

Przykład kompozycji Java

Poniżej podano program do zademonstrowania składu.

System, którego tutaj użyliśmy, jest przedstawiony poniżej.

Przykład kompozycji

Tak więc w tym programie mamy trzy klasy, jak pokazano powyżej. Honda jest samochodem, więc wywodzi się z klasy samochodów. CarEngine Object jest używany w klasie Honda.

Program jest podany poniżej.

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(); } }

Wynik:

Dane wyjściowe - przykład kompozycji

Zatem dane wyjściowe pokazują właściwości samochodów Hondy. Pokazuje również wynik metody z klasy CarEngine, której użyliśmy jako element członkowski klasy Honda przy użyciu kompozycji.

Ten program pokazał, jak możemy wykorzystać kompozycję w programie Java.

Agregacja w Javie

Agregacja to kolejna forma asocjacji w Javie. Ale w przypadku agregacji pozwala tylko na jednokierunkową relację między obiektami. Na przykład, pracownik ma adres domowy. Ale na odwrót, adres domowy ma pracowników, nie brzmi dobrze.

Podobnie, uczeń ma adres, ale „adres ma ucznia” nie ma sensu. Podobnie jak kompozycja, agregacja również przedstawia relację „ma-a”. Oznacza to, że klasa zawiera obiekt innej klasy.

Poniższy diagram przedstawia przykład agregacji.

Przykład agregacji

Powyższy przykład można interpretować, jako że Kolegium ma pracowników i studentów.

Kiedy więc dokładnie powinniśmy wybrać Agregację?

Powinniśmy używać agregacji, gdy nie ma potrzeby korzystania z relacji „jest-a” lub dziedziczenia. Jeśli uda nam się zachować relację „jest-a” przez całą aplikację lub przez cały okres istnienia obiektu, możemy zaimplementować dziedziczenie w celu ponownego wykorzystania kodu.

W przeciwnym razie najlepiej jest użyć agregacji w celu ponownego wykorzystania kodu. Zaimplementujmy teraz przykładową agregację w Javie.

Przykładowy system, którego użyliśmy, wygląda następująco:

przykład agregacji

Tutaj mamy klasę „Instytutu”. Instytut może mieć różne wydziały lub oddziały. Z kolei każdy oddział ma kilku studentów. W tym programie policzymy całkowitą liczbę studentów w całym instytucie. W tym celu używamy agregacji. Klasa Instytut zawiera obiekt Branch.

Obiekt oddziału zawiera obiekt studenta. Czyli w klasie Instytutu za pomocą obiektu Branch liczymy całkowitą liczbę studentów. W tym celu korzystamy z listy oddziałów w instytucie.

Program Java jest podany poniżej.

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()); } }

Wynik:

Agregacja w Javie - dane wyjściowe

Stąd agregacja i kompozycja to dwie formy asocjacji, o których tutaj mówiliśmy. Kiedy nie potrzebujemy lub nie możemy reprezentować relacji „jest-a” między obiektami, możemy wybrać kompozycję, jeśli chcemy silniejszego związku między obiektami lub agregacji, jeśli chcemy związku jednostronnego.

Zarówno agregacja, jak i kompozycja pomagają nam ponownie używać kodu w Javie.

Różnice między agregacją a kompozycją

Zarówno skład, jak i agregacja są częściami stowarzyszenia, które przedstawiają związek „ma-a”. Obie techniki nie są funkcjami Java i nie mają bezpośredniego sposobu implementacji, ale można je zaimplementować za pomocą kodu Java.

Kompozycja i agregacja pozwalają nam ponownie wykorzystać kod. Możliwość ponownego wykorzystania kodu zmniejsza liczbę błędów w kodzie, a także sprawia, że ​​aplikacja jest bardziej stabilna.

Poniżej wymieniono niektóre różnice między agregacją a kompozycją.

ZbiórKompozycja
Agregacja umożliwia niezależne istnienie obiektów podrzędnych lub obiektów zawartych. Na przykład w relacji, w której Szkoła ma Pracowników, jeśli usuniemy Szkołę, Pracownicy pozostaną i będą mogli samodzielnie funkcjonować.W kompozycji zawarty obiekt nie może istnieć samodzielnie. Na przykład samochód ma silnik. Jeśli usuniemy Car, klasa Engine nie może działać samodzielnie.
Agregacja to relacja typu „ma-a”.Kompozycja jest formą relacji „ma”, ale postrzegana jako część całości.
Agregacja ma tylko powiązanie jeden do jednego.Kompozycja zezwala na inne relacje dostępne w asocjacji.
Agregacja ma słabe powiązanie między obiektami.Kompozycja ma silny związek między przedmiotami.

Kompozycja Vs. Dziedzictwo

KompozycjaDziedzictwo
Kompozycja przedstawia zależność „Has-A”.Dziedziczenie reprezentuje relację „Is-A”.
Łatwiejsza zmiana implementacji obiektów zawierających.Kiedy jedna implementacja zmienia, zmienia się cała hierarchia dziedziczenia.
Ma powiązanie dynamiczne lub związane z czasem wykonywania.Ma powiązanie statyczne lub czas kompilacji.
Interfejs klasy Front-end można łatwo zmienić bez wpływu na klasy zaplecza.Wszelkie zmiany metod lub prototypów wpływają na wszystkie klasy.
Kompozycja jest używana, gdy nie musimy dodawać więcej cech lub funkcji do istniejącego obiektu.Dziedziczenie jest używane, gdy więcej funkcji ma zostać dodanych do dziedziczonych klas.

Często Zadawane Pytania

P 1) Jaka jest różnica między relacjami „IS - A” i „MA - A”?

Odpowiedź: W programowaniu obiektowym relacje IS-A reprezentują dziedziczenie, w którym klasa potomna „jest rodzajem” klasy nadrzędnej. Relacja Has-a jest relacją „część-całości”, która jest reprezentowana przez kompozycję i agregację. Dziedziczenie jest wiązaniem statycznym, podczas gdy kompozycja jest wiązaniem dynamicznym.

Pytanie 2) Co to jest agregacja i kompozycja w Javie?

Odpowiedź: W kompozycji oba obiekty są ze sobą ściśle powiązane, tj. Gdy obiekt (zawierający obiekt) będący właścicielem innego obiektu (obiekt zawarty) jest niszczony, drugi obiekt jest niszczony automatycznie, ponieważ nie może samodzielnie funkcjonować.

W agregacji obiekt zawierający i zawarty może działać niezależnie. Dzieje się tak, ponieważ w agregacji jeden obiekt używa innego obiektu.

Pytanie 3) Dlaczego używamy kompozycji w Javie?

Odpowiedź: Kompozycja pozwala nam ponownie wykorzystać istniejący kod, zmniejszając w ten sposób złożoność kodu, a także redukuje błędy w kodzie. Korzystając z kompozycji, możemy ponownie wykorzystać tylko to, czego potrzebujemy z obiektu, a także kontrolować jego widoczność.

P # 4) Jaki jest pożytek ze skojarzenia?

ile możesz zarobić na testach użytkowników

Odpowiedź: Skojarzenie reprezentuje relację „ma-a” w Javie. Skojarzenie w języku Java jest używane, gdy jeden obiekt musi korzystać z funkcjonalności i usług innego obiektu. Kompozycja i agregacja to dwie formy asocjacji.

P # 5) Czy kompozycja jest lepsza niż dziedziczenie?

Odpowiedź: To zależy od systemu OOP, który kodujemy. Jeśli możemy reprezentować w aplikacji obiekty z relacją IS-A przez cały okres ich istnienia, wówczas dziedziczenie jest lepszą opcją. Kiedy chcemy ponownie użyć kodu i nie możemy przedstawić systemu obiektowego za pomocą relacji IS-A, wtedy kompozycja jest lepsza.

Również, gdy chcemy często zmieniać klasy front-end bez naruszania klas back-endowych, wtedy kompozycja jest lepsza, ponieważ w przypadku dziedziczenia niewielkie zmiany wpływają głównie na całą hierarchię dziedziczenia.

Wniosek

W tym samouczku omówiliśmy relację HAS-A w Javie. Kompozycja i agregacja to formy, które realizują zależność „HAS-A”. Porównaliśmy obie te implementacje.

Chociaż oba zawierają obiekty innej klasy, kompozycja jest właścicielem obiektu, podczas gdy agregacja po prostu używa tego obiektu. Porównaliśmy również skład i dziedziczenie w Javie.

=> Zajrzyj tutaj, aby zobaczyć samouczki szkoleniowe od A do Z języka Java.

rekomendowane lektury

^