[oop] abstracte class, invulling methods

[offtopic]
Het doet in zoverre wel terzake dat je add_namespace() methode iets aan een namespace toevoegt dat niet in een namespace thuishoort. Of je zou de methode anders moeten noemen.
[/offtopic]

Als het om een kleine aanvulling op de abstracte klasse gaat, kun je de parent-methode aanroepen.

<?php
abstract class AbstractAutoloader
{
    protected $Namespaces;

    public function add_namespace($name, $path)
    {
        $this->Namespaces[$name] = $path;
    }
}

class OrdinaryAutoloader extends AbstractAutoloader
{
    // Blanco: implementeert AbstractAutoloader()
}

class SlashingAutoloader extends AbstractAutoloader
{
    public function add_namespace($name, $path)
    {
        // Voeg die backslash toe ...
        $name = rtrim($name, '\\') . '\\';
        // ... en implementeer de rest
        parent::add_namespace($name, $path);
    }
}
?>

"SlashingAutoloader"

Hehe... lol :)

De parent aanroepen zou kunnen, maar in jouw voorbeeld zou ik denk ik gewoon die regel code uit de parent in de method zelf zetten. Scheelt toch weer een method-call.

Dat zou ik niet doen: je wilt de methode in de abstracte klasse kunnen herschrijven of uitbreiden. Dat het nu maar één regel is, wil niet zeggen dat dat in de toekomst ook zo is. In de gekloonde methode wil je daarom liefst alleen de verschillen met het origineel vastleggen.

Mja... dat is een persoonlijke keuze. Je kunt het ook zien dat je nu de taak van 1 method gaat spreiden over 2 methods. Als er daadwerkelijk complexe logica wordt uitgevoerd, dan zou ik het nog een ander verhaal vinden. Maar om enkel iets te setten een andere method aanroepen... hmmm, kweet het niet. Je kunt het ook andersom zien. Je past de parent method aan, en creëert daarmee mogelijk zonder dat je het in de gaten hebt een probleem voor de SlashingAutoloader. Het werkt dus 2 kanten op.

DRY, look it up

Inderdaad.

Als je dergelijke verschillen met strings voor namen en paden vaker verwacht, zou je ook nog late static bindings kunnen gebruiken.

<?php
abstract class AbstractAutoloader
{
    const NAMESPACE_PREFIX  = '';
    const NAMESPACE_POSTFIX = '';

    protected $Namespaces;

    public function add_namespace($name, $path)
    {
        $name = static::NAMESPACE_PREFIX . $name . static::NAMESPACE_POSTFIX;
        $this->Namespaces[$name] = $path;
    }
}

class OrdinaryAutoloader extends AbstractAutoloader
{
    // Blanco: implementeert AbstractAutoloader() volledig
}

class SlashingAutoloader extends AbstractAutoloader
{
    // Implementeert maar één verschil
    const NAMESPACE_POSTFIX = '\\';
}
?>

@Dos: ik ken DRY.

Ben jij het dan NIET eens met wat Reshad hierboven zegt?

Reshad F op 19/06/2014 23:46:45

je gebruikt die abstractie wanneer je weet dat ELKE klas die het overneemt de zelfde implementatie gebruikt van die methode. wanneer je dit dus verschillend hebt dan kan je het beter leeg laten. ...

@Ward:

Daar ga ik eens over nadenken. Dat is wellicht een goede optie en wat minder "gevaarlijk" wat betreft het spreiden van code.

Ik ben het wel met Reshad eens: leeg laten is een duidelijke instructie die de verplichting om de methode te implementeren bij afgeleide klassen legt.

Alleen heb je hier een marginaal verschil in slechts één afgeleide klasse. Zoals ik daarom zei: "Als het om een kleine aanvulling op de abstracte klasse gaat ...". Daarom implementeer je uitsluitend die kleine aanvulling in de afgeleide methode en laat je het standaardprototype via parent:: de rest doen.

>> Daarom implementeer je uitsluitend die kleine aanvulling in de afgeleide methode en laat je het standaardprototype via parent:: de rest doen.

Maar is dat niet een "risico" dan? Als ik de method in de parent class invul is het geen abstracte method meer. Dan komt er een dag (enigszins geneuzel dat wel, maar het gaat even om het idee) dat ik besluit om in de parent class een slash toe te voegen aan de namespace. Het gevolg: die afwijkende class krijgt ineens 2 slashes achter een namespace. Dat is (denk ik) toch ook een risico? Is het dan niet veiliger om de method abstract te maken en de invulling aan de childs over te laten, waarbij je moet accepteren dat in 2 methods hetzelfde gebeurt?

Risico is iets dat je incalculeert, kijk maar naar wat ik eerder deed:

$name = rtrim($name, '\\') . '\\';

Risico = kans × effect. Als de abstract class wordt verbeterd en dat niet met copy/paste wordt overgenomen, heeft dat ingrijpendere gevolgen. De kans is klein, maar het effect is groot. Daarom formaliseer je die copy/paste met parent::add_namespace().