> For the complete documentation index, see [llms.txt](https://mominur.gitbook.io/mominur-notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mominur.gitbook.io/mominur-notes/system-design/oop/interface.md).

# Interface

ধরো, **ইলেকট্রিক সকেট** (power socket)।

* সারা পৃথিবীতে বিভিন্ন যন্ত্র (ফ্যান, টিভি, ফ্রিজ, ল্যাপটপ চার্জার) এই সকেটে লাগানো যায়।
* সকেট একটা **interface** → এটা শুধু বলছে তুমি যদি এই design (shape + voltage) follow করো, তবে আমার সাথে connect হতে পারবে।
* ফ্রিজ ভেতরে compressor চালাবে, টিভি ভেতরে display চালাবে → কিন্তু সকেটের বাইরে থেকে user এর কাছে সবকিছু একরকম দেখায়।

Interface হলো এরকম একটা socket — **একটা common নিয়ম যেটা সবাই follow করলে একসাথে কাজ করতে পারবে।**

***

### What is a Contract?

Contract = **Promise / চুক্তি**

* Interface আসলে একটা **contract** বানায়।
* চুক্তি: যে ক্লাস আমাকে implement করবে, তাকে অবশ্যই আমার methods define করতে হবে।
* যদি না করে, compiler/runtime error দিবে।

যেমন চাকরির চুক্তি (job contract) থাকে →

* প্রতিদিন অফিস আসতে হবে
* রিপোর্ট দিতে হবে
* কাজ শেষ করতে হবে\
  তুমি কীভাবে কাজ করবে সেটা চুক্তি বলে না, শুধু বলে **কোন কাজগুলো অবশ্যই করতে হবে**।

***

### What is in an Interface?

Interface-এর ভেতরে সাধারণত থাকে:

1. **Method signatures (function নাম + parameter)**
   * যেমন: `login(username, password)`
   * কিন্তু ভিতরে কোড থাকে না (logic নাই)।
2. **Constants (কিছু ভাষায়)**
   * Interface এর ভেতরে fixed values রাখা যায় (যেমন error codes)।
3. **(কিছু ভাষায়) Default methods**
   * Java 8+ এ default implementation রাখা যায়।

Constructor, instance variable, state → এগুলো interface এ থাকে না, কারণ এটা শুধু Contract, data রাখার জায়গা না।

***

### Why do we need Interface?

1. **Standardization**
   * আলাদা আলাদা ক্লাসকে একইভাবে ব্যবহার করা যায়।
   * যেমন: সব database driver একই method নাম মেনে চলে (`connect`, `query`, `close`)।
2. **Polymorphism**
   * তুমি একটাই interface দিয়ে অনেক ক্লাস ব্যবহার করতে পারো।
   * Example: `Shape` interface → Circle, Square, Triangle আলাদা ভাবে কাজ করলেও সবাইকে `draw()` method দিয়ে handle করা যায়।
3. **Loose Coupling**
   * Interface থাকলে তুমি এক implementation বদলে আরেকটা বসাতে পারো।
   * যেমন MySQL driver থেকে PostgreSQL driver এ সুইচ করা যায়, তোমার main code না বদলিয়েই।
4. **Team Collaboration**
   * বড় প্রজেক্টে টিম লিডার interface define করে দেন (contract)।
   * ডেভেলপাররা আলাদা আলাদা implementation লিখে, কিন্তু সবাই একই নিয়ম মানে।

## Interface in detail

### 1. **Basic Interface**

Interface শুধু method এর **contract** define করে, implementation দেয় না।

{% code lineNumbers="true" %}

```php
<?php
interface Animal {
    public function sound();
}

class Dog implements Animal {
    public function sound() {
        echo "Woof! Woof!\n";
    }
}

class Cat implements Animal {
    public function sound() {
        echo "Meow! Meow!\n";
    }
}

$dog = new Dog();
$cat = new Cat();

$dog->sound(); // Woof! Woof!
$cat->sound(); // Meow! Meow!
?>
```

{% endcode %}

এখানে `Animal` হলো contract। যে ক্লাস এটা implement করবে, তাকে অবশ্যই `sound()` লিখতে হবে।

***

### 2. **Multiple Interface Implementation**

একসাথে অনেকগুলো interface implement করা যায়।

{% code lineNumbers="true" %}

```php
<?php
interface CanRun {
    public function run();
}

interface CanSwim {
    public function swim();
}

class Human implements CanRun, CanSwim {
    public function run() {
        echo "Human is running\n";
    }

    public function swim() {
        echo "Human is swimming\n";
    }
}

$man = new Human();
$man->run();   // Human is running
$man->swim();  // Human is swimming
?>
```

{% endcode %}

এতে একটা ক্লাসকে **multiple behavior** দেওয়া যায়।

***

### 3. **Interface Extending Another Interface**

Interface আরেকটা interface কে **extend** করতে পারে।

{% code lineNumbers="true" %}

```php
<?php
interface Vehicle {
    public function start();
}

interface FourWheeler extends Vehicle {
    public function fourWheelDrive();
}

class Car implements FourWheeler {
    public function start() {
        echo "Car started\n";
    }

    public function fourWheelDrive() {
        echo "Car is in 4x4 mode\n";
    }
}

$car = new Car();
$car->start();
$car->fourWheelDrive();
?>
```

{% endcode %}

`FourWheeler` → `Vehicle` কে extend করছে, তাই class কে দুইটার method-ই implement করতে হবে।

***

### 4. **Constants in Interface**

Interface এ constant define করা যায়।

{% code lineNumbers="true" %}

```php
<?php
interface Status {
    const ACTIVE = 1;
    const INACTIVE = 0;
}

class User {
    public $status = Status::ACTIVE;
}

$user = new User();
echo $user->status; // 1
?>
```

{% endcode %}

Interface constant কখনো override করা যায় না। এগুলো **global standard values** হিসাবে কাজ করে।

***

### 5. **Dependency Injection with Interface**

Interface ব্যবহার করলে কোড **loosely coupled** হয়।

{% code lineNumbers="true" %}

```php
<?php
interface PaymentGateway {
    public function pay($amount);
}

class Bkash implements PaymentGateway {
    public function pay($amount) {
        echo "Paying $amount using bKash\n";
    }
}

class Nagad implements PaymentGateway {
    public function pay($amount) {
        echo "Paying $amount using Nagad\n";
    }
}

class Checkout {
    private $gateway;

    public function __construct(PaymentGateway $gateway) {
        $this->gateway = $gateway;
    }

    public function process($amount) {
        $this->gateway->pay($amount);
    }
}

// Use bKash
$checkout = new Checkout(new Bkash());
$checkout->process(1000);

// Switch to Nagad
$checkout = new Checkout(new Nagad());
$checkout->process(500);
?>
```

{% endcode %}

কোডে পরিবর্তন না করেই আমরা gateway switch করতে পারি, কারণ সবগুলো একই interface follow করছে।

***

### 6. **Marker Interface**

Marker interface এ **কোনো method থাকে না**, শুধু একটা tag হিসাবে কাজ করে।

{% code lineNumbers="true" %}

```php
<?php
interface SerializableEntity {} // marker interface

class User implements SerializableEntity {
    public $name = "Alice";
}

function save($obj) {
    if ($obj instanceof SerializableEntity) {
        echo "Saving object to database\n";
    } else {
        echo "Object not serializable\n";
    }
}

$user = new User();
save($user); // Saving object to database
?>
```

{% endcode %}

এখানে শুধু `SerializableEntity` interface ব্যবহার করা হয়েছে object কে আলাদা করে চিহ্নিত করতে।

## Conflict in Multiple Interface

একটা ক্লাস একসাথে একাধিক interface implement করতে পারে। কিন্তু যখন **method নাম এক হয়**, তখন conflict এর chances তৈরি হয়।

***

### Case 1: **Same Method Signature**

দুইটা interface এ method নাম **এবং parameter** একরকম হলে → **একটাই implementation** লিখলেই চলে।

{% code lineNumbers="true" %}

```php
<?php
interface A {
    public function show();
}

interface B {
    public function show();
}

class C implements A, B {
    public function show() {
        echo "Single implementation works!\n";
    }
}

$obj = new C();
$obj->show();  // ✅ Works fine
?>
```

{% endcode %}

এখানে conflict নেই, কারণ দুটো method signature পুরোপুরি এক।

***

### Case 2: **Same Method Name but Different Parameters**

যদি দুই interface এ একই নামের method থাকে কিন্তু parameter আলাদা হয় → PHP **Fatal Error** দিবে।

{% code lineNumbers="true" %}

```php
<?php
interface A {
    public function calculate($a);
}

interface B {
    public function calculate($a, $b);
}

class C implements A, B {
    // ❌ PHP Fatal error: Declaration must be compatible
    public function calculate($a, $b = 0) {
        return $a + $b;
    }
}
?>
```

{% endcode %}

কারণ PHP strict ভাবে method signature check করে। একসাথে দুইটা maintain করা possible না।

***

### Case 3: **Return Type Conflict (PHP 7.0+ onwards)**

যদি দুই interface এ একই method থাকে, কিন্তু **return type আলাদা** → PHP Error দিবে।

{% code lineNumbers="true" %}

```php
<?php
interface A {
    public function getData(): int;
}

interface B {
    public function getData(): string;
}

class C implements A, B {
    // ❌ Fatal error: Declaration must be compatible
    public function getData(): int {
        return 42;
    }
}
?>
```

{% endcode %}

এখানে compiler confused → `getData()` কি int return করবে, নাকি string?

***

### Case 4: **Covariant Return Types (PHP 7.4+)**

PHP 7.4+ এ কিছুটা flexibility এসেছে। যদি parent/interface method একটা type দেয়, আর child method **subtype** return করে → সেটা valid।

```php
<?php
interface A {
    public function getName(): ?string;
}

interface B {
    public function getName(): string;
}

class C implements A, B {
    public function getName(): string {
        return "Hello";
    }
}

$obj = new C();
echo $obj->getName(); // Hello
?>
```

এখানে conflict হয়নি কারণ `string` হল `?string` এর subset।

***

### Case 5: **Interface + Trait Conflict**

Traits এও method থাকতে পারে। যদি interface এর সাথে একই নামের method থাকে, তবে class এ implementation দিতে হবে।

```php
<?php
interface Logger {
    public function log($msg);
}

trait FileLogger {
    public function log($msg) {
        echo "File log: $msg\n";
    }
}

class App implements Logger {
    use FileLogger;
}

$app = new App();
$app->log("Started");  // File log: Started
?>
```

এখানে conflict resolve হয়েছে automatically, কারণ trait এর method implementation হিসেবে use হয়েছে।

***

Interface হলো programming-এর flexibility-এর মেরুদণ্ড। এটি what আর how-এর মধ্যে একটি clear separation তৈরি করে। এর ফলে system হয় reusable, maintainable এবং long-term sustainable। Interface ছাড়া software হবে এমন এক city-এর মতো যেখানে কোনো traffic rules নেই—পুরোটাই chaotic আর unmanageable