Alternatief voor extenden class met zelfde input

[TheNephilim]

Op dit moment heb ik ongeveer de volgende constructie:

PHP:

// Calculation.php
class Calculation {

    protected $var1;
    
    protected $var2;
    
    protected $var3;
    
    public function setVar1($var1)
    {
        $this->var1 = $var1;
    }
    
    public function setVar2()
    {
        $this->var2 = $var2;
    }
    
    public function setVar3()
    {
        $this->var3 = $var3;
    }
    
    public function doThis()
    {
        // example
    }
    
    public function doThat()
    {
        // example
    }
}

PHP:

// CalculationA.php
class CalculationA extends Calculation {

    public function result()
    {
        // example A
    }
}

PHP:

// CalculationB.php
class CalculationB extends Calculation {

    public function doSomethingElse()
    {
        // example
    }

    public function result()
    {
        // example B
    }
}

PHP:

// CalculationController.php
$calculationA = new CalculationA();

$calculationA
    ->setVar1($var1)
    ->setVar2($var2)
    ->setVar3($var3);

$resultA = $calculationA->result();

$calculationB = new CalculationA();

$calculationB
    ->setVar1($var1)
    ->setVar2($var2)
    ->setVar3($var3);

$resultB = $calculationB->result();

Dit is sterk versimpeld, maar het illustreert de vraag die ik heb.

Je ziet Calculation waar de meeste logica in zit. Zowel CalculationA als CalculationB hebben een resultaat, die voornamelijk gebruik maakt van de methods ed. die in Calculation zitten. Alleen de berekening van het resultaat is steeds anders en CalculationX kan aanvullende methods nodig hebben.

In elk geval is de data die erin gaat steeds hetzelfde. Wat is de juiste manier om éénmalig de data erin te gooien en dan de verschillende resultaten eruit te kunnen halen?

Andere manieren om dit te doen zijn;

1. Alles in één class gooien en dan de resultaten opsplitsen in method resultA en resultB. Niet wenselijk natuurlijk...
2. CalculationA als CalculationB traits toevoegen aan Calculation.

Uiteraard zijn er meerdere CalculationX classes en ook meerdere setVarN methods.

[emnich]

Je maakt een aparte class voor de vars (var1, var2, etc) en die geef je aan je calculation classes

[NMe]

Een factory gebruiken? Gewoon zorgen dat je een nieuwe calculation krijgt op basis van het type dat je wil, alle calls daarna zijn gewoon setters en een call naar je resultfunctie die weer generiek kunnen zijn. Betekent wel dat je result() als (abstracte) functie in Calculation moet zetten. Sowieso wil je volgens mij Calculation zelf abstract maken, geloof ik?

[TheNephilim]

Het punt is dat ik alle resultaten tegelijk nodig heb; ik moet vanuit dezelfde gegevens meerdere berekeningen tonen. Heel plastisch gezien zou ik op zoiets uitkomen:

PHP:

$calculation = new Calculation();

$calculation
    ->setVar1($var1)
    ->setVar2($var2)
    ->setVar3($var3);

$resultA = $calculation->resultA(); // bijv. in een trait CalculationA
$resultB = $calculation->resultB(); // bijv. in een trait CalculationB

Dus volgens mij heb ik geen factory nodig, maar misschien begrijp ik je verkeerd.

---

Of zoiets als dit:

PHP:

$calculation = new Calculation();

$calculation
    ->setVar1($var1)
    ->setVar2($var2)
    ->setVar3($var3);

$resultA = $calculation->result(new CalculationA());
$resultB = $calculation->result(new CalculationB());

---

Als ik Calculation abstract wil houden dan moet ik sowieso die variabelen zowel aan CalculationA als CalculationB geven. Dat is nogal een lap (volgens mij onnodige code) met 4-5 verschillende berekeningen.

[Creepy]

Misschien dat je het Strategy design pattern hiervoor kan gebruiken?

[emnich]

TheNephilim schreef op donderdag 16 maart 2017 @ 15:51:
Het punt is dat ik alle resultaten tegelijk nodig heb; ik moet vanuit dezelfde gegevens meerdere berekeningen tonen. Heel plastisch gezien zou ik op zoiets uitkomen:

PHP:

$calculation = new Calculation();

$calculation
    ->setVar1($var1)
    ->setVar2($var2)
    ->setVar3($var3);

$resultA = $calculation->resultA(); // bijv. in een trait CalculationA
$resultB = $calculation->resultB(); // bijv. in een trait CalculationB

Dus volgens mij heb ik geen factory nodig, maar misschien begrijp ik je verkeerd.

---

Of zoiets als dit:

PHP:

$calculation = new Calculation();

$calculation
    ->setVar1($var1)
    ->setVar2($var2)
    ->setVar3($var3);

$resultA = $calculation->result(new CalculationA());
$resultB = $calculation->result(new CalculationB());

---

Als ik Calculation abstract wil houden dan moet ik sowieso die variabelen zowel aan CalculationA als CalculationB geven. Dat is nogal een lap (volgens mij onnodige code) met 4-5 verschillende berekeningen.

En waarom niet

PHP:

$vars = new VarObject();
$vars->setVar1(1);
$vars->setVar2(2);

$calculationA = new CalculationA($vars);
$calculationA->getResult();

$calculationB = new CalculationB($vars);
$calculationB->getResult();

[NMe]

TheNephilim schreef op donderdag 16 maart 2017 @ 15:51:
Het punt is dat ik alle resultaten tegelijk nodig heb; ik moet vanuit dezelfde gegevens meerdere berekeningen tonen.

Dan sluit ik me bij Creepy aan en lijkt het strategy pattern me een prima keuze.

Als ik Calculation abstract wil houden dan moet ik sowieso die variabelen zowel aan CalculationA als CalculationB geven. Dat is nogal een lap (volgens mij onnodige code) met 4-5 verschillende berekeningen.

Waarom zou een abstracte klasse geen niet-abstracte members mogen hebben?

[TheNephilim]

NMe schreef op donderdag 16 maart 2017 @ 16:23:
[...]

Dan sluit ik me bij Creepy aan en lijkt het strategy pattern me een prima keuze.

Hmmm, ik ben nu een uurtje bezig met het toepassen ervan; of beter gezegd de toepassing ervan vinden voor mijn situatie. Misschien moet ik er morgen eens fris naar kijken.

[...]

Waarom zou een abstracte klasse geen niet-abstracte members mogen hebben?

Maar als ik Calculation niet kan instantiëren, dan kan ik toch er toch ook niet zeggen: $calculation = new Calculation(); en $calculation->setVar1();?

[NMe]

TheNephilim schreef op donderdag 16 maart 2017 @ 17:42:
Maar als ik Calculation niet kan instantiëren, dan kan ik toch er toch ook niet zeggen: $calculation = new Calculation(); en $calculation->setVar1();?

Nee, maar dat zou je in die opzet ook niet moeten willen. Mijn antwoord ging ervan uit dat je een Calculation had van één bepaald type en er ook maar eentje wilde doen op elke set data, en dan wil je dus inderdaad die resultaat-functie abstract opgeven in je Calculation en verder uitwerken in CalculationA en CalculationB. Calculation zelf moet dan abstract zijn in dat geval, en dat zou (wederom in die usecase) gewoon moeten kunnen. In de case die je daadwerkelijk hebt is het wat minder interessant.