Kokia yra skirtumas tarp sąsajos ir abstrakčios klasės?

Question

Accepted Answer

Abu apibrėžia abstrakčius tipus, kurie negali būti sukurti tiesiai ir turėtų būti implementuoti/išplėsti — tačiau jie tarnauja skirtingais projekavimo tikslais. Pagrindiniai skirtumai yra **dauginė paveldėjimas**, **būsena** ir modeluota santykis.

## Sąsaja — kontraktas ("gali-daryti" / galimybė)

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

Sąsaja apibrėžia **kontraktą** elgesio. Klasė gali implementuoti **kelis** sąsajas — tai yra Java būdas pasiekti dauginį paveldėjimą. Sąsajos (paprastai) neturi instancijos būsenos.

## Abstrakti klasė — dalinė bazė ("yra-a" su bendrinu kodu)

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

Abstrakti klasė gali turėti **būseną (laukus)**, **konstruktorius** ir konkrečius metodus su bendra realizacija — bet klasė gali pratęsti tik **vieną** abstraktą klasę (viengubai paveldėjimas).

## Pagrindiniai skirtumai

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

## Kada naudoti kurią

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

## Kodėl tai svarbu

Pasirinkimas tarp sąsajos ir abstrakčios klasės yra pagrindinė Java projekavimo sprendimas.

Sąsajos apibrėžia **kontraktus/galimybes** ir leidžia klasei implementuoti daug jų (Java atsakas į dauginį paveldėjimą) — idealu skersiniams gebėjimams.

Abstrakčios klasės suteikia **bendrą bazę su būsena ir daline realizacija** glaudžiai susijusioms poklasėms, tačiau riboja jus į viengubą paveldėjimą.

Supratimas apie kompromisus (dauginė implementacija vs bendra būsena/konstruktoriai, galimybė vs yra-a santykis) vadovauja geriam API ir klasės hierarchijos projektavimui.

Su Java 8+ numatytas metodais, kurie sudominimo ribą, žinoti, kada kiekviena tinka — ir pagrindiniai apribojimai (viena abstrakti klasė, bet daugybė sąsajų, būsena tik abstrakčiose klasėse) — yra būtina lanksčiam, gerai strukturuotam kodui projektuoti.