Antara muka

"Hello, Amigo! Hari ini anda akan membuat beberapa penemuan. Topik untuk hari ini—drum roll, please—adalah antara muka. "

"Ya. Hari yang sangat indah sehingga saya pulang ke rumah untuk mandi."

" Antara muka ialah anak kepada Abstraksi dan Polimorfisme. Antara muka adalah seperti kelas abstrak di mana semua kaedah adalah abstrak. Ia diisytiharkan dengan cara yang sama seperti kelas, tetapi dengan kata kunci . Berikut adalah beberapa contoh: 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. Tetapi mengapa kita memerlukan antara muka? Bilakah ia digunakan?"

"Antara muka mempunyai dua kelebihan yang kukuh berbanding kelas:"

1) Pengasingan "definisi kaedah" daripada pelaksanaan kaedah.

Saya sebelum ini memberitahu anda bahawa jika anda ingin membenarkan kelas lain memanggil kaedah kelas anda, maka anda perlu menandakannya sebagaipublic . Jika anda mahu kaedah tertentu dipanggil hanya dari kelas anda sendiri, maka kaedah tersebut mesti ditanda private. Dalam erti kata lain, kami membahagikan kaedah kelas kepada dua kategori: «untuk semua orang» dan «hanya untuk saya».

Kita boleh menggunakan antara muka untuk mengukuhkan lagi pemisahan ini. Kami akan membuat "kelas untuk semua orang" khas yang akan mewarisi "kelas hanya untuk saya" kedua. Itu akan kelihatan 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 membahagikan kelas kami kepada dua bahagian: antara muka dan kelas yang melaksanakan antara muka.

"Jadi apa kelebihannya?"

"Antara muka yang sama boleh dilaksanakan oleh (mewarisi) kelas yang berbeza. Dan setiap kelas boleh mempunyai tingkah lakunya sendiri. Sama seperti ArrayList dan LinkedList ialah dua pelaksanaan berbeza bagi antara muka Senarai. "

Oleh itu, kami menyembunyikan bukan sahaja pelaksanaan yang berbeza, tetapi juga kelas yang mengandungi pelaksanaan (kami hanya boleh menggunakan antara muka di mana-mana dalam kod). Ini membolehkan kami dengan sangat fleksibel menggantikan beberapa objek dengan objek lain semasa program sedang berjalan, mengubah tingkah laku objek tanpa pengetahuan mana-mana kelas yang menggunakannya.

Dalam kombinasi dengan polimorfisme, ini adalah teknik yang sangat berkuasa. Pada masa ini, tidak jelas mengapa kita perlu melakukan ini. Anda mesti menemui program yang terdiri daripada berpuluh-puluh atau beratus-ratus kelas terlebih dahulu untuk menghargai cara antara muka boleh memudahkan hidup anda dengan sangat baik.

2) Pusaka berbilang.

Di Java, setiap kelas hanya boleh mempunyai satu kelas induk. Dalam bahasa pengaturcaraan lain, kelas selalunya boleh mempunyai beberapa kelas induk. Ini sangat mudah, tetapi ia juga menimbulkan banyak masalah.

Java menawarkan kompromi:   anda tidak boleh mewarisi berbilang kelas, tetapi anda boleh melaksanakan berbilang antara muka. Antara muka boleh mempunyai beberapa antara muka induk.  Kelas boleh melaksanakan berbilang antara muka dan mewarisi hanya satu kelas induk.