[Alg] Abstract vs. interface

[Sebazzz]

Ik ben een beetje bezig met objectgeorienteerd programmeren maar ik kan er maar niet over uit wat het voor of nadeel is van abstracte classes tegenover interfaces.

Als je nu plantachtigen hebt, die moeten allemaal een zelfde patroon volgen:

PHP:

abstract class Plantachtig {
    abstract public function __construct();
    abstract public function __destruct();
    
    abstract public function knak();
}

class Plant extends Plantachtig {
    public function __construct() {
        echo "Plant zegt hallo.\n";
    }
    
    public function __destruct() {
        echo "Plant is dood gegaan\n";
    }
    
    public function knak() {
        echo "Plant knakt om\n";
    }
}

Maar ik kan net zo goed een interface maken:

PHP:

interface Plantachtig2 {
    public function __construct();
    public function __destruct();
    
    public function knak();
    
}

class Plant2 implements Plantachtig2 {
    public function __construct() {
        echo "Plant-interfaced zegt hallo.\n";
    }
    
    public function __destruct() {
        echo "Plant-interfaced is dood gegaan\n";
    }
    
    public function knak() {
        echo "Plant-interfaced knakt om\n";
    }
}

Er gebeurt hetzelfde. En als ik een method vergeet te implementeren dan gebeurt er bij beide:

Fatal error: Class Plant contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Plantachtig::knak) in Q:\www\abstract\abstract.php on line 24

Fatal error: Class Plant2 contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Plantachtig2::knak) in Q:\www\abstract\abstract.php on line 46

Ik snap niet wat het voordeel of nadeel is van een interface tegenover een abstracte class.
Een abstracte class kan alleen nog wat methodes al geimplementeerd hebben (voordeel), maar dan is toch het hele concept van een interface overbodig?
Kan iemand dat uitleggen?

[RobIII]

Hier is zijn pas nog een topics over geweest:
Abstract class versus Interface
\[C#]Beginner, waarom zou je abstract classes gebruiken? *

[ Voor 35% gewijzigd door RobIII op 10-04-2008 13:53 ]

[Cloud]

Je hebt de PHP documentatie over Class Abstraction gelezen neem ik aan?

Lees vooral de comments onderaan eens. Daar staan heel veel verschillen tussen abstracte klassen en interfaces genoemd. En ook wanneer je welke gebruikt.

[Confusion]

Sebazzz schreef op donderdag 10 april 2008 @ 13:50:
Een abstracte class kan alleen nog wat methodes al geimplementeerd hebben (voordeel)

Dat is geen voordeel als ik jouw implementaties niet wil.

[Voutloos]

Tsss, dat is gewoon een voordeel. Als er geen nuttige, algemeen bruikbare implementatie in de abstracte klasse te plaatsen is laat je die gewoon achterwege.

[Tony L]

Sebazzz schreef op donderdag 10 april 2008 @ 13:50:
Ik snap niet wat het voordeel of nadeel is van een interface tegenover een abstracte class.
Een abstracte class kan alleen nog wat methodes al geimplementeerd hebben (voordeel), maar dan is toch het hele concept van een interface overbodig?
Kan iemand dat uitleggen?

Je kan over het algemeen (in de meeste talen) maar één keer van een klasse overerven en meerdere interfaces implementeren.

EDIT : Spelling

[Verwijderd]

Een belangrijk verschil (wat ik veel gebruik) is dat je bij abstracte klassen naast een contract opstellen (methoden die kinderen moeten implementeren) ook al methoden kunt implementeren. Je kan dus standaard gedrag gaan definieren, wat alle kinderen dan overerven. Bij interfaces definieer je alleen welke methoden er geimplementeerd moeten worden, je kan er geen default behaviour in kwijt.

Edit: En dat verschil haal je blijkbaar zelf al aan, is alleen helemaal niet overbodig. Om verder te werken op je voorbeeld.

Je hebt verschillende planten, zoals jij het omschrijft hebben ze allen een verschillende implementatie van groeien, breken en doodgaan. Maar stel (puur om een voorbeeld te geven) dat ze wel allemaal groeien als de zon schijnt (=standaard), alleen de hoeveelheid dat ze groeien is verschillend (=contract):

code:

public abstract class Plantachtig {

    public abstract void groei(double cm);

    public abstract double getAantalCM(double lumen);

    public void krijgtLicht(double lumen){
        double cm = this.getAantalCM(lumen);
        this.groei(cm);
    }
    
}

Maakt dit iets duidelijk? (ps is nu wel java)

[ Voor 51% gewijzigd door Verwijderd op 10-04-2008 15:21 ]

[Janoz]

het grote verschil tussen een abstracte class en een interface is dat een abstracte class gewoon in de class hiërarchie thuishoort. Het valt gewoon onder 'is-a'. Het verschil is dat een abstracte class alleen nog niet genoeg heeft om te functioneren en dat er dus een specifiekere implementatie nodig is.

Een interface daarintegen is niet een 'is-a'. Een interface geeft niet aan wat een class is, maar wat een class kan. Interface geeft immers ook al aan dat het een beschrijving is hoe aan te sluiten op de class. Kijk ik naar je originele voorbeeld, dan is de naamgeving van je interface niet goed. Eigenlijk had die interface namelijk geen 'Plantachtige2' moeten heten, maar 'Knakbaar'.

Een constructor en destructor hoort sowieso niet in een interface thuis. Naast dat het in deze benadering niet logisch is geeft het ook andere problemen. Zou een class meerdere interfaces implementeren, welke constructors zouden dan uitgevoerd moeten worden en in welke volgorde?

[Sebazzz]

Oei, ik had wel even kunnen zoeken ja Sorry, sorry, sorry, maar de GoT search engine.... Google had ik niet geprobeerd.

Als ik het goed begrijp zijn abstracte classes meer voor het gedrag, terwijl interfaces beschrijven welke methode de klasse moet hebben die de interface implementeert. Met interfaces kan je dus geen gedrag aangeven?

[Verwijderd]

Sebazzz schreef op donderdag 10 april 2008 @ 15:22:
...
Als ik het goed begrijp zijn abstracte classes meer voor het gedrag, terwijl interfaces beschrijven welke methode de klasse moet hebben die de interface implementeert. Met interfaces kan je dus geen gedrag aangeven?

Klopt interface is enkel een contract. Dus heb je enkel een contract nodig dan gebruik je een interface. Heb je ook standaard gedrag nodig dan moet je naar overerving gaan zien, eventueel met een abstracte klasse om ook contracten te kunnen opstellen.

[Sebazzz]

Stel dat je een framework voor websites maakt. Een framework bevat o.a elementen wat later HTML elementen zullen worden. Ieder element (TextBox, Label, etc...) bevat dus o.a een methode die de HTML code van dat element teruggeeft. Maar het object moet ook via de PHP methode __toString die methode aanroepen. Je maakt dus een interface HTMLElement en geen abstracte klasse, dat kan wel, maar is niet 'juist'?

[Janoz]

Een HTMLElement lijkt me een typisch voorbeeld van een abstracte klasse. Alles is immers een html element, maar het html element zelf bestaat eigenlijk niet.

[NetForce1]

En die abstracte HTMLElement klasse heeft dan uiteraard methodes geimplementeerd om de id, style, class, name ed te setten / getten.

[ Voor 4% gewijzigd door NetForce1 op 10-04-2008 19:02 ]

[Verwijderd]

Een interface is een abstracte klasse, een volledig abstracte klasse wel te verstaan. Sommige talen maken een syntactisch verschil maar feitelijk is die er niet. Van volledig abstracte klassen weten we dat die niet voor problemen zorgen bij multiple inheritance dus vandaar dat je syntactisch wel het onderscheidt eventueel zou willen maken. Verschil is er dus eigenlijk helemaal niet

[Sebazzz]

Verwijderd schreef op donderdag 10 april 2008 @ 20:15:
Verschil is er dus eigenlijk helemaal niet

Nee maar wel in het juiste gebruiken in verschillende situaties. Dat is eigenlijk mijn vraag

[Verwijderd]

een abstracte klasse kan je gebruiken als er veel dezelfde code zit tussen de verschillende (eind-)klassen. Een interface is eigenlijk vooral om vershillende objecten te verplichten, d.m.v. een contract, te reageren op dezelfde aanroepen.

jij gebruikte de abstracte klasse dus eigenlijk alleen maar als interface ... maar een abstracte klasse's werkelijke potentieel ligt in het voorkomen van dubbele code... dus als je jouw voorbeeld nou eens implementeerd met een paar klassen meer:

_{ik kom uit een java/VB.net achtergrond dus code kan misschien net verkeerd zijn voor php.}

via een interface:

PHP:

<?php
interface Plantachtig2 {
    public function __construct();
    public function __destruct();
    
    public function knak();
    
}

class Roos implements Plantachtig2 {
    public function __construct() {
        echo "Roos zegt hallo.\n";
    }
    
    public function __destruct() {
        echo "Roos is dood gegaan\n";
    }
    
    public function knak() {
        echo "Roos knakt om\n";
    }
}

class Plant2 implements Plantachtig2 {
    public function __construct() {
        echo "Afrikaantje zegt hallo.\n";
    }
    
    public function __destruct() {
        echo "Afrikaantje is dood gegaan\n";
    }
    
    public function knak() {
        echo "Afrikaantje knakt om\n";
    }
}

class Plant2 implements Plantachtig2 {
    public function __construct() {
        echo "Zonnebloem zegt hallo.\n";
    }
    
    public function __destruct() {
        echo "Zonnebloem is dood gegaan\n";
    }
    
    public function knak() {
        echo "Zonnebloem knakt om\n";
    }
}
?>

via een abstracte klasse:

PHP:

<?php
abstract class Plantachtig {
    String naam;

    public function nieuw() {
     echo naam + " zegt hallo.\n";
    }
    public function __destruct(){
     echo naam + " is dood gegaan\n";
    }
    public function knak(){
     echo naam + " knakt om\n";
    }
}

class Roos extends Plantachtig {
    public function __construct() {     
        naam = "Roos";
    nieuw();
    }
}

class Afrikaantje extends Plantachtig {
     public function __construct() {    
        naam = "Afrikaantje";
    nieuw();
    }
}

class Zonnebloem extends Plantachtig {
     public function __construct() {    
        naam = "Zonnebloem ";
    nieuw();
    }
}
?>