Cad é an difríochtaí idir comhéadan agus aicme dhíreach?

Question

Accepted Answer

Sainmhíníonn an bheirt sin cineálacha teibí nach féidir iad a thobhach go díreach agus a bhfuil sé i gceist a chur i bhfeidhm/a shíneadh — ach freastalaíonn siad ar dhifreoir dhearaidh. Is iad na príomhdhifríochtaí ná **oidhreachais iolracha**, **stát**, agus an gaol a bhíonn siad i gcóir a mhúnlú.

## Comhéadan — conradh ("is féidir-déanamh" / cumas)

```java
public interface Drawable {
    void draw();                          // abstract method (implicitly public abstract)

default void render() {                // default method — has a body (Java 8+)
        System.out.println("rendering");
    }
    int MAX = 100;                         // implicitly public static final (constant only)
}

class Circle implements Drawable {
    public void draw() { /* must implement */ }
}
```

Sainmhíníonn comhéadan **conradh** de bhitheanna. Is féidir le haicme **iolracha** chomhéadain a chur i bhfeidhm — is é seo an chaoi a bhíonn Java ag fáil cruth ar oidhreachais iolrach. Níl stát tosaitheachta ag comhéadain (go traidisiúnta).

## Aicme dhíreach — bonn páirteach ("is-a" le cód comhroinnte)

```java
public abstract class Animal {
    protected String name;                 // ✅ can have instance FIELDS (state)

public Animal(String name) {           // ✅ can have a constructor
        this.name = name;
    }
    public abstract void makeSound();      // abstract — subclasses must implement
    public void sleep() {                   // ✅ concrete method with shared logic
        System.out.println(name + " sleeps");
    }
}

class Dog extends Animal {                 // can extend only ONE class
    public Dog(String n) { super(n); }
    public void makeSound() { System.out.println("Woof"); }
}
```

Is féidir le haicme dhíreach **stát (réimsí)**, **tógálaithe**, agus modhanna nithiúla a bhfuil feidhmiú comhroinnte acu a choinneáil — ach ní féidir le haicme ach **aicme dhíreach amháin** a shíneadh (oidhreachais singil).

## Príomhdifríochtaí

```text
                    Interface              Abstract class
Multiple inheritance ✓ (implement many)    ✗ (extend only one)
Instance fields/state ✗ (constants only)   ✓ (fields)
Constructor           ✗                    ✓
Method bodies         default/static only  ✓ (concrete methods)
Models                capability ("can-do") "is-a" with shared base
```

## Cathain atá siad le húsáid

```text
Interface → define a capability multiple unrelated classes can have
            (Comparable, Runnable, Serializable); when you need multiple inheritance
Abstract class → share common state + code among closely related subclasses
            (a base class with fields and partial implementation)
```

## Cén fáth a bhfuil sé tábhachtach

Is cinneadh dearaidh bhunúsach Java a bheith ag roghnú idir comhéadan agus aicme dhíreach.

Sainmhíníonn comhéadain **contrachtaí/cumais** agus cumasaíonn siad do aicme go leor acu a chur i bhfeidhm (freagra Java ar oidhreachais iolrach) — is fearr é do ghréine-ghearrtha.

Soláthraíonn aicmí díreach **bonn comhroinnte le stát agus feidhmiú páirteach** do fho-aicmí gar-ghaolmhara, ach cuireann siad teorainn ar oidhreachais singil.

Tuigint ar na malairtí (cur i bhfeidhm-iolrach versus stát-comhroinnte/tógálaithe, cumas versus gaol is-a) a threorú dearaidh maith API agus ord-aicme.

Le Java 8+ a raibh gealadh i gceist ag modhanna réamhshocraithe ar an líne, a fhios a bheith agat cathain a bhíonn gach ceann oiriúnach — agus na srianta bhunúsacha (aicme dhíreach amháin ach go leor comhéadain, stát i sainiúchán díreach amháin) — tá gá ann do dhearadh leaganúil, cód-struchtúrtha.