OOP Set Get etc
Bedankt voor je geduld!
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
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
<?php
class Person {
protected $name;
public function getName() {
return $this->name;
}
public function setName($name) {
$this->name = $name;
}
};
class Woman extends Person {
protected $sex;
function __construct() {
$this->sex = 'Female';
}
public function getSex() {
return $this->sex;
}
};
$persoon = new Woman();
$persoon->setName('Sandra');
echo $persoon->getName();
echo "\n";
echo $persoon->getSex();
?>
class Person {
protected $name;
public function getName() {
return $this->name;
}
public function setName($name) {
$this->name = $name;
}
};
class Woman extends Person {
protected $sex;
function __construct() {
$this->sex = 'Female';
}
public function getSex() {
return $this->sex;
}
};
$persoon = new Woman();
$persoon->setName('Sandra');
echo $persoon->getName();
echo "\n";
echo $persoon->getSex();
?>
Toevoeging op 01/11/2012 14:31:19:
Test en bestudeer dit nog maar eens. Succes!
- SanThe - op 01/11/2012 13:49:55:
Hoi Frank,
Nu je toch duidelijk aan het uitleggen bent. Kun je mischien heel in het kort de verschillen uitleggen tussen public, protected en private?
SanThe.
Nu je toch duidelijk aan het uitleggen bent. Kun je mischien heel in het kort de verschillen uitleggen tussen public, protected en private?
SanThe.
Nu ben ik niet Frank, maar een jaar geleden heb ik dit eens uitgebreid uitgelegd: http://www.phphulp.nl/php/forum/topic/oop-visibility/76673/#541920
Hoe krijg je voor mekaar dat ie * output?
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
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
class Calc
{
private $_input;
private $_input2;
private $_sign;
private $_output;
function setInput($int){
$this->_input = (int) $int;
}
function setInput2($int){
$this->_input2 = (int)$int;
}
function setSign($str){
$this->_sign = $str;
}
function calculate(){
$this->_output = $this->_input . $this->_sign . $this->_input2;
}
function getResult(){
return $this->_output;
}
}
$objCalculate = new Calc();
$objCalculate->setInput(5);
$objCalculate->setInput2(25);
$objCalculate->setSign('*');
$objCalculate->calculate();
echo $objCalculate->getResult();
{
private $_input;
private $_input2;
private $_sign;
private $_output;
function setInput($int){
$this->_input = (int) $int;
}
function setInput2($int){
$this->_input2 = (int)$int;
}
function setSign($str){
$this->_sign = $str;
}
function calculate(){
$this->_output = $this->_input . $this->_sign . $this->_input2;
}
function getResult(){
return $this->_output;
}
}
$objCalculate = new Calc();
$objCalculate->setInput(5);
$objCalculate->setInput2(25);
$objCalculate->setSign('*');
$objCalculate->calculate();
echo $objCalculate->getResult();
Bas D L op 01/11/2012 14:18:32:
Dankjewel! Dan begrijp ik het, nu nog toepassen hahaha.
Zijn daar nog goede vb van of tuts?
Zijn daar nog goede vb van of tuts?
Ik raad je aan nooit publieke properties te gebruiken. Je kan ze vanaf buiten manipuleren zonder dat je er in de klasse controle op hebt. Nu is dat rampzalig: In OO wil je zo flexibel mogelijk scripten. De klasse weet niks van de buitenkant, hoe hij gebruikt wordt wat er verder is, ect. De klasse weet alleen van zijn eigen binnenkant, het is de bedoeling dat je hem zoveel mogelijk controle geeft op zijn eigen binnenkant.
Als ik bijv. een naam van een gebruiker wil instellen dan wil ik zeker zijn dat daar geen vreemde tekens in zitten. Daarvoor gebruik ik een mooie setter:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Alleen als $name nu public was geweest heb ik deze hele controle niet meer!
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$user = new User();
$user->setName('wouter!%$'); // foutmelding
$user->name = 'wouter!$%'; // mag gewoon
?>
$user = new User();
$user->setName('wouter!%$'); // foutmelding
$user->name = 'wouter!$%'; // mag gewoon
?>
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 Calculator
{
public function sumAction(array $numbers)
{
return array_sum($numbers);
}
public function multiplyAction($numbers)
{
$result = 0;
foreach ($numbers as $number) {
$result *= $number;
}
return $result;
}
// ...
public function calculate($action, array $numbers)
{
$method = $action.'Action';
if (method_exists($this, $method)) {
return $this->$method($numbers);
} else {
// actie bestaat niet, geef foutmelding
}
}
}
class Calculator
{
public function sumAction(array $numbers)
{
return array_sum($numbers);
}
public function multiplyAction($numbers)
{
$result = 0;
foreach ($numbers as $number) {
$result *= $number;
}
return $result;
}
// ...
public function calculate($action, array $numbers)
{
$method = $action.'Action';
if (method_exists($this, $method)) {
return $this->$method($numbers);
} else {
// actie bestaat niet, geef foutmelding
}
}
}
Wouter J op 01/11/2012 15:51:33:
@Bas, $this->sign is gewoon een string en dus ziet PHP gewoon een string '5 * 3' en niet de formule 5 * 3. Je kan dit op een erg OO manier doen en voor elke rekenactie een klasse maken die een interface implementeerd, alleen daar mag je denk ik over een paar weken naar kijken. Voor nu zou ik gewoon verschillende methods toevoegen en die aanroepen:
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
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
<?php
class Calculator
{
public function sumAction(array $numbers)
{
return array_sum($numbers);
}
public function multiplyAction($numbers)
{
$result = 0;
foreach ($numbers as $number) {
$result *= $number;
}
return $result;
}
// ...
public function calculate($action, array $numbers)
{
$method = $action.'Action';
if (method_exists($this, $method)) {
return $this->$method($numbers);
} else {
// actie bestaat niet, geef foutmelding
}
}
}
[/quote]
Dit gaat me iets tever, hoe los ik het in mijn scriptje op? Dat probeer ik in eerste instantie te begrijpen...
class Calculator
{
public function sumAction(array $numbers)
{
return array_sum($numbers);
}
public function multiplyAction($numbers)
{
$result = 0;
foreach ($numbers as $number) {
$result *= $number;
}
return $result;
}
// ...
public function calculate($action, array $numbers)
{
$method = $action.'Action';
if (method_exists($this, $method)) {
return $this->$method($numbers);
} else {
// actie bestaat niet, geef foutmelding
}
}
}
[/quote]
Dit gaat me iets tever, hoe los ik het in mijn scriptje op? Dat probeer ik in eerste instantie te begrijpen...
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
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
<?php
public function calculate($action, array $numbers)
{
// alle methods zijn opgebouwd als <handeling>Action
// als we voor $action 'count' meegeven moeten we kijken
// naar een 'countAction' method in deze klasse. Vandaar
// dat we deze string even opslaan in een variabele
$method = $action.'Action';
// voordat we de method kunnen uitvoeren gaan we even kijken
// of deze bestaat, anders krijgen we PHP errors
// de method_exists functie bevat 2 parameters:
// - de klasse, in dit geval gebruiken we $this welke
// verwijst naar de huidige klasse
// - de method waarnaar we zoeken, deze hebben we net
// opgeslagen in de $method variabele
if (method_exists($this, $method)) {
// oke, de method bestaat we kunnen hem gaan aanroepen!
// De $this->$method syntax is een leuke, de $this verwijst
// weer naar de huidige klasse en $method is de method
// die we net aanmaakte. als we 'count' hadden ingevuld
// wordt de method 'countAction' en zullen we hier
// $this->countAction() aanroepen
// Deze method wil als parameter een array met de nummers
// waarmee we rekenen. Deze geven we dus ook mee.
// Als laatste geeft hij een berekening terug en die
// geven we hier in de calculate method nog een keer terug
return $this->$method($numbers);
} else {
// De handeling bestaat niet, we geven een foutmelding
}
}
public function calculate($action, array $numbers)
{
// alle methods zijn opgebouwd als <handeling>Action
// als we voor $action 'count' meegeven moeten we kijken
// naar een 'countAction' method in deze klasse. Vandaar
// dat we deze string even opslaan in een variabele
$method = $action.'Action';
// voordat we de method kunnen uitvoeren gaan we even kijken
// of deze bestaat, anders krijgen we PHP errors
// de method_exists functie bevat 2 parameters:
// - de klasse, in dit geval gebruiken we $this welke
// verwijst naar de huidige klasse
// - de method waarnaar we zoeken, deze hebben we net
// opgeslagen in de $method variabele
if (method_exists($this, $method)) {
// oke, de method bestaat we kunnen hem gaan aanroepen!
// De $this->$method syntax is een leuke, de $this verwijst
// weer naar de huidige klasse en $method is de method
// die we net aanmaakte. als we 'count' hadden ingevuld
// wordt de method 'countAction' en zullen we hier
// $this->countAction() aanroepen
// Deze method wil als parameter een array met de nummers
// waarmee we rekenen. Deze geven we dus ook mee.
// Als laatste geeft hij een berekening terug en die
// geven we hier in de calculate method nog een keer terug
return $this->$method($numbers);
} else {
// De handeling bestaat niet, we geven een foutmelding
}
}
Wouter J op 01/11/2012 15:39:13:
Nu ben ik niet Frank, maar een jaar geleden heb ik dit eens uitgebreid uitgelegd: http://www.phphulp.nl/php/forum/topic/oop-visibility/76673/#541920
Zeer duidelijke uitleg.
Bedankt.
@wouter: mooi voorbeeld. method_exist() heb ik zelf nog nooit gebruikt. Ik sla het op in de denktank
Frank
Maar wouter zijn advies over nooit een public property die ga je wel onthouden toch?
Oja calculate($action, array $numbers) en method_exists($this, $method) ;-)