Antarmuka

"Halo, Amigo! Hari ini Anda akan membuat beberapa penemuan. Topik hari ini—drum roll, tolong—adalah antarmuka. "

"Yap. Suatu hari yang begitu indah sehingga aku akan pulang untuk mandi."

" Antarmuka adalah anak dari Abstraksi dan Polimorfisme. Antarmuka sangat mirip dengan kelas abstrak di mana semua metodenya abstrak. Dideklarasikan dengan cara yang sama seperti kelas, tetapi dengan kata kunci . Berikut beberapa contohnya: interface"

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}

class abstract ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"Menarik. Tapi mengapa kita membutuhkan antarmuka? Kapan mereka digunakan?"

"Antarmuka memiliki dua keunggulan kuat dibandingkan kelas:"

1) Pemisahan "definisi metode" dari implementasi metode.

Saya sebelumnya memberi tahu Anda bahwa jika Anda ingin mengizinkan kelas lain memanggil metode kelas Anda, maka Anda perlu menandainya sebagaipublic . Jika Anda ingin metode tertentu dipanggil hanya dari kelas Anda sendiri, maka metode tersebut harus ditandai private. Dengan kata lain, kami membagi metode kelas menjadi dua kategori: «untuk semua orang» dan «hanya untuk saya».

Kita dapat menggunakan antarmuka untuk lebih memperkuat pemisahan ini. Kami akan membuat "kelas untuk semua orang" khusus yang akan mewarisi "kelas hanya untuk saya" kedua. Itu akan terlihat seperti ini:

class Student
{
 private String name;

 public Student(String name)
 {
  this.name = name;
 }

 public String getName()
 {
  return this.name;
 }

 private void setName(String name)
 {
  this.name = name;
 }

interface Student
{
 public String getName();
}

class StudentImpl implements Student
{
 private String name;
 public StudentImpl(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 private void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}

public static void main(String[] args)
{
 Student student =
               new StudentImpl("Ali");
 System.out.println(student.getName());
}

Kami membagi kelas kami menjadi dua bagian: antarmuka dan kelas yang mengimplementasikan antarmuka.

"Jadi apa keuntungannya?"

"Antarmuka yang sama dapat diimplementasikan oleh (mewarisi) kelas yang berbeda. Dan setiap kelas dapat memiliki perilakunya sendiri. Sama seperti ArrayList dan LinkedList adalah dua implementasi berbeda dari antarmuka Daftar. "

Jadi, kita tidak hanya menyembunyikan implementasi yang berbeda, tetapi juga kelas yang berisi implementasi (kita bisa menggunakan antarmuka di mana saja dalam kode). Ini memungkinkan kita dengan sangat fleksibel mengganti beberapa objek dengan objek lain saat program sedang berjalan, mengubah perilaku objek tanpa sepengetahuan kelas mana pun yang menggunakannya.

Dikombinasikan dengan polimorfisme, ini adalah teknik yang sangat kuat. Saat ini, masih jauh dari jelas mengapa kita perlu melakukan ini. Anda harus terlebih dahulu menemukan program yang terdiri dari lusinan atau ratusan kelas untuk menghargai bagaimana antarmuka dapat sangat menyederhanakan hidup Anda.

2) Warisan berganda.

Di Java, setiap kelas hanya dapat memiliki satu kelas induk. Dalam bahasa pemrograman lain, kelas seringkali dapat memiliki beberapa kelas induk. Ini sangat nyaman, tetapi juga menimbulkan banyak masalah.

Java menawarkan kompromi:   Anda tidak dapat mewarisi banyak kelas, tetapi Anda dapat mengimplementasikan banyak antarmuka. Antarmuka dapat memiliki beberapa antarmuka induk.  Kelas dapat mengimplementasikan banyak antarmuka dan hanya mewarisi satu kelas induk.