LAPORAN AKHIR

PRAKTIKUM IMPLEMENTASI PERANGKAT LUNAK

MODUL 3
“Design Principle (S.O.L.I.D)”

Disusun Oleh

ERRAS LINDIARDA MAHENTAR [3411191102]

DSE-C

PROGRAM STUDI / JURUSAN TEKNIK INFORMATIKA

FAKULTAS SAINS DAN INFORMATIKA
UNIVERSITAS JENDERAL ACHMAD YANI
TAHUN 2023
 DAFTAR ISI

DAFTAR ISI ........................................................................................................... 2

BAB I ....................................................................................................................... 3
PENDAHULUAN ................................................................................................... 3
I.1 PENDAHULUAN ..................................................................................... 3
A. Interface Segregation Principle (ISP) ................................................... 3
B. Dependency Inversion Principle (DIP) ................................................. 3
BAB II ..................................................................................................................... 4
HASIL PRAKTIKUM DAN TUGAS .................................................................... 4
II.1 Hasil Praktikum ........................................................................................ 4
A. Latihan ISP............................................................................................ 4
B. Latihan DPI ........................................................................................... 7
C. Tugas...................................................................................................... 9
BAB III .................................................................................................................. 11
KESIMPULAN ..................................................................................................... 11
 BAB I

PENDAHULUAN
I.1 PENDAHULUAN
A. Interface Segregation Principle (ISP)
Interface Segregation Principle bertujuan untuk mengurangi jumlah
ketergantungan sebuah class terhadap interface class yang tidak dibutuhkan.
Jumlah ketergantungan dari fungsi pada sebuah interface class yang dapat
diakses oleh class tersebut harus dioptimalkan atau dikurangi. Terkadang
ketika sebuah class dibuat dengan jumlah fungsi dan properti yang banyak,
class lain yang bergantung pada class tersebut hanya membutuhkan satu atau
dua fungsi dari class tersebut. Ketergantungan antar class akan semakin
bertambah seiring bertambahnya jumlah fungsi dan properti dari class yang
dibutuhkan.
Menggunakan prinsip Interface Segregation, class-class yang saling
bergantung dapat berkomunikasi dengan menggunakan interface yang lebih
kecil, mengurangi ketergantungan pada fungsi-fungsi yang tidak digunakan
dan mengurangi coupling. Dengan menggunakan interface yang lebih kecil
akan memudahkan dalam implementasi, meningkatkan fleksibilitas dan juga
kemungkinan untuk digunakan kembali (reuse).

B. Dependency Inversion Principle (DIP)

Prinsip Dependency Inversion hampir sama dengan konsep layering
dalam aplikasi, di mana low-level modules bertanggung jawab dengan fungsi
yang sangat detail dan high-level modules menggunakan low-level classes
untuk mencapai tugas yang lebih besar. Hal ini bisa dicapai dengan
bergantung pada sebuah abstraksi, ketika ada ketergantungan antar kelas
seperti interface, daripada referensi langsung ke kelas lainnya.
Supaya dapat lebih mudah memahami high-level modules dan low-
level modules, kelas-kelas dapat dikategorikan menjadi sebuah hirarki. High-
level modules adalah kelas-kelas yang berurusan dengan kumpulan-kumpulan
fungsionalitas. Pada hirarki tertinggi terdapat kelas-kelas yang
mengimplementasikan aturan bisnis sesuai dengan desain yang telah
ditentukan. Low-level modules bertanggung jawab pada operasi yang lebih
detail. Pada level terendah memungkinkan modul ini untuk bertanggung
jawab dalam menulis informasi ke database atau menyampaikan pesan ke
sistem operasi.
 BAB II

HASIL PRAKTIKUM DAN TUGAS

II.1 Hasil Praktikum
A. Latihan ISP
Diketahui jenis kendaraan sepeda motor dan mobil. Keduanya
termasuk dalam jenis kendaraan, tetapi keduanya memiliki fitur atau
kelengkapan yang berbeda. Kasus tersebut diimplementasikan dengan model
berikut:
Pada sepeda motor dimodelkan sebagai class Motorcycle, sedangkan
mobil dimodelkan sebagai class Car. Keduanya merupakan bagian dari
interface VehicleInterface sebagai berikut:

Interface VehicleInterface
interface VehicleInterface {
void drive();
void stop();
void refuel();
 void openDoors();
}
Class Motorcycle
class Motorcycle implements VehicleInterface {
// Can be implemented
@Override
public void drive() {
}
@Override
public void stop() {
}
@Override
public void refuel() {
}
// Can not be implemented
@Override
public void openDoors() {
}
}

Class Car
class Car implements VehicleInterface {
// Can be implemented
@Override
public void drive() {
}
@Override
public void stop() {
}
@Override
public void refuel() {
}
// Can not be implemented
@Override
public void openDoors() {
}
}

Berikut ini adalah design code dengan menerapkan Interface

Segregation Principle :
Interface VehicleInterface
interface VehicleInterface {
void drive();
void stop();
void refuel();
}
Interface DoorInterface
interface DoorInterface {
void openDoors();
}
Selanjutnya, pada class MotorCycle yang hanya
mengimplementasikan interface Vehicle menjadi seperti ini:
class Motorcycle : VehicleInterface {
override fun drive() {}
override fun stop() {}
override fun refuel() {}
}
Maka, interface DoorInterface dapat diterapkan pada class lain,
misalnya pada class Car, di mana kenyataannya mobil memiliki pintu.
Sehingga kita dapat menerapkannya menjadi seperti ini:
Class Car
class Car implements VehicleInterface, DoorInterface {
 @Override
public void drive() {
}
@Override
public void stop() {
}
@Override
public void refuel() {
}
@Override
public void openDoors() {
}

B. Latihan DPI
Berikut adalah kasus implementasi kasus mobil dan mesin yang
dimodelkan menjadi Class Car dan Engine. Class Car memiliki engine, dalam
hal ini dimodelkan sebagai class Engine. Namun, jika terdapat jenis engine
yang berbeda, sebagai contoh menjadi mesin diesel hal tersebut
mengakibatkan perlunya membuat class baru DieselEngine.

Class Car
class Car {
private final Engine engine;
public Car(Engine engine) {
this.engine = engine;
}
void start() {
engine.start();
}
}
Class Engine
class Engine {
void start() {
}
}
Class DieselEngine
class DieselEngine {
void start() {
}
}
Design code tersebut jika diterapkan prinsip Dependency Inversion,
maka akan menjadi seperti berikut:

Class PetrolEngine
class PetrolEngine implements EngineInterface {
@Override
public void start() {
}
}
Class HybridEngine
class HybridEngine implements EngineInterface {
@Override
 public void start() {
}
}
Class DieselEngine
class DieselEngine implements EngineInterface {
@Override
public void start() {
}
}
Sehingga, kita dengan mudah dapat membuat jenis Car yang berbeda,
cukup dari satu model class Car saja. Berikut penerapan untuk pemanggilan
kodenya:
class Main {
public static void main(String[] args) {
Car fuelCar = new Car(new PetrolEngine());
Car dieselCar = new Car(new DieselEngine());
Car hybridCar = new Car(new HybridEngine());
//Booom boom
fuelCar.start();
dieselCar.start();
hybridCar.start();
}
}

C. Tugas
Untuk memahami principle dari SOLID terutama bagian ISP dan DPI.
Selesaikan perintah berikut.
1. Pada Latihan 4.2.1 ISP, Jelaskan alasan kenapa bentuk/design codenya
harus diubah?
Jawab: Karena Prinsip ini sendiri bertujuan untuk mengurangi jumlah
ketergantungan sebuah class terhadap interface class yang tidak
dibutuhkan.

2. Ubah Class Motorcycle menggunakan fungsi java.

class MotorCycle implements Vehicle {

@Override
public void drive() {
System.out.println("Driving the motorcycle...");
}

@Override
 public void start() {
System.out.println("Starting the motorcycle...");
}

@Override
public void stop() {
System.out.println("Stopping the motorcycle...");
}
}
3. Pada Latihan 4.2.2 DPI, Jelaskan alasan kenapa bentuk/design
codenya harus diubah?
Jawab: karena akan membutuhkan pemfaktoran ulang class car namun,
bisa menyelesaikan ini dengan memperkenalkan lapisan abstrak. Alih
alih car yang bergantung langsung pada Engine, sehingga dapat
menghubungkan segala jenis engine yang mengimplementasikan
interface engine ke class car
 BAB III

KESIMPULAN

S.O.L.I.D merupakan suatu prinsip yang digunakan agar kita tetap dapat
menjaga kualitas dari kodingan. Dibutuhkan sedikit waktu untuk terbiasa dengan
prinsip-prinsip ini, namun mempelajari dan melaksanakannya, sangat membantu kita
dalam memelihara source code perangkat lunak.