Mikä on ero rajapinnan (interface) ja abstraktin luokan välillä?

Question

Accepted Answer

Molemmat määrittelevät abstrakteja tyyppejä, joita ei voi suoraan instantioida ja jotka on tarkoitettu implementoitaviksi/laajennettaviksi — mutta ne palvelevat eri suunnittelutarkoituksia. Keskeiset erot ovat **moniperintö**, **tila** ja niiden mallintama suhde.

## Rajapinta — sopimus ("voi tehdä" / kyky)

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

Rajapinta määrittelee käyttäytymisen **sopimuksen**. Luokka voi implementoida **useita** rajapintoja — näin Java saavuttaa moniperintöä. Rajapinnoilla (perinteisesti) ei ole instanssitilaa.

## Abstrakti luokka — osittainen kantatyyppi ("on" jaetulla koodilla)

```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 luokka voi sisältää **tilaa (kenttiä)**, **konstruktoreja** ja konkreetteja metodeita jaetulla toteutuksella — mutta luokka voi laajentaa vain **yhtä** abstraktia luokkaa (yksinkertainen perintö).

## Keskeiset erot

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

## Milloin käyttää kumpaa

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

## Miksi sillä on merkitystä

Valinta rajapinnan ja abstraktin luokan välillä on perusavain Java-suunnittelupäätös.

Rajapinnat määrittelevät **sopimukset/kyvyt** ja mahdollistavat luokalla implementoida monia niistä (Javan vastaus moniperintöön) — ihanteellinen poikittaisille kyvyille.

Abstraktit luokat tarjoavat **jaetun kantatyypin tilalla ja osittaisella toteutuksella** läheisesti liittyville aliluokille, mutta rajoittavat sinut yksinkertaiseen perintöön.

Kompromissien ymmärtäminen (usean implementoinnin vs. jaetun tilan/konstruktoreiden, kyvyn vs. "on" -suhteen) ohjaa hyvää API- ja luokkahierarkiasuunnittelua.

Java 8+ oletusmetodeilla rajan hämärtyessä, tietäminen milloin kukin sopii — ja päärajoitukset (yksi abstrakti luokka mutta monet rajapinnat, tila vain abstrakteissa luokissa) — on välttämätöntä joustavaa, hyvin rakennetun koodin suunnittelulle.