Abstraction di Java – Object Oriented (3) :

Abstraksi adalah kualitas yang berurusan dengan ide daripada peristiwa. Misalnya, jika Anda mempertimbangkan kasus email, detail kompleks seperti apa yang terjadi segera setelah Anda mengirim email, protokol yang digunakan server email Anda disembunyikan dari pengguna.

Oleh karena itu, untuk mengirim email Anda hanya perlu mengetikkan isinya, menyebutkan alamat penerima, dan klik kirim.

Abstraksi data adalah proses menyembunyikan detail tertentu dan hanya menampilkan informasi penting kepada pengguna.
Abstraksi dapat dicapai dengan kelas atau antarmuka abstrak (yang akan Anda pelajari lebih lanjut di bab berikutnya).

Demikian pula dalam pemrograman berorientasi objek, abstraksi adalah proses menyembunyikan detail implementasi dari pengguna, hanya fungsionalitas yang akan diberikan kepada pengguna.

Dengan kata lain, pengguna akan memiliki informasi tentang apa yang dilakukan objek alih-alih bagaimana melakukannya. Kata kunci abstract adalah sebuah non-access modifier, digunakan untuk kelas dan metode:

1. Abstract class yaitu adalah kelas terbatas yang tidak dapat digunakan untuk membuat objek (untuk mengaksesnya, itu harus diwarisi dari kelas lain).
2. Abstract Method yaitu hanya dapat digunakan di kelas abstrak, dan tidak memiliki isi. Tubuh disediakan oleh subclass (diwarisi).

Di Java, abstraksi dicapai dengan menggunakan kelas dan antarmuka Abstrak.

Abstract Class pada Java

Kelas yang berisi kata kunci abstrak dalam deklarasinya dikenal sebagai kelas abstrak

1. Kelas abstrak mungkin atau mungkin tidak berisi metode abstrak, yaitu metode tanpa tubuh (public void get (); ).
2. Jika sebuah kelas memiliki setidaknya satu metode abstrak, maka kelas tersebut harus dideklarasikan sebagai abstrak.
3. Jika kelas dideklarasikan abstrak, itu tidak bisa dibuat instance-nya.
4. Untuk menggunakan kelas abstrak, Anda harus mewarisinya dari kelas lain, menyediakan implementasi ke metode abstrak di dalamnya.
5. Jika Anda mewarisi kelas abstrak, Anda harus menyediakan implementasi ke semua metode abstrak di dalamnya.

Contoh Abstract Class

Untuk membuat kelas abstrak, cukup gunakan kata kunci abstrak sebelum kata kunci kelas, di deklarasi kelas bisa dibuat dengan beberapa contoh dibawah

abstract class Animal {
  public abstract void animalSound();
  public void sleep() {
    System.out.println("Zzz");
  }
}

Dari contoh di atas, tidak mungkin membuat objek kelas Animal yaitu pada kode

Animal myObj = new Animal(); // akan menjadi error

Contoh lain nya bisa dilihat pada contoh berikut ini

// Abstract class
abstract class Animal {
  // Abstract method (does not have a body)
  public abstract void animalSound();
  // Regular method
  public void sleep() {
    System.out.println("Zzz");
  }
}

// Subclass (inherit from Animal)
class Pig extends Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    Pig myPig = new Pig(); // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

Atau dapat juga membuat seperti contoh berikut

/* File name : Employee.java */public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   
   public double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }
 
   public String getAddress() {
      return address;
   }
   
   public void setAddress(String newAddress) {
      address = newAddress;
   }
 
   public int getNumber() {
      return number;
   }
}

Anda dapat mengamati bahwa kecuali metode abstrak, kelas Karyawan sama dengan kelas normal di Java. Kelas sekarang abstrak, tetapi masih memiliki tiga bidang, tujuh metode, dan satu konstruktor. Sekarang Anda dapat mencoba membuat instance kelas Karyawan dengan cara berikut

/* File name : AbstractDemo.java */public class AbstractDemo {

   public static void main(String [] args) {
      /* Following is not allowed and would raise error */      Employee e = new Employee("George W.", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Ketika dikompilasi akan menghasilkan hasil seperti ini

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

Inherit (Pewarisan) Abstract Class

Kita dapat mewarisi properti kelas Karyawan seperti kelas dibawah dengan cara berikut

/* File name : Salary.java */public class Salary extends Employee {
   private double salary;   // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }
 
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Di sini, Anda tidak dapat membuat instance kelas Karyawan, tetapi Anda dapat membuat instance Kelas Gaji, dan menggunakan contoh ini Anda dapat mengakses semua tiga bidang dan tujuh metode kelas Karyawan seperti yang ditunjukkan di bawah ini

/* File name : AbstractDemo.java */public class AbstractDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

maka akan menghasilkan seperti hasil dibawah

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Mailing check to John Adams with salary 2400.0

Metode Abstract

Jika Anda ingin kelas berisi metode tertentu tetapi Anda ingin implementasi sebenarnya dari metode itu ditentukan oleh kelas anak, Anda bisa mendeklarasikan metode di kelas induk sebagai abstrak dengan cara berikut ini.

1. Keywords abstract digunakan untuk mendeklarasikan metode sebagai abstrak.
2. Anda harus menempatkan kata kunci abstrak sebelum nama metode dalam deklarasi metode.
3. Metode abstrak berisi tanda tangan metode, tetapi tidak ada isi metode.
4. Alih-alih tanda kurung kurawal, metode abstrak akan memiliki titik dua (;) di bagian akhir.

Berikut adalah contoh metode abstrak

public abstract class Employee {
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   // Remainder of class definition
}

Mendeklarasikan metode sebagai abstrak memiliki dua konsekuensi yaitu

1. Kelas yang memuatnya harus dideklarasikan sebagai abstrak.
2. Setiap kelas yang mewarisi kelas saat ini harus mengganti metode abstrak atau mendeklarasikan dirinya sebagai abstrak.

Catatan : kelas turunan harus mengimplementasikan metode abstrak; jika tidak, Anda akan memiliki hierarki kelas abstrak yang tidak dapat dibuat instance-nya. Misalkan kelas Gaji mewarisi kelas Karyawan, maka kelas tersebut harus menerapkan metode computePay () seperti yang ditunjukkan di bawah ini

/* File name : Salary.java */public class Salary extends Employee {
   private double salary;   // Annual salary
  
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Interfaces pada Java

Antarmuka atau sering kita sebut Interfaces di Java adalah sebuah cetak biru pada kelas. Ini memiliki konstanta statis dan metode abstrak. Antarmuka di Java adalah mekanisme untuk mencapai abstraksi. Hanya ada metode abstrak di antarmuka Java, bukan isi metode. Ini digunakan untuk mencapai abstraksi dan multiple inheritance di Java. Dengan kata lain, Anda dapat mengatakan bahwa antarmuka dapat memiliki metode dan variabel abstrak. Itu tidak bisa memiliki tubuh metode.

Antarmuka Java juga mewakili hubungan IS-A. Itu tidak bisa dipakai seperti kelas abstrak. Sejak Java 8, kita dapat memiliki metode default dan statis dalam sebuah antarmuka. Sejak Java 9, kita dapat memiliki metode privat dalam sebuah antarmuka.

Kegunaan Interfaces pada Java ?

Ada tiga alasan utama untuk menggunakan antarmuka. Mereka diberikan di bawah ini

1. Ini digunakan untuk mencapai abstraksi.
2. Dengan antarmuka, kami dapat mendukung fungsionalitas multiple inheritance.
3. Ini dapat digunakan untuk mencapai kopling longgar.

Bagaimana Mendeklarasi Interface

Antarmuka dideklarasikan dengan menggunakan kata kunci antarmuka. Ini memberikan abstraksi total; berarti semua metode dalam antarmuka dideklarasikan dengan badan kosong, dan semua bidang bersifat publik, statis, dan final secara default. Kelas yang mengimplementasikan antarmuka harus mengimplementasikan semua metode yang dideklarasikan di antarmuka. Contoh sintaks yang dapat digunakan adalah seperti ini

interface <interface_name>{  
      
    // declare constant fields  
    // declare methods that abstract   
    // by default.  
}  

Kemudian contoh programnya adalah

interface printable{  
void print();  
}  
class A6 implements printable{  
public void print(){System.out.println("Hello");}  
  
public static void main(String args[]){  
A6 obj = new A6();  
obj.print();  
 }  
}  // ini akan menampilkan output : Hello

Contoh penggunaan Interface lainnya dengan membuat file berikut

//Interface declaration: by first user  
interface Drawable{  
void draw();  
}  
//Implementation: by second user  
class Rectangle implements Drawable{  
public void draw(){System.out.println("drawing rectangle");}  
}  
class Circle implements Drawable{  
public void draw(){System.out.println("drawing circle");}  
}  
//Using interface: by third user  
class TestInterface1{  
public static void main(String args[]){  
Drawable d=new Circle();//In real scenario, object is provided by method e.g. getDrawable()
d.draw();  
}
}  // maka output yang keluar adalah drawing circle

Multiple Inheritance oleh Interface pada Java

Jika sebuah kelas mengimplementasikan banyak antarmuka, atau sebuah antarmuka memperluas beberapa antarmuka, itu dikenal sebagai pewarisan ganda. Contoh multiple inheritance pada Java adalah

interface Printable{  
void print();  
}  
interface Showable{  
void show();  
}  
class A7 implements Printable,Showable{  
public void print(){System.out.println("Hello");}  
public void show(){System.out.println("Welcome");}  
  
public static void main(String args[]){  
A7 obj = new A7();  
obj.print();  
obj.show();  
 }  
}  // Output yang dihasilkan adalah : 
   // Hello
   // Welcome

Interface Inheritance

Kelas A mengimplementasikan antarmuka, tetapi satu antarmuka memperluas antarmuka lain. Contoh Interface Inheritance adalah

interface Printable{  
void print();  
}  
interface Showable extends Printable{  
void show();  
}  
class TestInterface4 implements Showable{  
public void print(){System.out.println("Hello");}  
public void show(){System.out.println("Welcome");}  
  
public static void main(String args[]){  
TestInterface4 obj = new TestInterface4();  
obj.print();  
obj.show();  
 }  
}  // Output yang dihasilkan adalah : 
   // Hello
   // Welcome

Nested Interface pada Java

Sebuah antarmuka dapat memiliki antarmuka lain yang dikenal sebagai nested interface. Sebagai contohnya adalah

interface printable{  
 void print();  
 interface MessagePrintable{  
   void msg();  
 }  
} 

Perbedaan Abstract Class dan Interface

Kelas abstrak dan antarmuka keduanya digunakan untuk mencapai abstraksi di mana kita dapat mendeklarasikan metode abstrak. Kelas abstrak dan antarmuka keduanya tidak dapat dipakai. Tetapi ada banyak perbedaan antara kelas abstrak dan interface yang diberikan di bawah ini