[ HTML ] [ Java ] [ Bahasa C ]


Senin, April 15, 2019

Asosiasi, komposisi, dan agregasi pada Java

Asosiasi adalah hubungan antara dua class terpisah yang terbentuk melalui objeknya. Asosiasi bisa berupa one-to-one, one-to-many, many-to-one, many-to-many. Pada pemrograman berorientasi objek, objek berkomunikasi dengan objek lainnya menggunakan fungsi dan services yang disediakan oleh objek. Komposisi dan agregasi adalah dua bentuk dari asosiasi seperti diperlihatkan pada gambar 1.


komposisi dan agregasi dan kedudukannya terhadap asosiasi pada bahasa pemrograman Java
Gambar 1 komposisi dan agregasi
sumber : geeksforgeeks.org

// Program Java

// mengilustrasikan konsep

// asosiasi.

import java.io.*

 

/* class bank */

class Bank 

{

private String name;

 

/* nama bank */

Bank(String name

{this.name = name;} 

 

public String getBankName() 

{return this.name;}

 

/* class pegawai */ 

class Employee 

private String name; 

 

/* nama pegawai */

Employee(String name

{this.name = name;} 

 

public String getEmployeeName() 

{return this.name;} 

 

// asosiasi antara kedua class

// pada main method.

class Association 

{

 

public static void main (String[] args

Bank bank = new Bank("Axis"); 

Employee emp = new Employee("Neha"); 

System.out.println(emp.getEmployeeName() 

+" adalah pegawai dari " 

+bank.getBankName()); 

}

 

}

Output:
Neha adalah pegawai dari Axis

Pada contoh sebelumnya dua class terpisah Bank dan Employee adalah asosiasi melalui objeknya. Bank dapat memiliki banyak Employee, jadi asosiasinya adalah one-to-many seperti diperlihatkan pada gambar 2.

asosiasi one to many pada bahasa pemrograman Java
Gambar 2 asosiasi one-to-many 
sumber : geeksforgeeks.org

Agregasi
Agregasi adalah form khusus dari asosiasi dimana:
satu, Agregasi merepresentasikan Has-A relasi.
dua, Agregasi adalah unidirectional asosiasi atau relasi satu arah. Contoh, department dapat memiliki siswa tetapi tidak sebaliknya.
tiga, Pada agregasi, kedua entries dapat berdiri sendiri, yang artinya mengakhiri satu entitas tidak akan memengaruhi entitas lainnya.

// Program Java

// mengilustrasikan konsep

// agregasi.

import java.io.*

import java.util.*

 

/* student class */

class Student 

String name; 

int id ; 

String dept; 

 

Student(String name, int id, String dept

{this.name = name; 

this.id = id; 

this.dept = dept;} 

 

// Departement class

// mengandung daftar dari

// student object. Hal ini

// berasosiasi dengan student

// class melalui objeknya.

class Department 

String name; 

private List<student> students; 

 

Department(String name, List<student> students

{this.name = name; 

this.students = students;} 

 

public List<student> getStudents() 

{return students;} 

 

// Institute class mengandung

// daftar dari Department

// Object. Hal ini berasosiasi

// dengan Department class

// melalui objeknya.

class Institute 

String instituteName; 

private List<department> departments; 

 

Institute(String instituteName, List<department> departments

{this.instituteName = instituteName; 

this.departments = departments;} 

 

// menghitung jumlah siswa

// dari seluruh department

// yang diberikan institute.

public int getTotalStudentsInInstitute() 

int noOfStudents = 0

List<student> students; 

for(Department dept : departments) 

students = dept.getStudents(); 

for(Student s : students) 

{noOfStudents++;} 

return noOfStudents; 

 

/* main method */

class GFG 

{

 

public static void main (String[] args

Student s1 = new Student("Mia", 1, "CSE"); 

Student s2 = new Student("Priya", 2, "CSE"); 

Student s3 = new Student("John", 1, "EE"); 

Student s4 = new Student("Rahul", 2, "EE"); 

 

// membuat daftar dari CSE

// student.

List <student> cse_students = new ArrayList<student>(); 

cse_students.add(s1); 

cse_students.add(s2); 

  

// membuat daftar dari EE

// student.

List <student> ee_students = new ArrayList<student>(); 

ee_students.add(s3); 

ee_students.add(s4); 

  

Department CSE = new Department("CSE", cse_students); 

Department EE = new Department("EE", ee_students); 

  

List <department> departments = new ArrayList<department>(); 

departments.add(CSE); 

departments.add(EE); 

  

// menciptakan instance dari

// institute.

Institute institute = new Institute("BITS", departments); 

  

System.out.print("Total siswa"

+" adalah: "); 

System.out.print(institute.getTotalStudentsInInstitute()); 

}

 

}

Output:
Total siswa adalah : 4

Pada contoh sebelumnya, terdapat institute yang tidak memiliki no. dari department seperti CSE, EE. setiap department memiliki no. dari student. Jadi, diciptakan institute class yang memiliki referensi terhadap object atau no. dari object (list of object) dari Department class. Artinya Institute class berasosiasi dengan Department class melalui objeknya. Department class juga memiliki referensi dari objek atau beberapa objek (list of object) dari Student class atau dengan kata lain berasosiasi dengan Student class melalui objeknya. Gambar 3 memperlihatkan Has-A relasi.

asosiasi institute, department, dan student pada bahasa pemrograman Java
Gambar 3 asosiasi institute, department, dan studentsumber : geeksforgeeks.org

Kapan menggunakan agregasi?
Penggunaan ulang kode program adalah cara terbaik dari penggunaan agregasi.

Komposisi
Komposisi membatasi form dari agregasi dimana dua entitas berdiri sendiri terhadap entitas lainnya.
satu, Komposisi merepresentasikan part-of relasi.
dua, Dalam komposisi, kedua entitas bersifat dependent terhadap entitas lainnya.
tiga, Ketika terdapat komposisi antara dua entitas, maka komposisi objek tidak bisa exist tanpa entitas lainnya.

Perhatikan contoh berikut ini.

// Program Java

// mengilustrasikan konsep

// komposisi.

import java.io.*

import java.util.*

 

/* class book */

class Book 

public String title; 

public String author; 

 

Book(String title, String author

{this.title = title; 

this.author = author;} 

 

// Libary class mengandung

// list of books.

class Library 

// referensi untuk

// memperlihatkan list of

// books.

private final List<book> books; 

 

Library (List<book> books

{this.books = books;} 

 

public List<book> getTotalBooksInLibrary()

{return books;} 

 

/* main method */

class GFG 

 

public static void main (String[] args

// menciptakan objek dari Book

// class.

Book b1 = new Book("EffectiveJ Java", "Joshua Bloch");

Book b2 = new Book("Thinking in Java", "Bruce Eckel"); 

Book b3 = new Book("Java: The Complete Reference", "Herbert Schildt"); 

  

// menciptakan daftar yang

// mengandung no. dari book.

List<book> books = new ArrayList<book>(); 

books.add(b1); 

books.add(b2); 

books.add(b3); 

  

Library library = new Library(books); 

  

List<book> bks = library.getTotalBooksInLibrary(); 

 

for(Book bk : bks)

{System.out.println("Judul : "

+bk.title 

+" dan "

+" Pengarang : " 

+bk.author);} 

}

 

}

Output:
Judul : EffectiveJ Java dan  Pengarang : Joshua Bloch
Judul : Thinking in Java dan  Pengarang : Bruce Eckel
Judul : Java: The Complete Reference dan  Pengarang : Herbert Schildt

Pada contoh sebelumnya library dapat memiliki no. dari book pada subjek yang sama ataupun berbeda. Jadi, jika Library dihancurkan (free memory) maka semua book dalam library tertentu akan ikut hancur atau dengan kata lain book tidak bisa exist tanpa library.

Aggregasi dan Komposisi
satu, Dependency: Agregasi menyiratkan hubungan dimana child dapat exist mandiri dari parent. Contoh, Bank dan Employee, jika Bank dihapus maka Employee akan tetap exist. Komposisi menyiratkan hubungan dimana child tidak bisa exist secara mandiri tanpa parent. Contoh: Manusia dan jantung, jantung tidak bisa exist jika terpisah dari manusia.
dua, Tipe dari relasi: Aggregasi relasi adalah "has-a" dan komposisi "part-of" relasi.
tiga, Tipe dari asosiasi: Komposisi adalah asosiasi yang bersifat kuat (strong) dan agregasi adalah asosiasi yang bersifat lemah (weak).

// Program Java

// menglilustrasikan perbedaan

// antara agregasi dan

// komposisi.

import java.io.*

 

// Engine class akan digunakan

// oleh car. jadi 'Car' class

// akan memiliki bagian dari

// tipe mesin.   

class Engine 

/* starting engine */ 

public void work() 

{System.out.println("Mesin"

+" kendaraan dinyalakan");} 

 

/* Engine class */

final class Car 

// Untuk menggerakkan

// kendaraan, kendaraan

// membutuhkan mesin.

private final Engine engine; 

/* Komposisi */ 

/* private Engine engine; */ /* Aggregation */

 

Car(Engine engine

{this.engine = engine;} 

 

// kendaraan mulai bergerak

// oleh starting engine.

public void move() 

/* if(engine != null) */

{engine.work(); 

System.out.println("Kendaraan"

+" bergerak ");} 

}

 

class GFG 

public static void main (String[] args

{

// membuat mesin dengan cara

// menciptakan instance dari

// Engine class.

Engine engine = new Engine(); 

  

// Membuat kendaraan dengan

// mesin. melewatkan isntance

// mesin (engine) sebagai

// argument ketika mencipakan

// instance dari kendaraan

// (car).

Car car = new Car(engine); 

car.move();} 

}

Output:
Mesin kendaraan dinyalakan
Kendaraan bergerak

Dalam hal agregasi, Car juga menjalankan fungsinya melalui Engine. tetapi Engine tidak selalu merupakan bagian internal dari Car. Mesin dapat ditukar keluar atau bahkan dapat dilepas dari kesatuan komponen Car. Itu sebabnya bidang tipe Engine tidak dibuat final.

Tidak ada komentar:

Posting Komentar

Respon komentar 7 x 24 jam, so please be patient :D