[Java] Object-Oriented Programming (OOP)

Object-Oriented Programming (OOP) adalah konsep pemrograman aplikasi yang berfokus pada entitas (Entity) dari suatu aplikasi. Pendekatan ini digunakan untuk memudahkan dalam mendesain dan mengembangkan Entity dan hubungan antar Entity pada aplikasi. OOP juga memungkinkan programmer untuk membuat blueprint dari suatu Entity.

Contohnya adalah,

//Kucing.java
public class Kucing {
  private String warna;
  private String jenis;

  public Kucing(String warna, String jenis) { 
    this.warna = warna;
    this.jenis = jenis;
  }

  private String meong() {
    System.out.println("...MEONG~")
  }
}


//Main.java
public class Main {
  public static main(String[] args) {
    Kucing kucing_anggora = new Kucing("putih", "ANGGORA");
    Kucing kucing_persia = new Kucing("hitam", "PERSIA");
  }
}

Pada kode diatas, Entity Kucing (Kucing.java) menjadi blueprint dari objek yang akan dibuat (kucing_anggora & kucing_persia).

Pendekatan OOP memiliki 4 prinsip / pilar dasar, yakni:

INHERITANCE

… adalah prinsip menurunkan attributes dan methods.

Tujuan → mencegah perulangan penulisan kode.

public class Kucing {
  private String warna;
  private String jenis;
  
  public void makan(){
    System.out.println("Sedang makan...");
  }
  public void lari(){
    System.out.println("LARI...");
  }
}

public class Kucing {
  private String warna;
  private String jenis;

  public void makan(){
    System.out.println("Sedang makan...");
  }
  public void terbang(){
    System.out.println("TERBANG...");
  }
}

Pada contoh diatas, Entity Kucing dan Burung sama-sama memiliki attribute warna dan jenis & method makan().

Kode diatas mungkin terlihat tidak masalah, namun seiring waktu, ketika aplikasi semakin besar, kita akan memerlukan banyak Class lain dengan attribute dan method yang sama. Hal ini akan membuat size & budget aplikasi kita membengkak.

Untuk mengurangi perulangan kode, kita dapat mengimplementasikan Inheritance dengan membuat class yang lebih umum / SuperClass & memberikan keyword “extends” pada class detailnya / SubClass.

public class Hewan { //SuperClass
  private String warna;
  private String jenis;

  public void makan(){
    System.out.println("Sedang makan...");
  }
}

public class Kucing extends Hewan { //SubClass
  public void lari(){
    System.out.println("LARI...");
  }
}

public class Burung extends Hewan {//SubClass
  public void terbang() {
    System.out.println("TERBANG...");
  }
}

Sekarang Entity Kucing & Burung tetap memiliki attribute warna dan jenis & method makan().

POLYMORPHISM

…adalah prinsip sebuah objek dapat memiliki perilaku serupa yang berbeda sesuai dengan kondisi.

Tujuan → mengurangi ketergantungan / coupling.

Pada contoh sebelumnya, Kucing & Burung sama-sama memiliki method makan(). Jika kita ingin output berbeda ketika kedua Entity memanggil method makan(), kita dapat menulis ulang method tersebut di masing-masing Class dan merubah detailnya. Konsep ini disebut Overriding.

Tidak lupa memberi anotasi @Override sebagai indikasi bahwa method tersebut menimpa method SuperClass-nya.

public class Kucing extends Hewan { // SubClass
  public void lari() {
    System.out.println("LARI...");
  }

  @Override
  public void makan() {
    System.out.println("KUCING Sedang makan...");
  }
}

Terdapat 1 konsep lagi, yaitu Overloading, konsep dimana nama beberapa method sama tapi memiliki parameter berbeda

public class Kucing extends Hewan { // SubClass
  public void lari() {
    System.out.println("LARI...");
  }

  @Override
  public void makan() {
    System.out.println("KUCING Sedang makan...");
  }
  public void makan(String food) {
    System.out.println("KUCING Sedang makan..." + food);
  }
}

Dengan Overloading, kita dapat memiliki method serupa namun tak sama dan tidak mengganggu SuperClass-nya.

ABSTRACTION

…adalah prinsip modeling suatu Entity hanya sebagai interface tanpa detail implementasinya.

Tujuan → mengurangi kompleksitas desain. Fokus pada perilakunya saja.

Abstraction dapat dicapai dengan membuat interface / abstract class.

Contoh penggunaan dengan interface adalah Bidang2D.java

public interface Bidang2D {
  int hitungLuas();
  int hitungKeliling();
}

public class Persegi implements Bidang2D {
  private double sisi;

  @Override
  public double hitungLuas() {

    return sisi * sisi;
  }

  @Override
  public double hitungKeliling() {

    return 4 * sisi;
  }
}

public class Lingkaran implements Bidang2D {
  private double jariJari;

  @Override
  public double hitungLuas() {

    return 3.14 * jariJari* jariJari;
  }

  @Override
  public double hitungKeliling() {

    return 2 * 3.14 * jariJari;
  }
}

Detail implementasi dari method Bidang2D tersebut tergantung pada Class yang menggunakan. Maka dari itu detailnya terletak pada Class Persegi & Lingkaran.

ENCAPSULATION

…adalah prinsip melindungi akses langsung dari objek lain.

Tujuan → menyembunyikan detail implementasi suatu Entity.

Encapsulation dapat dicapai dengan menggunakan access modifier (private, protected, dan public).

• private digunakan ketika attribute / method hanya dipakai di Class tersebut saja.
• protected digunakan ketika attribute / method hanya digunakan oleh SubClass inheritance & Class yang berada dalam 1 package.
• public digunakan untuk memberikan akses yang bebas pada attribute / method.

public class Manusia {
  private String nama;

  public void setNama(String nama) {
    this.nama = nama;
  }

  public String getNama() {
    return nama;
  }

  protected void printNama() {
    System.out.println("Nama saya: " + nama);
  }
}

public class Mahasiswa extends Manusia {
  private int nim;

  public void setNim(int nim) {
    this.nim = nim;
  }

  public String getNim() {
    return nim;
  }
}

Dalam contoh tersebut, attribute nama & nim tidak dapat diakses langsung dari manapun, harus melalui setter & getter dengan access modifier public. kemudian Mahasiswa juga dapat memanggil printNama().

Kesimpulannya adalah, OOP adalah konsep penting dalam pemrograman Java yang memungkinkan pembuatan program yang lebih terstruktur, mudah dipahami, dan mudah dikelola. Dengan menggunakan konsep OOP seperti inheritance, polymorphism, abstraction, dan encapsulation, kita dapat membuat program Java yang lebih efektif dan mudah di-maintain.

*Thank you for taking the time to read my writing. Your support and attention are greatly appreciated.

Next topic: [Java] Primitive VS Non-Primitive Data Types