Antarmuka

Modul 2: Inti Java
Level 4 , Pelajaran 0
Tersedia

"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"

Kode Deskripsi dan fakta
interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}
1) Alih-alih kata class, kami menulis interface.

2) Ini hanya berisi metode abstrak (tidak perlu menambahkan kata abstrak).

3) Faktanya, semua metode pada antarmuka bersifat publik.

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}
Antarmuka hanya dapat mewarisi antarmuka lain.

Anda dapat memiliki banyak antarmuka induk.

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;
}

}
Kelas dapat mewarisi beberapa antarmuka (dan hanya satu kelas). Untuk menunjukkan warisan ini, kami menggunakan kata kunci  implements.

Kelas ChessItem dinyatakan abstrak: itu menerapkan semua metode yang diwariskan kecuali menggambar.

Dengan kata lain, ChessItem berisi satu metode abstrak:  draw().

"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:

Sebelum
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;
 }
Setelah
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;
 }
}
Sebelum
public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}
Setelah
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.

Komentar
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION