[php] Object moet informatie krijgen van parent

[Alain]

Ik heb een class Switchboard. Deze class bevat (mogelijk) objecten van de classes Generators en Consumers. Alle genoemde classes hebben de variabelen 'voltage' en 'frequency'.

Nu wil ik eigenlijk dat bij de functie calculate() de variabelen 'voltage' en 'frequency' van de parent Switchboard worden gebruikt. Maar ik snap niet hoe ik dit het beste kan doen.

De variabelen static maken heeft geen zin, want objecten van de verschillende classes kunnen verschillende spanningen en frequenties hebben. De informatie moet dus bij de class Switchboard vandaan komen.

Nu kan ik natuurlijk de variabelen 'voltage' en 'frequency' voor elk object aanmaken en bij een wijziging updaten, maar kan dit niet simpeler?

[Kettrick]

Je kan de generators en consumers toch een reference voeren van je switchboard ?

[mithras]

Ik snap niet helemaal wat je voor probleem schetst. Als ik het goed begrijp zit je met de volgende casus:

PHP:

class Switchboard{
  public voltage;
  public $frequency;
}

class Generators extends Switchboard{
  public voltage;
  public $frequency;
  function calculate(){
    do_something( parent::voltage );
  }
}

class Consumers extends Switchboard{
  public voltage;
  public $frequency;
  function calculate(){
    do_something( parent::voltage );
  }
}

Je kan gewoon parent keyword met scope resolution operator gebruiken dan

Als je bedoelt dat Switchboard een parameter heeft die een instance is van Generators en Consumers, zou je het zo kunnen oplossen:

PHP:

class Switchboard{
  public voltage;
  public $frequency;
  private $generators;
  private $consumers;

  public function __construct(){
    $this->generators = new Generators( $this );
    $this->consumers = new Consumers( $this );
  }
}

class Generators{
  public voltage;
  public $frequency;
  private $parent;

  public function __construct( $parent ){
    $this->parent = $parent;
  }
  function calculate(){
    do_something( $this->parent->voltage );
  }
}

class Consumers{
  public voltage;
  public $frequency;
  private $parent;

  public function __construct( $parent ){
    $this->parent = $parent;
  }
  function calculate(){
    do_something( $this->parent->voltage );
  }
}

[ Voor 43% gewijzigd door mithras op 05-02-2008 22:06 ]

[Alain]

RoeLz schreef op dinsdag 05 februari 2008 @ 22:01:
Je kan de generators en consumers toch een reference voeren van je switchboard ?

Daar was ik eigenlijk naar op zoek. Nu je het woord reference noemde heb ik veel informatie op php.net gevonden.

mithras schreef op dinsdag 05 februari 2008 @ 22:04:
Ik snap niet helemaal wat je voor probleem schetst.

Je hebt het stiekum wel begrepen. Jouw tweede oplossing is perfect voor mij.

Jouw eerste oplossing snap ik niet helemaal. Zoals ik het daar lees heeft een Generator dus ook alle eigenschappen van een Switchboard?

[mithras]

AlainS schreef op dinsdag 05 februari 2008 @ 22:21:
[...]

Je hebt het stiekum wel begrepen. Jouw tweede oplossing is perfect voor mij.

Zie mijn edit. Zag RoeLz' post en bedacht dat je dat bedoelde. Met parent/child relaties bedoel je vaker een extended klasse dan een instantie van een klasse als property

Jouw eerste oplossing snap ik niet helemaal. Zoals ik het daar lees heeft een Generator dus ook alle eigenschappen van een Switchboard?

Zie de php manual eens en met name het kopje extends.

Zie ook dit duidelijke voorbeeld:

PHP:

class auto{
  public $max_snelheid;
  public $vermogen;
  public $kleur;
  public $model;
}

class fiat extends auto{
  public function __construct(){
    $this->max_snelheid = 120;
    $this->vermogen = 180;
    $this->kleur = "zwart";
    $this->model = "punto";
  }
}

class ferrari extends auto{
  private $special;

  public function __construct(){
    $this->max_snelheid = 350;
    $this->vermogen = 660;
    $this->kleur = "rood";
    $this->model = "enzo";
    $this->special = true;
  }
}

[Alain]

mithras schreef op dinsdag 05 februari 2008 @ 23:20:
Zie de php manual eens en met name het kopje extends.

Dat is toch precies wat ik zeg? Je neemt de eigenschappen van een andere class over. Een Switchboard heeft op spanning en frequentie na geen overeenkomsten met een Generator of Consumer. Ik zou dus alleen de spanning en frequentie mee willen nemen in berekeningen en daarvoor werkt je tweede methode goed.

[Snake]

Zet dan je variablen wel op protected Daarvoor dient dat namelijk.

[SchizoDuckie]

mithras schreef op dinsdag 05 februari 2008 @ 23:20:
[...]
Zie mijn edit. Zag RoeLz' post en bedacht dat je dat bedoelde. Met parent/child relaties bedoel je vaker een extended klasse dan een instantie van een klasse als property

Zegguh wil je mij en andere personen hun basiskennis van OO theorie even niet door de war schoppen? Je had zelfs mij even in mode met je eerste voorbeeld. Parent/child relaties werken met references, niet d.m.v. het extenden van een object (er is namelijk geen parent instance maar een parent class in jouw eerste voorbeeld.

Overigens, om terug te komen op de TS, je kunt nog overwegen om je switchboard class een singleton te maken als dit een soort van globale 'manager' is, en je maar 1 instance hebt. Voordeel daaraan is dat je code overzichtelijker en meer zichzelf beschrijvend wordt (ipv $this->parent heb je nu gelijk de class name voor je neus):

PHP:

class Switchboard {
    public voltage;
    public $frequency;
    private $generators = array();
    private $consumers = array();

    public function __construct(){
        $this->voltage = 100;
        $this->frequency = 220;
    }

    public static function getInstance(){
        static $instance;
        if (!isset($instance)) {
            $c = __CLASS__;
            $instance = new $c;
        }
        return $instance;
    }

    function addCunsumer($label){
        $newCunsumer= new Cunsumer($label);
        $this->consumers[] = $newCunsumer;
        return $newCunsumer ;
    }
}

// generator is ff niet nodig voor demo

class Consumer{
    private $label;

    function __construct($label='undefined'){
        $this->label = $label;
    }

    function display() {
        return $this->label.': '.SwitchBoard::getInstance()->voltage;
    }
} 

$consumer = SwitchBoard::getInstance->addConsumer('test dingetje');
echo $consumer->display();

Wat je op deze manier dus ook kunt doen, is als je van meerdere types elk een switchboard hebt, deze extenden van switchboard, en die zou je dan gelijk vanuit bijv. bij het aanmaken van een nieuwe Generator bij elkaar kunnen rapen:

PHP:

// we gaan even verder met de code van hierboven



class OverloadedSwitchboard extends Switchboard {
   function __ construct(){
        $this->voltage = 8000;
        $this->frequency = 1800;
   }

} 

class Generator extends Consumer{
   
   function display(){
        return $this->label.':'.SwitchBoard::getInstance()->voltage. ' - '.OverloadedSwitchboard::getInstance()->voltage;
   }


}

$generator = new Generator('vwalla: ');
echo $generator->display();

[ Voor 32% gewijzigd door SchizoDuckie op 06-02-2008 00:52 ]

[mithras]

Snake schreef op dinsdag 05 februari 2008 @ 23:51:
Zet dan je variablen wel op protected Daarvoor dient dat namelijk.

Mm, ja dat is waar. Dat kwam eigenlijk terug in les 2

SchizoDuckie schreef op woensdag 06 februari 2008 @ 00:29:
[...]


Zegguh wil je mij en andere personen hun basiskennis van OO theorie even niet door de war schoppen? Je had zelfs mij even in mode met je eerste voorbeeld. Parent/child relaties werken met references, niet d.m.v. het extenden van een object (er is namelijk geen parent instance maar een parent class in jouw eerste voorbeeld.

De php manual spreekt van:

extends
[...]
The inherited methods and members can be overridden, unless the parent class has defined a method as final, by redeclaring them with the same name defined in the parent class. It is possible to access the overridden methods or static members by referencing them with parent::

Er is in de klasse gewoon sprake van een parent klasse. Dus waarom zou je niet van die relatie kunnen spreken? Er is dmv een extend toch een relatie tussen a en b gezegd (of ga ik hier nu de mist in ).

Verder geeft php dit voorbeeld voor het extenden:

PHP:

class SimpleClass
{
    // member declaration
    public $var = 'a default value';

    // method declaration
    public function displayVar() {
        echo $this->var;
    }
}
class ExtendClass extends SimpleClass
{
    // Redefine the parent method
    function displayVar()
    {
        echo "Extending class\n";
        parent::displayVar();
    }
}

$extended = new ExtendClass();
$extended->displayVar();

code:

Extending class
a default value

Daar zit imho niet bijzonder veel verschil in.

Overigens, om terug te komen op de TS, je kunt nog overwegen om je switchboard class een singleton te maken als dit een soort van globale 'manager' is, en je maar 1 instance hebt. Voordeel daaraan is dat je code overzichtelijker en meer zichzelf beschrijvend wordt (ipv $this->parent heb je nu gelijk de class name voor je neus):

PHP:

class Switchboard {
    public voltage;
    public $frequency;
    private $generators = array();
    private $consumers = array();

    public function __construct(){
        $this->voltage = 100;
        $this->frequency = 220;
    }

    public static function getInstance(){
        static $instance;
        if (!isset($instance)) {
            $c = __CLASS__;
            $instance = new $c;
        }
        return $instance;
    }

    function addCunsumer($label){
        $newCunsumer= new Cunsumer($label);
        $this->consumers[] = $newCunsumer;
        return $newCunsumer ;
    }
}

// generator is ff niet nodig voor demo

class Consumer{
    private $label;

    function __construct($label='undefined'){
        $this->label = $label;
    }

    function display() {
        return $this->label.': '.SwitchBoard::getInstance()->voltage;
    }
} 

$consumer = SwitchBoard::getInstance->addConsumer('test dingetje');
echo $consumer->display();

Sowieso moet je singletons wel uitleggen dat er maar een instance van mogelijk is. Het is niet toevallig handig als je maar een instance gebruikt, er mag maximaal maar een instance zijn.

Verder kan je (als je niet heel moeilijk wil doen), ook $this->parent vervangen door $this->switchboard, als je er erg over struikelt.

Wat je op deze manier dus ook kunt doen, is als je van meerdere types elk een switchboard hebt, deze extenden van switchboard, en die zou je dan gelijk vanuit bijv. bij het aanmaken van een nieuwe Generator bij elkaar kunnen rapen:

PHP:

// we gaan even verder met de code van hierboven



class OverloadedSwitchboard extends Switchboard {
   function __ construct(){
        $this->voltage = 8000;
        $this->frequency = 1800;
   }

} 

class Generator extends Consumer{
   
   function display(){
        return $this->label.':'.SwitchBoard::getInstance()->voltage. ' - '.OverloadedSwitchboard::getInstance()->voltage;
   }


}

$generator = new Generator('vwalla: ');
echo $generator->display();

Is dit (een singleton trouwens ook) niet gewoon compleet overrated voor het simpele voorbeeld uit de TS?

[Janoz]

mithras schreef op woensdag 06 februari 2008 @ 09:39:
[...]
De php manual spreekt van:

De php manual zou ik persoonlijk niet als je bron mbt algemene OO gebruiken.

Er is in de klasse gewoon sprake van een parent klasse. Dus waarom zou je niet van die relatie kunnen spreken? Er is dmv een extend toch een relatie tussen a en b gezegd (of ga ik hier nu de mist in ).

Ja. Overerving is misschien wel een soort relatie, maar niet elke relatie is overerving. Overerving, en dus extends, gebruik je bij een verdere specificering van hetzelfde object. De ene class extend de andere wanneer ze een 'is a' relatie hebben. In het gegeven voorbeeld wordt over consumers, generators en switchboards gesproken. Volgens mij kun je niet zeggen 'generator is a switchboard' of 'consumer is a switchboard'. Hier is waarschijnlijk meer de 'has a' van toepassing.

Een parent is niet automatisch een base class. Neem bijvoorbeeld een formulier in een html pagina. Elk formulier veld heeft als parent een form en een form heeft een berg input velden als children. Wanneer je dit in een OO modelletje zou gieten dan zouden de input velden absoluut niet extenden van form. Een OO design zal eerder een generieke input class hebben met name en value als properties. Een form class zal een lijst input objecten hebben (de 'has a' relatie). Vervolgens zullen er verschillende input classes zijn (text, textarea, password enz). Deze extenden de generieke input class. Voor een password veld geld immers 'password input is an input'.

[Alain]

SchizoDuckie schreef op woensdag 06 februari 2008 @ 00:29:
[...]


Overigens, om terug te komen op de TS, je kunt nog overwegen om je switchboard class een singleton te maken als dit een soort van globale 'manager' is, en je maar 1 instance hebt. Voordeel daaraan is dat je code overzichtelijker en meer zichzelf beschrijvend wordt (ipv $this->parent heb je nu gelijk de class name voor je neus):

Bedankt voor je oplossing. Ik heb er wat van geleerd, maar kan het in dit geval niet gebruiken omdat ik meerdere instantie's van Switchboard krijg. Ik heb het opgelost door een referentie mee te geven. Ik heb het nu ook zo gemaakt dat je een Switchboard in de constructor een referentie mee kunt geven naar een ander Switchboard (een Switchboard kan een onderverdeling zijn van een ander Switchboard).

Bedankt allemaal. Ik kan voorlopig weer verder hobbien.