Object-Oriented Programming (OOP) adalah cara menulis program dengan memodelkan objek seperti di dunia nyata.
Berikut adalah contoh kode yang digunakan dalam modul ini: App.java
Class adalah blueprint atau cetakan untuk membuat object.
Pada kode ini:
abstract class Car {
protected String brand;
protected String type;
protected String color;
private int speed;
}Car adalah class yang mendefinisikan data dan perilaku dasar dari sebuah mobil.
Class lain juga ada, misalnya:
ElectricCarCashPayment
Object adalah hasil nyata dari class.
Contoh pada main():
ElectricCar myCar = new ElectricCar("Honda", "Brio", "Kuning", 0);myCar adalah object dari class ElectricCar.
Artinya object myCar punya data:
brand = "Honda"type = "Brio"color = "Kuning"speed = 0
Lalu object ini bisa menjalankan method seperti:
myCar.getSpeed();
myCar.startEngine();
myCar.payToll(100000);
Atribut adalah sifat-sifat yang dimiliki object.
Pada class Car:
protected String brand;
protected String type;
protected String color;
private int speed;
protected CashPayment cashPayment = new CashPayment();Penjelasan:
brand→ merek mobiltype→ tipe mobilcolor→ warna mobilspeed→ kecepatan mobilcashPayment→ object untuk proses pembayaran tol
Method adalah aksi atau perilaku yang bisa dilakukan object.
Contoh method pada Car:
public int getSpeed() {
return speed;
}
public void setSpeed(int speedNew) {
this.speed = speedNew;
}
public void payToll(int number) {
cashPayment.payToll(number);
}Contoh method pada ElectricCar:
void startEngine() {
System.out.println("Ini electric car");
}Constructor adalah method khusus yang otomatis dipanggil saat object dibuat. Fungsi utamanya adalah untuk menginisialisasi nilai awal dari object.
Ciri-ciri constructor:
- Nama constructor harus sama dengan nama class
- Tidak memiliki return type
- Dipanggil saat object dibuat dengan keyword
new
Contoh sederhana:
Car myCar = new Car();Saat baris di atas dijalankan, constructor Car() akan dipanggil.
Secara garis besar, ada 2 jenis constructor, yaitu:
- Default Constructor
- Parameterized Constructor
Dalam implementasinya, berkembang jadi beberapa jenis, yaitu:
- Overloading Constructor
- Copy Constructor
- Private Constructor
- Constructor pada Inheritance
Default constructor adalah constructor tanpa parameter. Constructor ini cocok digunakan ketika object ingin langsung punya nilai awal default tanpa harus mengisi data dari luar.
Contoh:
class Car {
String brand;
Car() {
brand = "Honda";
}
}Pemakaian di Main:
Car myCar = new Car();
System.out.println(myCar.brand);Output:
HondaParameterized constructor adalah constructor yang memiliki parameter. Constructor ini dipakai ketika nilai object ingin diisi langsung saat object dibuat.
Contoh:
class Car {
String brand;
String type;
String color;
int speed;
public Car(String brand, String type, String color, int speed) {
this.brand = brand;
this.type = type;
this.color = color;
this.speed = speed;
}
}Pemakaian di Main:
Car myCar = new Car("Honda", "Brio", "Merah", 100);
System.out.println(myCar.brand);
System.out.println(myCar.color);Output:
Honda
MerahConstructor overloading adalah satu class memiliki lebih dari satu constructor, tetapi dengan parameter yang berbeda. Dengan overloading, object bisa dibuat dengan beberapa cara sesuai kebutuhan.
Misalnya:
- tanpa parameter
- dengan 1 parameter
- dengan 2 parameter
Contoh:
class Car {
String brand;
String color;
Car() {
brand = "Default Brand";
color = "Hitam";
}
Car(String brand) {
this.brand = brand;
this.color = "Putih";
}
Car(String brand, String color) {
this.brand = brand;
this.color = color;
}
}Pemakaian:
Car car1 = new Car();
Car car2 = new Car("Honda");
Car car3 = new Car("Suzuki", "Biru");Di Java, copy constructor adalah constructor yang menerima object sejenis lalu menyalin nilainya ke object baru. Constructor ini berguna untuk membuat object baru berdasarkan object yang sudah ada.
Contoh:
class Car {
String brand;
String color;
Car(String brand, String color) {
this.brand = brand;
this.color = color;
}
Car(Car other) {
this.brand = other.brand;
this.color = other.color;
}
}Pemakaian:
Car car1 = new Car("Honda", "Kuning");
Car car2 = new Car(car1);
System.out.println(car2.brand);
System.out.println(car2.color);Output:
Honda
KuningPrivate constructor adalah constructor yang dibuat dengan access modifier private.
Contoh:
class Database {
private Database() {
System.out.println("Constructor dipanggil");
}
}Constructor ini tidak bisa dipanggil dari luar class. Biasanya digunakan untuk:
- pattern Singleton
- mencegah object dibuat sembarangan
- class utility
Contoh Singleton sederhana:
class Database {
private static Database instance;
private Database() {}
public static Database getInstance() {
if (instance == null) {
instance = new Database();
}
return instance;
}
}Pemakaian:
Database db = Database.getInstance();Dalam pewarisan, constructor parent bisa dipanggil menggunakan super().
Contoh:
class Car {
String brand;
String type;
String color;
int speed;
public Car(String brand, String type, String color, int speed) {
this.brand = brand;
this.type = type;
this.color = color;
this.speed = speed;
}
}
class ElectricCar extends Car {
public ElectricCar(String brand, String type, String color, int speed) {
super(brand, type, color, speed);
}
}Kata kunci super(...) digunakan untuk memanggil constructor milik parent class, yaitu Car.
Saat kode ini dijalankan:
ElectricCar myCar = new ElectricCar("Honda", "Brio", "Kuning", 0);Maka constructor ElectricCar dipanggil, lalu meneruskan data ke constructor Car.
4 pilar utama Pemrograman Berorientasi Objek (OOP) adalah
- Enkapsulasi
- Pewarisan (Inheritance)
- Polimorfisme, dan
- Abstraksi
Pilar-pilar ini berfungsi untuk meningkatkan modularitas, keamanan, dan reusabilitas kode, membuat perangkat lunak lebih mudah dikelola serta dikembangkan.
Abstraction adalah menyembunyikan detail implementasi dan hanya menampilkan hal penting.
Pada kode ini, abstraction terlihat dari:
abstract class Car {
abstract void startEngine();
}Class Car hanya mengatakan bahwa setiap mobil harus punya method startEngine(),
tetapi cara menyalakan mesin tidak dijelaskan di Car.
Implementasinya diberikan di class turunan:
@Override
void startEngine() {
System.out.println("Ini electric car");
}Jadi:
Carmendefinisikan konsep umum mobilElectricCarmengisi detail implementasinya
Pada kode ini juga ada:
interface TollPayment {
void payToll(int number);
}Interface TollPayment hanya menentukan aturan bahwa class yang mengimplementasikannya harus punya method payToll(int number).
Inheritance adalah pewarisan, yaitu class anak mewarisi atribut dan method dari class induk.
Contoh:
class ElectricCar extends Car {ElectricCar mewarisi isi dari Car, seperti:
brandtypecolorgetSpeed()setSpeed()payToll()
Karena itu object myCar bisa langsung memakai:
myCar.getSpeed();
myCar.payToll(100000);padahal method tersebut didefinisikan di class Car.
Keuntungan inheritance:
- kode lebih rapi
- bisa digunakan ulang
- tidak perlu menulis ulang fitur yang sama
Polymorphism berarti "satu bentuk, banyak perilaku".
Dalam OOP, method yang sama bisa punya implementasi berbeda pada class yang berbeda.
Contoh pada method abstract:
abstract void startEngine();Lalu di ElectricCar di-override menjadi:
@Override
void startEngine() {
System.out.println("Ini electric car");
}Kalau nanti ada class lain, misalnya GasCar, maka method startEngine() bisa diisi berbeda, misalnya:
@Override
void startEngine() {
System.out.println("Mesin bensin dinyalakan");
}Artinya:
- nama method sama →
startEngine() - perilaku bisa berbeda tergantung jenis object
Contoh lain polymorphism juga terlihat pada interface:
interface TollPayment {
void payToll(int number);
}Lalu class:
class CashPayment implements TollPayment {
@Override
public void payToll(int number) {
System.out.println("Pembayaran Cash sejumlah: " + number);
}
}Kalau nanti ada DebitPayment atau EWaletPayment, semua bisa punya method payToll() dengan cara pembayaran berbeda.
Encapsulation adalah membungkus data dan mengontrol akses terhadap data tersebut.
Contoh paling jelas ada pada property speed:
private int speed;Karena speed bersifat private, property ini tidak bisa diakses langsung dari luar class.
Aksesnya harus lewat method:
public int getSpeed() {
return speed;
}
public void setSpeed(int speedNew) {
this.speed = speedNew;
}Jadi daripada langsung menulis:
myCar.speed = 100; // tidak bisa, karena privatekita harus menggunakan:
myCar.setSpeed(100);
System.out.println(myCar.getSpeed());Keuntungan encapsulation:
- data lebih aman
- akses bisa dikontrol
- mencegah perubahan sembarangan dari luar class
