Form Diskusi Pertemuan 12
Design Patterns 02
Tujuan diskusi:
Mahasiswa mampu mengimplementasi Factory Pattern dan Singleton Pattern dengan
menggunakan Bahasa Java.
Tutorial 12.1: Factory Pattern
1. Factory Pattern merupakan pattern yang digunakan untuk menciptakan sebuah objek dari
kelas tertentu. Dalam membuat objek dengan pattern ini, kita tidak dihadapkan dengan lojik
bagaimana objek dibuat, melainkan penciptaan objek dilakukan melalui sebuah antarmuka.
Struktur pattern dapat dilihat pada gambar 3 berikut ini:
Gambar 1. Struktur Factory Pattern
2. Dengan menggunakan struktur composite pada tutorial 11.4, Pada tutorial ini, akan
diimplementasikan Factory Pattern, dengan kelas-kelas yang terlibat seperti pada gambar 2
berikut:
P a g e 1 | 11
Employee Asuransi
FactoryPatternTest * 1 -views: Vector<Employee>
- role: String
- name: String + attach(Employee): void
- asuransi: float + notifyObserver(float): void
- model: Asuransi + setState(float): void
+ addChild(Employee) : void
+ getChild(int) : Employee
+ traverseEmp() : void
+ update(float) : void
Staf
EmployeeFactory Manager
+ addChild(Employee) : void
creates
+create(String,String,String,Asuransi) : + getChild(int) : Employee -employee: List<employee>
Employee
+ traverseEmp() : void + addChild(Employee) : void
+ update(float) : void + getChild(int) : Employee
creates + traverseEmp() : void
+ update(float) : void
Gambar 2. Struktur Lengkap Factory Pattern Sesuai Kasus
No Kelas dalam Factory Pattern Kelas Tutorial
1 Abstract Product Employee
2 Concrete Product Manager
3 Concrete Product Staf
4 Factory EmployeeFactory
5 Client FactoryPatternTest
----------
3. Buatlah project dengan nama FactoryPattern
4. Gunakan kelas-kelas yang ada dalam tutorial 11.4, yaitu : Employee, Manager, Staf, dan
Asuransi.
5. Buatlah kelas EmployeeFactory, dengan kode program berikut ini:
public class EmployeeFactory {
public Employee create(String type, String name, String role,
Asuransi asr) {
if ([Link]("Manager")) {
[Link]("Membuat Instance Manager");
return new Manager(name, role, asr);
}
else { // Penciptaan objek Staf
[Link]("Membuat Instance Staf");
return new Staf(name, role, asr);
}
}
}
P a g e 2 | 11
6. Buat kelas FactoryPatternTest menjadi berikut ini:
public class FactoryPatternTest {
public static void main(String[] args) throws IOException {
EmployeeFactory ef = new EmployeeFactory();
Asuransi kis = new Asuransi();
Employee direktur = [Link]("Manager", "Arief Nugraha", "Direktur", kis);
Employee mankeu = [Link] ("Manager", "Suryana", "Manajer Keuangan", kis);
Employee mansdm = [Link] ("Manager", "Susila","Manajer SDM", kis);
Employee kaakun = [Link] ("Manager", "Septarini","Kabag Akuntansi", kis);
Employee kaaudt = [Link] ("Manager", "Herjuna","Kabag Audit", kis);
Employee kapsdm = [Link] ("Manager", "Dewi Yani", "Kabag SDM", kis);
Employee kaprom = [Link] ("Manager", "Eleonora", "Kabag Promosi", kis);
Employee skeu1 = [Link] ("Staf", "Panduwinata", "Staf Keuangan", kis);
Employee skeu2 = [Link] ("Staf", "Megadewi", "Staf Keuangan", kis);
Employee ssdm1 = [Link] ("Staf", "Trifina", "Staf SDM", kis);
Employee ssdm2 = [Link] ("Staf", "Kanda", "Staf SDM", kis);
Employee ssdm3 = [Link] ("Staf", "Arjuna", "Staf SDM", kis);
[Link](mankeu); [Link](mansdm);
[Link](kaakun); [Link](kaaudt);
[Link](skeu1);
[Link](skeu2);
[Link](kapsdm); [Link](kaprom);
[Link](ssdm1); [Link](ssdm2);
[Link](ssdm3);
[Link]();
InputStreamReader values = new InputStreamReader ([Link]);
BufferedReader br = new BufferedReader(values);
do {
[Link]("\nInput kenaikan premi [0..1] : ");
String valueStr = [Link]();
if ([Link]("00"))
break;
[Link]([Link](valueStr));
[Link]();
} while(true);
}
}
7. Eksekusi program.
Apa yang bisa Anda simpulkan dengan menggunakan Factory Pattern ?
Kesimpulan yang kami dapat dari Factory pattern yaitu, factory pattern ini digunakan untuk
membuat atau menciptakan sebuah objek yang mana nantinya akan memutuskan kelas anak
mana yang akan di buat objeknya, dimana pattern factory sendiri menerapkan konsep
pewarisan.
Pada contoh code yang berada di form diskusi ini terdapat kelas Factory yang bernama
EmployeeFactory yang didalamnya terdapat sebuah method create untuk membuat objek
usernya yaitu String type sebagai parameter inputannya atau sebagai acuan objeknya.
P a g e 3 | 11
Sehingga jika ingin membuat sebuah objek tidak perlu memakai fungsi NEW pad bagian
main, karena hanya perlu memanggil method create yang berada di dalam kelas Factory dan
menyesuaikan String type dengan objek apa yang ingin dibuat.
Tutorial 12.2: Singleton Pattern
1. Singleton Pattern merupakan pattern yang digunakan untuk menjamin bahwa objek dari
sebuah yang diciptakan hanya satu saja.
Gambar 3. Struktur Singleton Pattern
2. Tutorial 12.2 akan mengimplementasikan Singleton Pattern, di mana kelas Asuransi akan
dibuat menjadi singleton, dalam arti instance kelas ini hanya dibatasi satu saja.
3. Buatlah project dengan nama SingletonPattern
4. Gunakan hasil tutorial 12.1, dengan menggunakan semua kelas yang ada, kecuali kelas
FactoryPatternTest.
5. Lakukan modifikasi terhadap kelas Asuransi, dengan kode program berikut ini. Kode ini
menunjukkan objek kelas Asuransi hanya dapat diciptakan satu saja. (Catatan: kode
program berwarna merah menunjukkan implementasi singleton)
import [Link];
public class Asuransi {
///////////////////////////////////////////////////////
// atribut dan fungsi kelas Asuransi dalam implementasi
// pattern singleton
private static Asuransi asuransi = null;
public static Asuransi getInstance() {
if(asuransi == null) {
asuransi = new Asuransi();
[Link]("Instansi kelas Asuransi dibuat");
}
else {
[Link]("Instansi kelas Asuransi sudah ada");
}
return asuransi;
}
//////////////////////////////////////////////////////
P a g e 4 | 11
// atribut kelas Asuransi sebagai subject dalam pattern observer
private Vector<Employee> views;
////////////////////////////////////////////////////////////////
// fungsi konstruktor dibuat private sebagai implementasi pattern
// singleton
private Asuransi() {
views = new Vector<Employee>();
}
////////////////////////////////////////////////////////////////
// fungsi-fungsi kelas Asuransi sebagai subject dalam
// pattern observer
public void attach (Employee obs) {
[Link](obs);
}
public void notifyObserver(float val) {
for (int i=0; i < [Link](); i++)
[Link](i).update(val);
}
public void setState(float val) {
notifyObserver(val);
}
6. Buatlah kelas SingletonPatternTest dengan kode berikut ini:
public class SingletonPatternTest {
public static void main(String[] args) throws IOException {
EmployeeFactory ef = new EmployeeFactory();
Asuransi kis = [Link]();
Asuransi kis2 = [Link]();
Employee direktur = [Link]("Manager", "Arief Nugraha", "Direktur", kis);
Employee mankeu = [Link] ("Manager", "Suryana", "Manajer Keuangan", kis);
Employee mansdm = [Link] ("Manager", "Susila","Manajer SDM", kis);
Employee kaakun = [Link] ("Manager", "Septarini","Kabag Akuntansi", kis);
Employee kaaudt = [Link] ("Manager", "Herjuna","Kabag Audit", kis);
Employee kapsdm = [Link] ("Manager", "Dewi Yani", "Kabag SDM", kis);
Employee kaprom = [Link] ("Manager", "Eleonora", "Kabag Promosi", kis);
Employee skeu1 = [Link] ("Staf", "Panduwinata", "Staf Keuangan", kis);
Employee skeu2 = [Link] ("Staf", "Megadewi", "Staf Keuangan", kis);
Employee ssdm1 = [Link] ("Staf", "Trifina", "Staf SDM", kis);
Employee ssdm2 = [Link] ("Staf", "Kanda", "Staf SDM", kis);
Employee ssdm3 = [Link] ("Staf", "Arjuna", "Staf SDM", kis);
[Link](mankeu); [Link](mansdm);
[Link](kaakun); [Link](kaaudt);
P a g e 5 | 11
[Link](skeu1);
[Link](skeu2);
[Link](kapsdm); [Link](kaprom);
[Link](ssdm1); [Link](ssdm2);
[Link](ssdm3);
[Link]();
InputStreamReader values = new InputStreamReader ([Link]);
BufferedReader br = new BufferedReader(values);
do {
[Link]("\nInput kenaikan premi [0..1] : ");
String valueStr = [Link]();
if ([Link]("00"))
break;
[Link]([Link](valueStr));
[Link]();
} while(true);
}
}
7. Eksekusi kode program.
Apa yang bisa Anda simpulkan dengan menggunakan Singleton Pattern ?
Singleton pattern adalah dalam sebuah kelas hanya ada 1 obkek saja dari kelas tersebut yang
diciptakan dan dapat digunakan oleh kelas kelas lain. Ada 3 langkah untuk mengubah kelas menjadi
singleton pattern :
1. Penciptaaan objek kelas kelas singleton melalui method static. Diperlukan method static agar
objek dapat dibuat dengan mengakses kelasnya dan memberikan akses global untuk melakukan
pengecekan terhadap objek yang sudah dibuat.
2. Kontruktor kelas singleton dibuat private agar objek tidak sembarang dicreate dikelas lain
sehingga pembuatan objek dapat dikontrol oleh kelas tersebut.
3. Diperlukan deklarasi variabel bertipe variabel static yang akan jadi tanda dari pembuatan
objek. Jika static asuransi masih kosong maka objek akan dibuat dan method akan mereturnkan
objek yang dibuat, sedangkan jika static asuransi sudah ada maka objek baru tidak akan dibuat.
Pada code program diatas pada kelas asuransi dibuat menjadi singleton pattern dengan cara
konstuktornya diganti visibilitasnya menjadi private. Pendeklarasian variabel static asuransi yang
diinisialisasi dengan null. Terdapat method static getInstance yang akan mengecek apakah variabel
asuransi masih null atau tidak. Jika null maka objek akan dibuat jika tidak makan objek tidak akan
dibuat. Hal tersebut bertujuan agar hanya ada 1 objek saja yang dapat dibuat.
No Kelompok :4
Anggota :
NPM Anggota Nama Anggota
200710692 Theodorus Adiyatma Suhargo
200710705 Hanwyn Tang
200710709 Satria Bagus Yudatama
P a g e 6 | 11
200710712 Yesi Sugandi
200710723 Archangela Ghiriani Dian Indah
*Anggota yang tidak berkontribusi sama sekali dalam diskusi boleh tidak dituliskan.
Cukup 1 orang yang mengumpulkan
Beri nama file :
X_Y_DesignPattern2.docx
X = Kelas
Y = Nomor Kelompok
P a g e 7 | 11
Lampiran Kode Program pada tutorial 11.4 - Composite Observer Pattern
1. Kelas Employee
public abstract class Employee {
public static StringBuffer space = new StringBuffer();
// atribut-atribut kelas Employee sebagai sebuah konsep
protected String role; // jabatan employee
protected String name;
protected float asuransi; // premi asuransi employee
public Employee (String nm, String rl, float asr) {
name = nm; role = rl;
asuransi = asr;
}
public Employee (String nm, String rl, float asr, Asuransi mod) {
name = nm; role = rl;
asuransi = asr;
model = mod;
[Link](this); // Employee sebagai observers mendaftar
// ke Asuransi (sebagai subject)
}
// fungsi-fungsi Employee sebagai abstract component
// dalam pattern composite. Override di kelas turunan
public abstract void addChild(Employee e);
public abstract Employee getChild(int i);
public abstract void traverseEmp();
// fungsi-fungsi getter kelas Employee sebagai sebuah konsep
public String getRole() { return role; }
public String getName() { return name; }
public float getAsuransi() { return asuransi ; }
/////////////////////////////////////////////////////
// atribut kelas Employee sebagai abstract observer
// dalam pattern observer
private Asuransi model;
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
// fungsi-fungsi kelas Employee sebagai abstract observer
// dalam pattern observer
public abstract void update(float val);
/////////////////////////////////////////////////////
}
P a g e 8 | 11
2. Kelas Manager dan kelas Staf
//[Link]
import [Link];
import [Link];
public class Manager extends Employee {
// atribut kelas Manager sebagai composite class dalam
// pattern composite
List<Employee> employees = new ArrayList<Employee>();
public Manager(String nm, String rl){
super(nm, rl, 1000000);
}
public Manager(String nm, String rl, Asuransi mod){
super(nm, rl, 1000000, mod);
}
// fungsi-fungsi kelas Manager sebagai composite class
// dalam pattern composite
public void addChild(Employee e) { // Catat siapa saja yang
[Link](e); // menjadi bawahan manager
}
public Employee getChild(int i) { // Cari tahu bawahan untuk
return [Link](i); // seorang manager
}
public void traverseEmp() { // tampilkan semua employee
[Link]( [Link] + getName() + "(" +
getRole() + " - " + getAsuransi() + ")" );
[Link](" ");
for (Employee e : employees)
{
[Link]();
}
[Link]([Link]() - 3);
}
///////////////////////////////////////////////////////
// fungsi kelas Manager sebagai concrete observer class
// pattern observer
public void update(float val) {
asuransi = asuransi + asuransi * val;
}
///////////////////////////////////////////////////////
}
P a g e 9 | 11
//[Link]
public class Staf extends Employee {
public Staf (String nm, String rl){
super(nm, rl, 750000);
}
public Staf (String nm, String rl, Asuransi mod){
super(nm, rl, 750000, mod);
}
// fungsi-fungsi kelas Staf sebagai leaf class dalam
// pattern composite
public void addChild(Employee employee) {} // do nothing. Kelas Staf
// tidak memiliki bawahan
public Employee getChild(int i) {
return null;
}
public void traverseEmp() {
[Link]( [Link] + getName() + "(" +
getRole() + " - " + getAsuransi() + ")" );
}
///////////////////////////////////////////////////////
// fungsi kelas Staf sebagai concrete observer dalam
// pattern composite
public void update(float val) {
asuransi = asuransi + asuransi * val;
}
}
3. Kelas Asuransi sebagai subject dalam pattern observer
import [Link];
public class Asuransi {
// atribut kelas Asuransi sebagai subject dalam pattern observer
private Vector<Employee> views;
public Asuransi() {
views = new Vector<Employee>();
}
// fungsi-fungsi kelas Asuransi sebagai subject dalam
// pattern observer
public void attach (Employee obs) {
[Link](obs);
}
public void notifyObserver(float val) {
for (int i=0; i < [Link](); i++)
[Link](i).update(val);
P a g e 10 | 11
}
public void setState(float val) {
notifyObserver(val);
}
}
P a g e 11 | 11