X'inhu d-differenza bejn interface u abstract class?

Question

Accepted Answer

It-tnejn jiddefinixxu tipi astratti li ma jistgħux jinstaŋċjaw direttament u huma għall-implementazzjoni/estensjoni — imma jservu għal għanijiet ta' disinn differenti. Id-distinzjonijiet ewlenin huma **erdja multipla**, **stat**, u r-relazzjoni li jimudellaw.

## Interface — kontrattu ("jista'-jagħmel" / kapaċità)

```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 */ }
}
```

Interface tiddefinixxi **kontrattu** ta' kondotta. Klassi tista' timplimenta **multipli** interfaces — dan kif Java noħloq forma ta' erdja multipla. Interfaces (tradizzjonalment) m'għandhomx stat ta' istanza.

## Abstract class — bażi parzjali ("huwa-a" b'kod maqsum)

```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"); }
}
```

Abstract class tista' timmortazza **stat (fields)**, **konstruttori**, u metodi konkreti b'implementazzjoni maqsuma — imma klassi tista' testendi biss **waħda** abstract class (erdja singola).

## Id-differenzi ewlenin

```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
```

## Meta tuża liema

```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)
```

## Għaliex dan importanti

L-għażla bejn interface u abstract class hija deċiżjoni ta' disinn fundamentali ta' Java.

Interfaces jiddefinixxu **kuntratti/kapaċitajiet** u jippermettu lil klassi timplimenta ħafna minnhom (ir-risposta ta' Java għall-erdja multipla) — ideali għal kapaċitajiet traversali.

Abstract classes jipprovdu **bażi maqsuma b'stat u implementazzjoni parzjali** għal subklassi relatati mill-qrib, imma jilimitawk għall-erdja singola.

L-għarfien tal-kompromessi (implementazzjoni multipla vs stat/konstruttori maqsum, kapaċità vs relazzjoni huwa-a) jigwida disinn tajjeb ta' API u ġerarkija tal-klassi.

B'Java 8+ metodi default li jagħtu l-linji fuq ħamrija, li taf meta kull waħda toqgħod — u l-limitazzjonijiet essenzjali (klassi abstract waħda imma interfaces multipli, stat biss fil-abstract classes) — hija essenzjali għad-disinn ta' kodiċi flessibli u strutturati tajjeb.