3 methoden van attr opslaan
De eerste methode heeft een iets andere (mindere) functionaliteit dan de 2e en 3e, maar het idee is hetzelfde.
Het gaat over 3 manieren om een vliegtuig en zijn vleugels op te slaan. Ik maak steeds twee klassen: Airplane en een extended versie daarvan: CoolAirplane.
Let niet op naamgeving, scopes, gebrek aan attributen, foutafhandeling, etc. Ga uit van eerlijk gebruik (laten we hier aub niet de discussie over beginnen). Het gaat alleen maar om de vleugels en het vleugeloppervlak.
Elke vleugel heeft twee attr: oppervlak en hoek. Een hoek van 0gr betekent horizontaal, een hoek van 90gr is verticaal (dus zonder draagoppervlak).
Code (php)
Welke van de volgende methoden is het "beste":
---- 1 ----
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
class Airplane {
public $wings = array();
public function __construct() {
$this->wings[] = new Wing(40, 0);
$this->wings[] = new Wing(40, 0);
}
public function getWingSurface() {
$fSurface = 0.0;
foreach ( $this->wings AS $wing ) {
$fSurface += $wing->surface * cos($wing->angle);
}
return round($fSurface, 2);
}
}
class CoolAirplane extends Airplane {
public function __construct() {
parent::__construct();
$this->wings[] = new Wing(25, 45);
$this->wings[] = new Wing(25, 45);
}
}
?>
class Airplane {
public $wings = array();
public function __construct() {
$this->wings[] = new Wing(40, 0);
$this->wings[] = new Wing(40, 0);
}
public function getWingSurface() {
$fSurface = 0.0;
foreach ( $this->wings AS $wing ) {
$fSurface += $wing->surface * cos($wing->angle);
}
return round($fSurface, 2);
}
}
class CoolAirplane extends Airplane {
public function __construct() {
parent::__construct();
$this->wings[] = new Wing(25, 45);
$this->wings[] = new Wing(25, 45);
}
}
?>
of
---- 2 ----
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?php
class Airplane {
public $leftwing = null;
public $rightwing = null;
public function __construct() {
$this->leftwing = new Wing(40, 0);
$this->rightwing = new Wing(40, 0);
}
public function getWingSurface() {
$fSurface = 0.0;
$fSurface += $this->leftwing->surface * cos($this->leftwing->angle);
$fSurface += $this->rightwing->surface * cos($this->rightwing->angle);
return round($fSurface, 2);
}
}
class CoolAirplane extends Airplane {
public $leftglider = null;
public $rightglider = null;
public function __construct() {
parent::__construct();
$this->leftglider = new Wing(25, 45);
$this->rightglider = new Wing(25, 45);
}
public function getWingSurface() {
$fSurface = parent::getWingSurface();
$fSurface += $this->leftglider->surface * cos($this->leftglider->angle);
$fSurface += $this->rightglider->surface * cos($this->rightglider->angle);
return round($fSurface, 2);
}
}
?>
class Airplane {
public $leftwing = null;
public $rightwing = null;
public function __construct() {
$this->leftwing = new Wing(40, 0);
$this->rightwing = new Wing(40, 0);
}
public function getWingSurface() {
$fSurface = 0.0;
$fSurface += $this->leftwing->surface * cos($this->leftwing->angle);
$fSurface += $this->rightwing->surface * cos($this->rightwing->angle);
return round($fSurface, 2);
}
}
class CoolAirplane extends Airplane {
public $leftglider = null;
public $rightglider = null;
public function __construct() {
parent::__construct();
$this->leftglider = new Wing(25, 45);
$this->rightglider = new Wing(25, 45);
}
public function getWingSurface() {
$fSurface = parent::getWingSurface();
$fSurface += $this->leftglider->surface * cos($this->leftglider->angle);
$fSurface += $this->rightglider->surface * cos($this->rightglider->angle);
return round($fSurface, 2);
}
}
?>
of
---- 3 ----
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php
class Airplane {
public $leftwing = null;
public $rightwing = null;
public $wings = array('leftwing', 'rightwing');
public function __construct() {
$this->leftwing = new Wing(40, 0);
$this->rightwing = new Wing(40, 0);
}
public function getWingSurface() {
$fSurface = 0.0;
foreach ( $this->wings AS $wingname ) {
$fSurface += $this->$wingname->surface * cos($this->$wingname->angle);
}
return round($fSurface, 2);
}
}
class CoolAirplane extends Airplane {
public $leftglider = null;
public $rightglider = null;
public function __construct() {
parent::__construct();
$this->leftglider = new Wing(25, 45);
$this->rightglider = new Wing(25, 45);
$this->wings = array_merge($this->wings, array('leftglider', 'rightglider'));
}
}
?>
class Airplane {
public $leftwing = null;
public $rightwing = null;
public $wings = array('leftwing', 'rightwing');
public function __construct() {
$this->leftwing = new Wing(40, 0);
$this->rightwing = new Wing(40, 0);
}
public function getWingSurface() {
$fSurface = 0.0;
foreach ( $this->wings AS $wingname ) {
$fSurface += $this->$wingname->surface * cos($this->$wingname->angle);
}
return round($fSurface, 2);
}
}
class CoolAirplane extends Airplane {
public $leftglider = null;
public $rightglider = null;
public function __construct() {
parent::__construct();
$this->leftglider = new Wing(25, 45);
$this->rightglider = new Wing(25, 45);
$this->wings = array_merge($this->wings, array('leftglider', 'rightglider'));
}
}
?>
De "test":
Code (php)
Het resultaat is steeds hetzelfde. Ik heb niet voor snelheden gebenchmarkt.
Een paar van mijn gedachten:
Optie 1 is makkelijk en generiek. De getWingSurface methode blijft gelijk en is makkelijk. Een nadeel ervan is dat je in een ander (afwezig) onderdeel van de klasse niet bij een specifieke vleugel kan. Ze zitten namelijk in een gewone array.
Optie 2 is moeilijker en groter. Wel fijn is dat je waar dan ook in je klasse bij welke wing dan ook kan (en overzichtelijk). Nadeel is dat de getWingSurface methode steeds verandert bij elke extension van de klasse.
Optie 3 is een soort middenweg, maar de attribuutNAMEN van de vleugels opslaan in de klasse staat me niet zo aan. getWingSurface() blijgt gelijk en specifieke vleugels aanroepen kan.
Wat denk jij?
De keuze tussen 1 en 2 is meer functioneel: heeft elk vliegtuig altijd 2 vleugels of zou het kunnen dat er ooit één komt met meer vleugels? Ik denk zelf dat laatste en zou voor optie 1 gaan.
Maar, ik wil zelf een optie 4 voorleggen. Bij optie 4 houd je volledige flexibiliteit in je Airplane-object en kun je on-the-fly een Airplane maken, of je kunt 'm extenden. Kijk:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<?php
class Airplane {
protected $wings = array();
public function getWingSurface() {
$fSurface = 0.0;
foreach ( $this->wings as $wing ) {
$fSurface += $wing->surface * cos($wing->angle);
}
return round($fSurface, 2);
}
public function addWing(Wing $wing) {
$this->wings[] = $wing;
}
public function getWings() {
return $this->wings();
}
}
class MyCoolAirplane extends Airplane {
public function __construct() {
$this->addWing( new Wing(10, 100) );
$this->addWing( new Wing(10, 100) );
}
}
class MyOtherCoolAirplane extends Airplane {
protected $_leftWing;
protected $_rightWing;
public function __construct() {
$this->_leftWing = new Wing(5, 10);
$this->_rightWing = new Wing(5, 20);
$this->addWing( $this->_leftWing );
$this->addWing( $this->_rightWing );
}
public function getLeftWing() {
return $this->_leftWing;
}
// etc
}
// of on-the-fly:
$plane = new Airplane();
$plane->addWing( new Wing(1, 2) );
$plane->addWing( new Wing(1, 2) );
$plane->addWing( new Wing(1, 2) );
$surface = $plane->getWingSurface();
try {
$plane->fly(); // ik doe maar wat hoor ter illustratie
} catch (FlyException $e) {
echo 'Plane crashed with 3 wings ;)';
}
?>
class Airplane {
protected $wings = array();
public function getWingSurface() {
$fSurface = 0.0;
foreach ( $this->wings as $wing ) {
$fSurface += $wing->surface * cos($wing->angle);
}
return round($fSurface, 2);
}
public function addWing(Wing $wing) {
$this->wings[] = $wing;
}
public function getWings() {
return $this->wings();
}
}
class MyCoolAirplane extends Airplane {
public function __construct() {
$this->addWing( new Wing(10, 100) );
$this->addWing( new Wing(10, 100) );
}
}
class MyOtherCoolAirplane extends Airplane {
protected $_leftWing;
protected $_rightWing;
public function __construct() {
$this->_leftWing = new Wing(5, 10);
$this->_rightWing = new Wing(5, 20);
$this->addWing( $this->_leftWing );
$this->addWing( $this->_rightWing );
}
public function getLeftWing() {
return $this->_leftWing;
}
// etc
}
// of on-the-fly:
$plane = new Airplane();
$plane->addWing( new Wing(1, 2) );
$plane->addWing( new Wing(1, 2) );
$plane->addWing( new Wing(1, 2) );
$surface = $plane->getWingSurface();
try {
$plane->fly(); // ik doe maar wat hoor ter illustratie
} catch (FlyException $e) {
echo 'Plane crashed with 3 wings ;)';
}
?>
Ik hoop dat je hier iets mee kan. Je kunt ook MyOtherCoolAirplane veranderen dat ie niet de constructor gebruikt maar een method setLeftWing() en setRightWing(). Eventueel nog removeWing(Wing $wing) in Airplane.
Gewijzigd op 01/01/1970 01:00:00 door PHP erik
In de methode getWingSurface van de klasse Airplane roep je dan alleen nog per wing hun method getWingSurface aan, en al die resultaten tel je bij elkaar op.
Het idee is dat de Wing klasse zelf beter weet wat zijn oppervlakte is, of hoe hij die moet berekenen dan de Airplane klasse. Nu kun je ook hele vreemde of complexe vleugels toevoegen waarvan de oppervlakte bepaald wordt door meer variabelen dan alleen de oppervlakte (hmm) en hoek.
Jelmer rrrr op 20/11/2008 08:18:00:
Nu kun je ook hele vreemde of complexe vleugels toevoegen waarvan de oppervlakte bepaald wordt door meer variabelen dan alleen de oppervlakte (hmm) en hoek.
LOL :) Hmm indeed.
Betere semantiek was geweest: oppervlak (X) en draagoppervlak (<= X)
Vliegtuig is ondertussen wel neergestort. Leuk om oude berichtjes te lezen though