Contoh implementasi OOP (Class, Object, Inheritance, Polymorphism, Encaptulation) dalam Java ~ Problem Solver

Oriented Object Programming (OOP) adalah suatu paradigma pemrograman yang menekankan pada pembuatan program berdasarkan objek-objek yang saling terkait satu sama lain. OOP merupakan salah satu cara yang efektif dalam mengelola proyek pemrograman yang kompleks karena dapat membantu dalam mengelompokkan objek-objek sesuai dengan kebutuhan dan mempermudah proses pemeliharaan kode program.

Java merupakan bahasa pemrograman yang menggunakan paradigma OOP. Berikut ini adalah beberapa contoh implementasi OOP dalam Java:

#Pembuatan class dan object

Class adalah sebuah template atau blue print yang menentukan atribut dan behavior dari sebuah object. Atribut adalah data yang disimpan di dalam object, sedangkan behavior adalah aksi yang dapat dilakukan oleh object tersebut.

Contoh pembuatan class dan object adalah sebagai berikut:


class Mobil {
// Atribut
String merk;
String warna;
int tahunProduksi;

// Behavior
void jalankan() {
System.out.println("Mobil sedang berjalan");
}

void berhenti() {
System.out.println("Mobil berhenti");
}
}

class Main {
public static void main(String[] args) {
Mobil mobil1 = new Mobil();
mobil1.merk = "Toyota";
mobil1.warna = "Merah";
mobil1.tahunProduksi = 2019;
mobil1.jalankan();
// Output: Mobil sedang berjalan

Mobil mobil2 = new Mobil();
mobil2.merk = "Honda";
mobil2.warna = "Biru";
mobil2.tahunProduksi = 2020;
mobil2.berhenti();
// Output: Mobil berhenti
}
}

Di sini, terdapat class Mobil yang memiliki atribut merk, warna, dan tahunProduksi serta behavior jalankan dan berhenti. Kemudian dibuat object mobil1 dan mobil2 yang masing-masing memiliki atribut yang berbeda.

#Inheritance

Inheritance adalah konsep dimana sebuah class dapat "menurunkan" atribut dan behavior-nya kepada class lain yang disebut dengan child class. Dengan inheritance, proses pembuatan class baru menjadi lebih mudah karena tidak perlu menuliskan kembali atribut dan behavior yang sudah ada pada class parent-nya.

Contoh penggunaan inheritance adalah sebagai berikut:


class Kendaraan {
// Atribut
String merk;
String warna;
int tahunProduksi;

// Behavior
void jalankan() {
System.out.println("Kendaraan sedang berjalan");
}

void berhenti() {
System.out.println("Kendaraan berhenti");
}
}

class Mobil extends Kendaraan {
// Atribut tambahan
int jumlahRoda;

// Behavior tambahan
void ngebut() {
System.out.println("Mobil sedang ngebut");
}
}

class Main {
public static void main(String[] args) {
Kendaraan kendaraan1 = new Kendaraan();
kendaraan1.merk = "Suzuki";
kendaraan1.warna = "Putih";
kendaraan1.tahunProduksi = 2015;
kendaraan1.jalankan();
// Output: Kendaraan sedang berjalan

Mobil mobil1 = new Mobil();
mobil1.merk = "Toyota";
mobil1.warna = "Merah";
mobil1.tahunProduksi = 2019;
mobil1.jumlahRoda = 4;
mobil1.jalankan();
mobil1.ngebut();
// Output: Kendaraan sedang berjalan
// Output: Mobil sedang ngebut
}
}

Di sini, class Mobil "mewarisi" atribut dan behavior dari class Kendaraan, yaitu merk, warna, tahunProduksi, jalankan, dan berhenti. Class Mobil juga memiliki atribut tambahan yaitu jumlahRoda dan behavior tambahan yaitu ngebut.

#Polymorphism

Polymorphism : memungkinkan sebuah object memiliki beberapa bentuk atau sifat yang berbeda tergantung pada konteks penggunaannya, dapat dicapai dengan inheritance atau menggunakan interface.

Berikut ini adalah contoh penggunaan polymorphism dengan inheritance:


class Kendaraan {
// Atribut
String merk;

// Behavior
void jalankan() {
System.out.println("Kendaraan sedang berjalan");
}
}

class Mobil extends Kendaraan {
// Atribut tambahan
int jumlahRoda;

// Behavior tambahan
void ngebut() {
System.out.println("Mobil sedang ngebut");
}
}

class Motor extends Kendaraan {
// Atribut tambahan
int jumlahRoda;

// Behavior tambahan
void ngerem() {
System.out.println("Motor melakukan pengereman");
}
}

class Main {
public static void main(String[] args) {
Kendaraan kendaraan1 = new Kendaraan();
kendaraan1.jalankan();
// Output: Kendaraan sedang berjalan

Kendaraan kendaraan2 = new Mobil();
kendaraan2.jalankan();
// Output: Kendaraan sedang berjalan

Kendaraan kendaraan3 = new Motor();
kendaraan3.jalankan();
// Output: Kendaraan sedang berjalan
}
}

Di sini, object kendaraan1, kendaraan2, dan kendaraan3 semuanya merupakan object dari class Kendaraan, namun kendaraan2 dan kendaraan3 sebenarnya merupakan object dari class Mobil dan Motor yang masing-masing "mewarisi" atribut dan behavior dari class Kendaraan. Dengan menggunakan polymorphism, object kendaraan2 yang sebenarnya merupakan object Mobil dapat diakses seolah-olah merupakan object Kendaraan, begitu juga dengan object kendaraan3 yang merupakan object Motor.

#Encapsulation

Encapsulation: menyembunyikan atribut dari class agar tidak dapat diakses secara langsung, sehingga hanya dapat diakses melalui method yang telah disediakan.

Berikut ini adalah contoh penggunaan encapsulation:

 
class Kendaraan {
// Atribut dengan access modifier private
private String merk;
private int tahunProduksi;

// Getter dan setter untuk atribut merk
public String getMerk() {
return merk;
}

public void setMerk(String merk) {
this.merk = merk;
}

// Getter dan setter untuk atribut tahunProduksi
public int getTahunProduksi() {
return tahunProduksi;
}

public void setTahunProduksi(int tahunProduksi) {
this.tahunProduksi = tahunProduksi;
}
}

class Main {
public static void main(String[] args) {
Kendaraan kendaraan1 = new Kendaraan();
kendaraan1.setMerk("Suzuki");
kendaraan1.setTahunProduksi(2015);

System.out.println(kendaraan1.getMerk());
// Output: Suzuki
System.out.println(kendaraan1.getTahunProduksi());
// Output: 2015
}
}

Di sini, atribut merk dan tahunProduksi dari class Kendaraan tidak dapat diakses secara langsung dari luar class, hanya dapat diakses melalui getter dan setter yang telah disediakan. Dengan demikian, proses pengubahan atribut tersebut dapat dikontrol dan diatur sesuai kebutuhan. Selain itu, encapsulation juga memudahkan dalam proses debugging dan maintenance karena hanya perlu mengubah implementasi pada getter dan setter, bukan langsung pada atributnya. Contoh penggunaan encapsulation dengan membuat atribut sebagai constant (final) adalah sebagai berikut:


class Kendaraan {
// Atribut dengan access modifier private
private final String merk;
private final int tahunProduksi;

// Konstruktor dengan parameter merk dan tahunProduksi
public Kendaraan(String merk, int tahunProduksi) {
this.merk = merk;
this.tahunProduksi = tahunProduksi;
}

// Getter untuk atribut merk
public String getMerk() {
return merk;
}

// Getter untuk atribut tahunProduksi
public int getTahunProduksi() {
return tahunProduksi;
}
}

class Main {
public static void main(String[] args) {
Kendaraan kendaraan1 = new Kendaraan("Suzuki", 2015);

System.out.println(kendaraan1.getMerk());
// Output: Suzuki
System.out.println(kendaraan1.getTahunProduksi());
// Output: 2015
}
}

Di sini, atribut merk dan tahunProduksi dari class Kendaraan tidak memiliki setter, sehingga nilainya tidak dapat diubah setelah object dibuat. Nilai atribut tersebut harus ditentukan pada saat object dibuat dengan memanggil konstruktor yang telah disediakan. Dengan menggunakan encapsulation, nilai atribut tersebut dapat dijadikan constant (final) sehingga tidak dapat diubah setelah object dibuat.

#Abstract class dan method

Abstract class dan method: membuat class atau method yang tidak dapat diinstansiasi atau tidak dapat diimplementasikan secara langsung, harus diwarisi atau diimplementasikan oleh class lain terlebih dahulu.

Berikut ini adalah contoh penggunaan abstract class dan method:


abstract class Kendaraan {
// Atribut
String merk;

// Method abstrak
abstract void jalankan();

// Method biasa
void berhenti() {
System.out.println("Kendaraan berhenti");
}
}

class Mobil extends Kendaraan {
// Atribut tambahan
int jumlahRoda;

// Implementasi method abstrak
@Override
void jalankan() {
System.out.println("Mobil sedang berjalan");
}
}

class Motor extends Kendaraan {
// Atribut tambahan
int jumlahRoda;

// Implementasi method abstrak
@Override
void jalankan() {
System.out.println("Motor sedang berjalan");
}
}

class Main {
public static void main(String[] args) {
Kendaraan kendaraan1 = new Mobil();
kendaraan1.jalankan();
// Output: Mobil sedang berjalan

Kendaraan kendaraan2 = new Motor();
kendaraan2.jalankan();
// Output: Motor sedang berjalan

kendaraan1.berhenti();
// Output: Kendaraan berhenti
}
}

Di sini, terdapat abstract class Kendaraan yang memiliki method abstrak jalankan dan method biasa berhenti. Kemudian terdapat class Mobil dan Motor yang masing-masing "mewarisi" atribut dan behavior dari class Kendaraan dan mengimplementasikan method abstrak jalankan. Class Kendaraan tidak dapat diinstansiasi (dibuat objectnya), sehingga harus diwarisi atau diimplementasikan oleh class lain terlebih dahulu. Method abstrak jalankan tidak memiliki implementasi, sehingga harus diimplementasikan oleh class yang mewarisi atau mengimplementasikan Kendaraan.

#Overriding method

Overriding method: menimpa implementasi method dari class parent dengan implementasi baru pada class child.

Berikut ini adalah contoh penggunaan overriding method:


class Kendaraan {
// Atribut
String merk;

// Method
void jalankan() {
System.out.println("Kendaraan sedang berjalan");
}

void berhenti() {
System.out.println("Kendaraan berhenti");
}
}

class Mobil extends Kendaraan {
// Atribut tambahan
int jumlahRoda;

// Method dengan nama yang sama dengan method di class Kendaraan
@Override
void jalankan() {
System.out.println("Mobil sedang berjalan");
}

// Method dengan nama yang sama dengan method di class Kendaraan
@Override
void berhenti() {
System.out.println("Mobil melakukan pengereman");
}
}

class Motor extends Kendaraan {
// Atribut tambahan
int jumlahRoda;

// Method dengan nama yang sama dengan method di class Kendaraan
@Override
void jalankan() {
System.out.println("Motor sedang berjalan");
}
}

class Main {
public static void main(String[] args) {
Kendaraan kendaraan1 = new Kendaraan();
kendaraan1.jalankan();
// Output: Kendaraan sedang berjalan
kendaraan1.berhenti();
// Output: Kendaraan berhenti

Kendaraan kendaraan2 = new Mobil();
kendaraan2.jalankan();
// Output: Mobil sedang berjalan
kendaraan2.berhenti();
// Output: Mobil melakukan pengereman

Kendaraan kendaraan3 = new Motor();
kendaraan3.jalankan();
// Output: Motor sedang berjalan
kendaraan3.berhenti();
// Output: Kendaraan berhenti
}
}

Di sini, terdapat class Kendaraan dengan method jalankan dan berhenti. Kemudian terdapat class Mobil dan Motor yang masing-masing "mewarisi" atribut dan behavior dari class Kendaraan dan menimpa implementasi method jalankan dan berhenti. Method jalankan dan berhenti pada class Kendaraan disebut sebagai method parent, sedangkan method jalankan dan berhenti pada class Mobil disebut sebagai method child. Dengan menggunakan overriding, method child akan menimpa implementasi method parent sehingga saat method child dipanggil, implementasi method child yang akan dijalankan.

#Overloading method

Overloading method: membuat method dengan nama yang sama tapi dengan jumlah atau tipe parameter yang berbeda dalam satu class.

Berikut ini adalah contoh penggunaan overloading method:


class Calculator {
// Method dengan nama yang sama dengan parameter dan tipe data yang berbeda
int add(int a, int b) {
return a + b;
}

int add(int a, int b, int c) {
return a + b + c;
}

double add(double a, double b) {
return a + b;
}
}

class Main {
public static void main(String[] args) {
Calculator calc = new Calculator();

System.out.println(calc.add(1, 2));
// Output: 3
System.out.println(calc.add(1, 2, 3));
// Output: 6
System.out.println(calc.add(1.5, 2.5));
// Output: 4.0
}
}

Di sini, terdapat class Calculator dengan method add yang memiliki nama yang sama namun memiliki parameter dan tipe data yang berbeda. Dengan menggunakan overloading, kita dapat membuat beberapa method dengan nama yang sama namun memiliki parameter dan tipe data yang berbeda. Method yang akan dipanggil akan tergantung dari parameter yang diberikan pada saat memanggil method tersebut. Perhatikan bahwa pada contoh di atas, tidak terdapat method add dengan parameter (int a, double b). Jika terdapat method seperti itu, maka akan terjadi error karena terdapat ambiguitas (tidak jelas) antara method add(int, int) dan method add(double, double).

#Type casting

Type casting: mengubah tipe data dari satu jenis ke jenis lain, baik secara implisit maupun eksplisit Exception handling: menangani kesalahan yang terjadi saat program dijalankan sehingga program tidak terhenti secara tiba-tiba.

Berikut ini adalah contoh penggunaan type casting:


class Main {
public static void main(String[] args) {
// Widening casting (implicit casting)
int a = 100;
long b = a;

// Narrowing casting (explicit casting)
long c = 500;
int d = (int) c;

// Type casting untuk primitive data types
char e = 'A';
int f = (int) e;
System.out.println(f);
// Output: 65

// Type casting untuk object reference types
Object obj = "Hello";
String str = (String) obj;
System.out.println(str);
// Output: Hello
}
}

Di sini, terdapat dua jenis type casting yaitu widening casting dan narrowing casting. Widening casting adalah proses mengubah tipe data yang lebih kecil menjadi tipe data yang lebih besar secara otomatis. Contohnya adalah mengubah tipe data int menjadi tipe data long. Narrowing casting adalah proses mengubah tipe data yang lebih besar menjadi tipe data yang lebih kecil secara eksplisit dengan menggunakan tanda kurung (()). Contohnya adalah mengubah tipe data long menjadi tipe data int.

Type casting juga dapat dilakukan untuk object reference types. Contohnya adalah mengubah tipe data Object menjadi tipe data String. Namun, perlu diperhatikan bahwa type casting yang dilakukan harus sesuai dengan class yang sebenarnya dari object tersebut. Jika tidak, maka akan terjadi error ClassCastException.

Kembali ke halaman utama

Categories: Java