[oop] factory vs constructor

Hey Ozzie,

Als je beginner bent dan adviseer ik je altijd eenvoudig te programmeren.

Gebruik Object-oriented concept en namespace die zijn belangrijk.

Factory design is echt niet dat belangrijk voor een beginner.

Factory design is gebaseerd op een eenvoudig princiep.
Net als een fabriek dat maakt verschillen producten.

Het kan een global fabriek of meerder sub fabrieken.
Dus een factory is een class dat bestaat uit meerder static methoden die creëren objecten en geven die objecten terug.
Bijv.
$Session = $Factory::creatSession('user', 'Ozzie');
$Auto = $Factory::creatProduct( ‘auto’);
….

Het kan ook heel global zijn
$Session = $Factory::creat('user', 'Ozzie');
$Auto = $Factory::creat( ‘auto’);

P.S
$session = Session::create('user', 'Ozzie');
respecteert niet de Factory design.

>> P.S
$session = Session::create('user', 'Ozzie');
respecteert niet de Factory design.

Maar dat is dus ook mijn vraag...

Waarom zou je dit doen

$session = Session::create('user', 'Ozzie')

in plaats van dit?

$session = new Session('user', 'Ozzie');

oke.

Hier is een simpel voorbeeld zonder factory design.

if (class_exists('auto') && class_exists('motor') && class_exists('wielen') ) {
$wielen= new wielen();
$motor= new motor();
$auto = new auto($motor, $wielen);
}

met factory design

public static function creat($nameObject) {

if($nameObject=='auto') $this->creatAuto();
}

private function creatAuto() {
if (class_exists('auto') && class_exists('motor') && class_exists('wielen') ) {
$wielen= new wielen();
$motor= new motor();
return new auto($motor, $wielen);
} else {
 die('fatal error, class not exist ');
}
}

$auto = factory::creat('auto');

Maar in het voorbeeld hierboven, waarom zegt Wouter daar "en nog mooier: gebruik een factory: Session::create('user', 'Ozzie')"? Weet jij waarom hij dat mooier vindt? Ik zie het voordeel niet.

Wat betreft jouw voorbeeld... als je een autoloader gebruikt heb je zoiets toch niet nodig?

Ik dacht dat factory's vooral bedoeld waren om een object te maken met een bepaalde configuratie, zodat je dat niet telkens hoeft te herhalen.

Dus alle die controles en error detectie... worden in factory gemaakt!

Toevoeging op 07/03/2014 19:57:08:

Ja! je kan dat met een autoloder gebruiken.
de bedoeling van factory is dat je alle soort objecten met een object can maken.


Toevoeging op 07/03/2014 20:01:29:

Hier is een uitleg met een voorbeeld.

http://www.phptherightway.com/pages/Design-Patterns.html

In het voorbeeld in de link die jij geeft staat:

<?php
class AutomobileFactory
{
public static function create($make, $model)
{
return new Automobile($make, $model);
}
}
?>
En dan...

<?php
$veyron = AutomobileFactory::create('Bugatti', 'Veyron');
?>
Wat is het verschil als ik gewoon dit doe:

<?php
$veyron = new Automobile('Bugatti', 'Veyron');
?>
Ik zie het nut niet zo eigenlijk.

Waarom Wouter het factory pattern aanhaalde weet ik niet.

<?php

final class Model {

private static $factories = array();

public static function create($model, ...$params) // PHP 5.6 variadics
{
$model = strtolower($model);

if ( ! isset(self::$factories[$model]))
throw new InvalidArgumentException('no factory found');

$factory = self::$factories[$model];

return $factory::create(...$params); // PHP 5.6 variadics
}

public static function register($model, $factory)
{
if ( ! is_string($factory) || ! method_exists($factory, 'create'))
throw new InvalidArgumentException('invalid factory');

self::$factories[strtolower($model)] = $factory;
}
}

// use namespace statements

Model::register('User', User::class);
Model::register('Profile', Profile::class);
Model::register('Game', Game::class);

// ander bestand

$user = Model::create('User', 42, 'Darsstar');

?>

Met een factory maak je een object aan van een onbekende class. Vaak weet je wel dat het een bepaalde interface implementeert, of een class X is of als parent heeft. Maar zeker weten welke class doe je vaak niet.

Dat voorbeeld is erg eenvoudig.

Soms het maken van een object bestaat uit veel stappen.
In plaats dat je dat herhaaldelijk doet elke keer als je een object wil maken.
Doe je dat een keer in jouw Factory class.

Ah oke... dat is inderdaad een andere, meer zinvolle, interpretatie. Volgens mij kun je dit soort dingen ook oplossen met een servicecontainer?

Hoe dan ook snap ik nog steeds niet waarom Wouter in het genoemde voorbeeld een factory "mooier" noemt, want in het betreffende geval zie ik geen meerwaarde ten opzichte van het aanmaken van een object en het meegeven van de argumenten aan de constructor.

Toevoeging op 07/03/2014 20:26:39:

>> Soms het maken van een object bestaat uit veel stappen.
In plaats dat je dat herhaaldelijk doet elke keer als je een object wil maken.
Doe je dat een keer in jouw Factory class.

Ja, maar in het voorbeeld wat Wouter geeft, is dit toch niet van toepassing?

Wat wouter bedoelt is een soort of embedded Factorization.

maar hier is een class diagram van de factory pattern