رابط‌ها (Interfaces) در جاوا

در جاوا، رابط‌ها (Interfaces) یکی از روش‌های انتزاع (Abstraction) هستند. رابط‌ها شبیه کلاس‌های انتزاعی (Abstract Classes) هستند اما تفاوت اصلی آن‌ها این است که همه متدهای موجود در یک رابط، بدون بدنه (بدون پیاده‌سازی) هستند.

۱. تعریف یک رابط

رابط‌ها در جاوا گروهی از متدهای مرتبط هستند که هیچ‌کدام از آن‌ها بدنه‌ای ندارند. به عبارت دیگر، فقط امضای متدها در آن مشخص می‌شود و پیاده‌سازی آن‌ها بر عهده کلاس‌هایی است که این رابط را “پیاده‌سازی (Implement)” می‌کنند.

مثال: تعریف یک رابط در جاوا

// تعریف یک رابط (Interface)
interface Animal {
  public void animalSound(); // متدی بدون بدنه
  public void run();         // متدی بدون بدنه
}

در این مثال، یک رابط به نام Animal تعریف شده که دو متد animalSound() و run() دارد اما هیچ‌کدام بدنه‌ای ندارند.

۲. پیاده‌سازی یک رابط در کلاس‌ها

برای استفاده از متدهای یک رابط، باید یک کلاس، آن رابط را “پیاده‌سازی (Implement)” کند. این کار با استفاده از کلمه‌کلیدی implements انجام می‌شود. وقتی یک کلاس یک رابط را پیاده‌سازی می‌کند، باید تمام متدهای آن رابط را تعریف کند.

مثال: پیاده‌سازی رابط Animal در کلاس Pig

// تعریف رابط
interface Animal {
  public void animalSound(); // بدون بدنه
  public void sleep();       // بدون بدنه
}

// کلاس Pig که رابط Animal را پیاده‌سازی می‌کند
class Pig implements Animal {
  public void animalSound() {
    System.out.println("The pig says: wee wee");
  }

  public void sleep() {
    System.out.println("Zzz");
  }
}

// کلاس اصلی برای اجرای برنامه
class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig();  // ایجاد یک شیء از کلاس Pig
    myPig.animalSound();
    myPig.sleep();
  }
}

📌 خروجی برنامه:

The pig says: wee wee
Zzz

نکات مهم:
✅ نمی‌توان از یک رابط، مستقیماً شیء ایجاد کرد. (یعنی Animal myAnimal = new Animal(); مجاز نیست.)
✅ هر کلاسی که یک رابط را پیاده‌سازی کند، باید تمام متدهای آن رابط را پیاده‌سازی کند.
✅ متدهای رابط به‌صورت پیش‌فرض public و abstract هستند، بنابراین نیاز نیست آن‌ها را به‌طور صریح public abstract تعریف کنیم.
✅ متغیرهای رابط به‌طور پیش‌فرض public، static و final هستند.
✅ رابط‌ها سازنده (Constructor) ندارند، زیرا نمی‌توان از آن‌ها شیء ساخت.

۳. چرا و چه زمانی باید از رابط‌ها استفاده کنیم؟

✔ افزایش امنیت: برخی جزئیات را پنهان می‌کنیم و فقط اطلاعات مهم را نمایش می‌دهیم.
✔ حل مشکل وراثت چندگانه: در جاوا، یک کلاس فقط می‌تواند از یک کلاس دیگر ارث‌بری (extends) کند، اما می‌تواند چندین رابط (implements) را پیاده‌سازی کند.

۴. پیاده‌سازی چندین رابط در یک کلاس

در جاوا، یک کلاس می‌تواند چندین رابط را همزمان پیاده‌سازی کند. برای این کار، نام رابط‌ها را با کاما (,) از هم جدا می‌کنیم.

مثال: پیاده‌سازی دو رابط در یک کلاس

// تعریف دو رابط
interface FirstInterface {
  public void myMethod(); // متد بدون بدنه
}

interface SecondInterface {
  public void myOtherMethod(); // متد بدون بدنه
}

// کلاس DemoClass که هر دو رابط را پیاده‌سازی می‌کند
class DemoClass implements FirstInterface, SecondInterface {
  public void myMethod() {
    System.out.println("Some text..");
  }

  public void myOtherMethod() {
    System.out.println("Some other text...");
  }
}

// کلاس اصلی
class Main {
  public static void main(String[] args) {
    DemoClass myObj = new DemoClass();
    myObj.myMethod();
    myObj.myOtherMethod();
  }
}

📌 خروجی برنامه:

Some text..
Some other text...

مزیت این روش:
✅ امکان ترکیب ویژگی‌های چندین رابط در یک کلاس، بدون نیاز به وراثت چندگانه.

تمرین‌ها برای درک بهتر

✅ تمرین ۱: یک رابط Vehicle تعریف کن که دو متد startEngine() و stopEngine() داشته باشد. سپس یک کلاس Car بساز که این رابط را پیاده‌سازی کند و پیام‌های مناسب را در متدها چاپ کند.

✅ تمرین ۲: یک رابط Playable تعریف کن که متدی به نام play() داشته باشد. سپس دو کلاس Guitar و Piano بساز که این رابط را پیاده‌سازی کنند و پیامی مناسب در متد play() نمایش دهند.

✅ تمرین ۳: چه تفاوتی بین رابط (Interface) و کلاس انتزاعی (Abstract Class) وجود دارد؟ پاسخ خود را با مثال توضیح دهید.

🔹 خلاصه کلی

رابط‌ها (Interfaces) در جاوا، گروهی از متدهای بدون بدنه هستند.
یک کلاس برای استفاده از یک رابط، باید از کلمه‌کلیدی implements استفاده کند و تمام متدهای آن را پیاده‌سازی کند.
رابط‌ها نمی‌توانند شیء بسازند و نمی‌توانند متغیر معمولی یا سازنده (Constructor) داشته باشند.
یک کلاس می‌تواند چندین رابط را همزمان پیاده‌سازی کند که این ویژگی در جاوا به جای وراثت چندگانه استفاده می‌شود.