Langsung ke konten utama

Iklan





Asosiasi, Komposisi, dan Agregasi pada Java

Dalam artikel ini akan dijelaskan fungsi dari asosiasi, komposis, dan agregasi yang merupakan bentuk-bentuk hubungan antar object dalam OOP Java.

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


// 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.




Iklan

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) yang berasal dari Department class. Artinya Institute class berasosiasi dengan Department class melalui object-nya. Department class juga memiliki referensi dari object atau beberapa object (list of object) dari Student class atau dengan kata lain berasosiasi dengan Student class melalui object-nya. Gambar 3 memperlihatkan Has-A relasi.


Waktu Penggunaan Agregasi
Ketika melakukan penggunaan ulang kode program adalah cara terbaik dari penggunaan agregasi.



Iklan

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 object 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 subject 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 ini menyiratkan hubungan dimana child tidak bisa exist secara mandiri tanpa adanya 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. Engine dapat ditukar keluar atau bahkan dapat dilepas dari kesatuan komponen Car. Itu sebabnya bidang tipe Engine tidak dibuat final.


Iklan

Komentar

  1. Apa yang dimaksud dengan agregasi dalam bahasa pemrograman Java?

    BalasHapus
    Balasan
    1. Ketika sebuah object A berisi nilai referensi ke object B lain atau Object A memiliki hubungan HAS-A dengan Object B, maka hubungan tersebut disebut dengan hubungan agregasi. Agregasi membantu dalam penggunaan ulang suatu kode program. Object B dalam memiliki method utilitas dan dapat digunakan oleh banyak object lainnya.

      Hapus
  2. Apa yang dimaksud dengan sosiasi dalam bahasa pemrograman Java?

    BalasHapus
    Balasan
    1. Asosiasi pada Java adalah bentuk koneksi atau relasi antara dua class terpisah yang diatur melalui object-nya. Hubungan asosiasi menunjukkan bagaimana object dapat mengetahui satu sama lain dan bagaimana object-object tersebut menggunakan fungsionalitas satu sama lainnya.

      Hapus
  3. Apa yang dimaksud dengan komposisi dalam bahasa pemrograman Java?

    BalasHapus
    Balasan
    1. Komposisi merupakana salah satu teknik perancangan pada Java yang digunakan untuk mengimplementasikan hubungan HAS-A. Komposisi dapat dicapai dengan menggunakan instance variabel yang mengacu pada object lain.

      Hapus

Posting Komentar

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