Mi a különbség egy interface és egy absztrakt osztály között?

Question

Accepted Answer

Mindkettő olyan absztrakt típusokat definiál, amelyeket nem lehet közvetlenül instantiálni, és amelyeket meg kell valósítani/kiterjeszteni — azonban eltérő tervezési célokat szolgálnak. A lényeges különbségek a **többszörös öröklődés**, az **állapot** és az általuk modellezett kapcsolat.

## Interface — egy szerződés ("lehet" / képesség)

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

An interface defines a **contract** of behavior. A class can implement **multiple** interfaces — this is how Java achieves a form of multiple inheritance. Interfaces (traditionally) have no instance state.

## Absztrakt osztály — egy részleges bázis ("van" megosztott kóddal)

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

An abstract class can hold **state (fields)**, **constructors**, and concrete methods with shared implementation — but a class can extend only **one** abstract class (single inheritance).

## Fő különbségek

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

## Mikor melyiket használjuk

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

## Miért számít ez

Az interface és az absztrakt osztály közötti választás a Java tervezés alapvető döntése.

A interface-ek **szerződéseket/képességeket** definiálnak és lehetővé teszik egy osztálynak, hogy sok ilyet megvalósítson (Java válasza a többszörös öröklődésre) — ideális a keresztmetszet típusú képességekhez.

An abstract class provides a **shared base with state and partial implementation** for closely-related subclasses, but limit you to single inheritance.

A kompromisszumok megértése (többszörös megvalósítás versus megosztott állapot/konstruktorok, képesség versus van-a kapcsolat) vezet a jó API és osztályhierarchia tervezéshez.

Java 8+ default methods korában, amikor elmosódnak a határok, tudni, hogy mikor melyik illeszkedik — és az alapvető korlátok (egy absztrakt osztály de sok interface, állapot csak absztrakt osztályokban) — elengedhetetlen rugalmas, jól strukturált kód tervezéséhez.