อินเทอร์เฟซ

"สวัสดี Amigo! วันนี้คุณจะต้องทำการค้นพบบางอย่างหัวข้อสำหรับวันนี้ - ดรัมโรล ได้โปรด - คืออินเทอร์เฟซ "

"ใช่ วันนี้วิเศษมาก ฉันกลับบ้านไปอาบน้ำ"

" อินเทอร์เฟซคือลูกของ Abstraction และ Polymorphism อินเทอร์เฟซเป็นเหมือนคลาสนามธรรมที่เมธอดทั้งหมดเป็นแบบนามธรรม มันถูกประกาศในลักษณะเดียวกับคลาส แต่ใช้คีย์เวิร์ด นี่คือตัวอย่างบางส่วน: interface"

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

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

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

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"น่าสนใจ แต่ทำไมเราถึงต้องการอินเทอร์เฟซ? จะใช้เมื่อใด"

"อินเทอร์เฟซมีข้อดีสองประการที่เหนือกว่าคลาส:"

1) การแยก "คำจำกัดความของวิธีการ" ออกจากการใช้งานวิธีการ

ก่อนหน้านี้ฉันบอกคุณว่าถ้าคุณต้องการอนุญาตให้คลาสอื่นเรียกเมธอดของคลาสของคุณ คุณต้องทำเครื่องหมายเป็นpublic . หากคุณต้องการให้เรียกใช้เมธอดบางอย่างจากคลาสของคุณเองเท่านั้น จะต้องทำเครื่องหมายprivateไว้ กล่าวอีกนัยหนึ่ง เรากำลังแบ่งวิธีการของชั้นเรียนออกเป็นสองประเภท: «สำหรับทุกคน» และ «เฉพาะสำหรับฉัน»

เราสามารถใช้อินเทอร์เฟซเพื่อเสริมการแบ่งแยกนี้ให้มากยิ่งขึ้น เราจะสร้าง "คลาสพิเศษสำหรับทุกคน" ซึ่งจะสืบทอด "คลาสสำหรับฉัน" คลาสที่สอง ซึ่งจะมีลักษณะดังนี้:

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

เราแบ่งคลาสของเราออกเป็นสองส่วน: อินเทอร์เฟซและคลาสที่ใช้อินเทอร์เฟซ

“แล้วข้อดีล่ะ?”

"อินเทอร์เฟซเดียวกันสามารถนำไปใช้โดย (สืบทอด) คลาสที่แตกต่างกัน และแต่ละคลาสสามารถมีลักษณะการทำงานของตนเองได้ เช่นเดียวกับArrayListและLinkedList เป็นการใช้งานอินเทอร์เฟซ List สองแบบที่แตกต่างกัน "

ดังนั้นเราจึงซ่อนไม่เพียงแค่การใช้งานที่แตกต่างกันเท่านั้น แต่ยังรวมถึงคลาสที่มีการนำไปใช้งานด้วย (เราสามารถใช้อินเทอร์เฟซได้ทุกที่ในโค้ด) สิ่งนี้ช่วยให้เราสามารถแทนที่ออบเจกต์บางอย่างด้วยออบเจ็กต์อื่นได้อย่างยืดหยุ่นมากในขณะที่โปรแกรมกำลังทำงาน โดยเปลี่ยนพฤติกรรมของออบเจ็กต์โดยไม่ต้องมีความรู้เรื่องคลาสใด ๆ ที่ใช้มัน

เมื่อใช้ร่วมกับความหลากหลาย นี่เป็นเทคนิคที่ทรงพลังมาก ในขณะนี้ ยังห่างไกลจากความชัดเจนว่าเหตุใดเราจึงต้องทำเช่นนี้ ก่อนอื่นคุณต้องพบกับโปรแกรมที่ประกอบด้วยคลาสหลายสิบหรือหลายร้อยคลาสเพื่อชื่นชมว่าอินเทอร์เฟซสามารถทำให้ชีวิตของคุณง่ายขึ้นได้อย่างไร

2) การสืบทอดหลายรายการ

ใน Java แต่ละคลาสสามารถมีคลาสพาเรนต์ได้เพียงคลาสเดียวเท่านั้น ในภาษาโปรแกรมอื่นๆ คลาสมักจะมีพาเรนต์หลายคลาส สิ่งนี้สะดวกมาก แต่ก็สร้างปัญหามากมายเช่นกัน

Java มีการประนีประนอม:   คุณไม่สามารถสืบทอดหลายคลาสได้ แต่คุณสามารถใช้หลายอินเตอร์เฟสได้ อินเทอร์เฟซสามารถมีหลายอินเทอร์เฟซหลัก  คลาสสามารถใช้หลายอินเทอร์เฟซและสืบทอดคลาสพาเรนต์เดียวเท่านั้น