Waarom OO?!
Ja, ik zie het voordeel van Object oriented programmeren. Maar ik zie niet waarom ik Classes moet gebruiken. Nu heb ik in de tijd dat ik van OO afweet in PHP tot nog toe nooit een echt groot project gehad waarvan ik zeg dat OO echt nodig is.
Nu ben ik echter bezig met een tool, waarbij ik echt volgens mij doen al OO werk, maar niet het voordeel zie van Classes etc...
Als ik dan zoek naar Waarom OO? krijg ik het antwoord "omdat je bepaalde functies kan her gebruiken" Dan kom ik eigenlijk tot de conclusie dat ik al OO denk wanneer ik bijvoorbeeld een centraal bestand heb met daarin functions die ik dus hergebruik.
Ook omdat ik bijvoorbeeld voor een inlog scherm al het bestand inlog.php include. (ik noem maar wat)en die aanpas als er wat moet gebeuren...
Nu ben ik dus niet opzoek waarom OO, maar ik ben eigenlijk opzoek die bij mij de knop kan omzetten om OO te gaan programmeren met de bijbehorende objecten, classes etc.
Ik kom ook nooit uit het voorbeeld van de auto... Boeiend dat deze blauw moet zijn...
Graag hoor ik het ook als ik echt compleet de bus mis en bovenstaande kant noch wal raakt.. Ik probeer bij mij zelf die knop om te zetten....
Henk Van der Plas op 27/11/2013 15:45:17:
Nu is deze vraag al waarschijnlijk 100 keer gesteld. Maar ik krijg het er bij mij zelf niet in waarom ik OO moet gaan gebruiken.
Niets moet. Lijkt een dooddoener, maar wel de werkelijkheid. Als jij de voordelen niet ziet, dan zijn ze er blijkbaar niet (voor jou in elk geval). OO is niet de heilige graal die alles makkelijker of beter maakt. In tegendeel in veel gevallen
Henk Van der Plas op 27/11/2013 15:45:17:
Ja, ik zie het voordeel van Object oriented programmeren. Maar ik zie niet waarom ik Classes moet gebruiken.
...
Nu ben ik echter bezig met een tool, waarbij ik echt volgens mij doen al OO werk, maar niet het voordeel zie van Classes etc...
...
Nu ben ik echter bezig met een tool, waarbij ik echt volgens mij doen al OO werk, maar niet het voordeel zie van Classes etc...
Lijkt me een contradictio in terminis. Classes gebruiken, maar niet OO is mogelijk, andersom heb ik het nog nooit gezien. Als je dus OO gebruikt, dan gebruik je classes. Gebruik je geen classes, dan is je applicatie ook niet OO.
Erwin H op 27/11/2013 15:50:17:
Lijkt me een contradictio in terminis. Classes gebruiken, maar niet OO is mogelijk, andersom heb ik het nog nooit gezien. Als je dus OO gebruikt, dan gebruik je classes. Gebruik je geen classes, dan is je applicatie ook niet OO.
Mijn inziens is het OO, niet omdat ik classes gebruik, maar omdat ik bepaalde onderdelen toch al weet her te gebruiken? Maar daarom zeg ik het ook. Die knop moet om waarom ik classes zou moeten gebruiken in plaats van functies.
Misschien ligt mijn denkbeeld van OO helemaal verkeerd en zit ik mis met OO is dat ik dingen hergebruik, ik kan een functie schrijven die e-mail voor mij verstuurd in een bepaalde opmaak. Nu heb ik van het internet een stukje "geleend" dat OO is (manier van schrijven) waarbij ik het zelfde e-mailtje kan versturen...
Is het dan in eens OO omdat het op die manier geschreven is? Of is OO niet de manier van programmeren, maar het hergebruiken van het stukje programmeer werk...
Ik bouw een object, mail versturen. Hoe die mail verstuurd wordt is irrelevant, zolang ik maar het zelfde mail versturen 5 pagina's verder weer kan gebruiken. EN als er wat aangepast moet worden dat ik het niet op pagina 1 en op 5 moet aan passen, maar op een plaats voor beide momenten dat je het gebruikt.
R van der Meer op 27/11/2013 16:00:40:
Mijn inziens is het OO, niet omdat ik classes gebruik, maar omdat ik bepaalde onderdelen toch al weet her te gebruiken?
Het feit dat je iets herbruikt heeft natuurlijk helemaal niets met OO te maken. Ik kan 1 regel code schrijven die 'hoi' naar het scherm stuurt, dit in een php bestand plaatsen en dat bestand dan te pas en te onpas includen. Dan herbruik ik code, maar het heeft natuurlijk geen bal te maken met OO.
OO (Object Oriented) gaat uit van het gebruiken van objecten die zelfstandig kunnen opereren. Die objecten kunnen binnen hun eigen verantwoordelijkheid beslissingen nemen, validatie toepassen en er zorg voor dragen dat bepaalde functionaliteit correct wordt uitgevoerd. Het is niet een functie 'die iets doet', maar een op zich zelfstaand onderdeel van je applicatie. Dit onderdeel kan je vervolgens ergens anders ook weer gebruiken. Het herbruiken van de code is echter een voordeel, niet een kenmerk.
Daarnaast is nog een enorm belangrijk onderdeel dat elke functionaliteit altijd maar op 1 plek in je code wordt gedefinieerd. Je hebt dus bijvoorbeeld 1 validatie class die alle validatie (voor een bepaald type) doet. Die class gebruik je overal en altijd waar je die validatie nodig hebt.
En zo verder, en zo verder.
Gewijzigd op 27/11/2013 16:46:01 door Erwin H
Mooi. Dan probeer ik die gedachte over boord te gooien.
Maar als ik het dan betrek op een systeem waarbij ik gebruikers ga hebben en die moet aanmaken. Ik kan een functie schrijven die aangeroepen wordt na het verzenden van een formulier. Laten we die functie "nieuwe-gebruiker" noemen.
"nieuwe-gebruiker" bestaat uit het opslaan van de gegevens in de database en een e-mail naar deze nieuwe gebruiker toe te sturen.
Stel ik wil dat in objecten/classes onderbrengen. Ben ik dan op de juiste wijze aan het denken? Dat ik niet de functie aanroep, maar het object.
Waarbij ik dus een toevoeging doe aan de database. EN een mail stuur.
Ik zou dan twee objecten moeten maken.
"toevoegen" en "versturen"
Waarbij ik bijvoorbeeld het zelfde "versturen" weer kan gebruiken als ik een e-mail wil versturen bij een nieuw bericht (ik schud het nu even uit de mouw)
Alleen die hele e-mail heeft een totaal andere opmaak... Hoe verwerk ik dat dan?
Het "toevoegen" kan ook weer gebruikt worden, alleen dan in een andere tabel (berichten) met andere inhoud...
In OOP is een object een entiteit, bijvoorbeeld een gebruiker, bijvoorbeeld een mailer, bijvoorbeeld een database, etc. Elk object heeft properties (de mailer kan bijvoorbeeld het property afzender hebben) en functionaliteiten (ook wel methodes genoemd in OOP). 'versturen' en 'toevoegen' zijn dus geen objecten, maar methodes van objecten.
Met je nieuwe gebruiker voorbeeld kan je dus een gebruiker object hebben (met alle kenmerken van de gebruiker), een database object (dat de data in de database toevoegt, of opslaat) en een mailer (dat de mail kan versturen).
En dit is een zeer versimpeld voorbeeld. Alleen je database object zal in het echt al minimaal uit 3 objecten bestaan (database-, connectie- en queryobject), maar al snel nog meer. Bedenk ook dat elk object uiteindelijk maar verantwoordelijk mag zijn voor 1 onderdeel van je applicatie. Je kan dus niet een mailer hebben die ook de content van de emails bepaalt. In dat geval krijg je namelijk al een probleem met het opnieuw gebruiken van dat object, want in een volgende applicatie zijn de mails heel anders.
Gewijzigd op 27/11/2013 17:01:02 door Erwin H
Ik raad je aan eens rustig mijn tut door te lezen om een gevoel te krijgen voor objecten: http://wouterj.nl/2012/05/oo/nadenken-in-objecten/
Php is niet de ideale taal wenneer je het nut van OOP wil uitleggen.
Vooral dan omdat php een verzoek regelt in 1 ogenblik (een aantal microseconden).
Beeld je even in dat je de zelfde vraag stelt, maar dan met een andere taal, bv. C++, C#, Java, ... om een applicatie (een GUI, een windows proggramma, ...) te maken.
Daar heb je een programma dat blijft draaien.
De variabelen blijven actief zolang het programma draait.
We maken een windows programma waarmee we een auto samenstellen. Voor het gemak gebruik ik php notatie.
Vanaf het programma wordt gestart wordt dit uitgevoerd:
$auto = new Auto();
Een minuut later heeft de gebruiker een kleur (van lak) gekozen.
Dan wordt dit uitgevoerd:
$auto->setColor('red');
Nog een minuut later kiest de gebruiker de cilinderinhoud
$auto->setCC(2200);
Snap je dat het in deze situatie handig is dat we 1 variabele hebben: $auto.
Alle eigenschappen van die auto worden verzameld in die ene variabele. -> dat zijn de eigenschappen of properties.
En niet alleen de eigenschappen, maar ook alle mogelijkheden; -> dat zijn de functies of de methods.
In php vallen sommige voordelen minder op, omdat alles sowieso in 1 ruk gebeurt.
Maar je snapt ook wel hoe dit begonnen is: programmmeurs uit een c++ of JAVA achtergrond beginnen php te scripten en denken: ik wil ook OOP kunnen gebruiken in php.
De rest is geschiedenis.
Wouter J op 27/11/2013 17:00:23:
Sinds wanneer is versturen een object?
Dit soort reacties vind ik zo vreemd. Ik geef bovenstaand aan dat ik op een bepaalde manier zie, op een gegeven moment na 3/4 antwoorden lees ik dat mijn denk manier verkeerd is wat betreft OO. Komt er iemand door de bocht met "Sinds wanneer is versturen een object?"
Ik kom net tot de conclusie dat ik verkeerd denk, dat jij begrijpt wat er bedoeld word vind ik super. Maar je kunt het ook normaal omschrijven, zoals je wel op je website doet. EN ja ik heb die post op je website gelezen. En waarschijnlijk lees ik het nog 5 keer puur alleen om nu een schakel in mijn hoofd om te zetten.
Op je website zet je neer "artikel" is een object. Vandaar dat ik dacht dat e-mail ook een object is (welke ik boven aanduid met "verstuur" is dat een verkeerde woord keuze van mij. Maar begrijp ik het dan goed als ik jouw pagina gebruik dat e-mail wel een object is?
Erwin H op 27/11/2013 16:59:57:
Met je nieuwe gebruiker voorbeeld kan je dus een gebruiker object hebben (met alle kenmerken van de gebruiker), een database object (dat de data in de database toevoegt, of opslaat) en een mailer (dat de mail kan versturen).
En dit is een zeer versimpeld voorbeeld. Alleen je database object zal in het echt al minimaal uit 3 objecten bestaan (database-, connectie- en queryobject), maar al snel nog meer. Bedenk ook dat elk object uiteindelijk maar verantwoordelijk mag zijn voor 1 onderdeel van je applicatie. Je kan dus niet een mailer hebben die ook de content van de emails bepaalt. In dat geval krijg je namelijk al een probleem met het opnieuw gebruiken van dat object, want in een volgende applicatie zijn de mails heel anders.
En dit is een zeer versimpeld voorbeeld. Alleen je database object zal in het echt al minimaal uit 3 objecten bestaan (database-, connectie- en queryobject), maar al snel nog meer. Bedenk ook dat elk object uiteindelijk maar verantwoordelijk mag zijn voor 1 onderdeel van je applicatie. Je kan dus niet een mailer hebben die ook de content van de emails bepaalt. In dat geval krijg je namelijk al een probleem met het opnieuw gebruiken van dat object, want in een volgende applicatie zijn de mails heel anders.
Even ter illustratie voor mij;
Op plek A heb ik het object "mailer" welke de mail verzend.
Op plek B wil ik een mail versturen.
Op plek B zeg ik wat de mail moet zijn. EN dan verstuur ik door middel van de "mailer" de e-mail. Die dus alleen de e-mail voor mij verzend.
Op plek Z wil ik weer een mail sturen, maar dan met inhoud die anders is. Dan staat op Z mijn content en roep ik A aan?
@Kris Peeters
27/11/2013 17:36:54
Dit heb ik op het moment van posten van dit bericht nog niet gelezen (wel gezien)
--- Reactie op Kris Peeters ---
Zie ik het dan goed dat als ik jouw voorbeeld uitbreid met
$auto->setDeuren(4);
ik waar dan ook in mijn script kan zeggen dat mijn auto 4 deuren heeft (moet dat dan via $auto-setDeuren; ?)
Maar ook als ik dan naar een andere pagina ga?
En geldt het dan ook dat ik bijvoorbeeld ook iets nieuws kan toevoegen wat helemaal niet in het object auto zit? Bijvoorbeeld $auto->setToetsenbord(tekst);?
Gewijzigd op 27/11/2013 17:45:41 door R van der Meer
Die werkwoorden zijn de methods (functies) van een object. En om wille van herbruikbaarheid worden deze vaak ook in een klasse gezet. We hebben dan in jouw geval dus een Email object. Deze email wordt verstuurd, een ->send() functie dus. Maar omdat we niet afhankelijk willen zijn van 1 verzend methode (bijv. via de stmp server) plaatsen we deze ook in een object. We hebben nu dus een Email object en een StmpMailer object die die Email verzend.
Een object moet altijd een enkelvoudig zelfstandig naamwoord zijn. Dus de class naam Mail is beter dan de naam Mails
Verder is het ook weer niet goed als je te algemene klassen maakt. Een gastenboek dat werkt op 1 klasse, is niet juist OO gebruik.
Je hebt hier te maken met heel veel verschillende dingen, die aparte taken hebben.
Bij een gastenboek heb je bijvoorbeeld het formulier, de input checks, de verwerking, de database etc.
Van alleen al een formulier zou je makkelijk 10 klasses kunnen maken.
Een klasse voor elk HTML input element, een klasse voor het formulier algemeen, etc.
Als je dit goed doet, kun je de form klassen ook weel makkelijk hergebruiken om een contact formulier te maken of een ander formulier.
Je hoeft eigenlijk nooit zuinig te zijn met het maken van klassen.
Als je echt goed OO wilt kunnen, zou jet het beste Java kunnen leren (Java is niet Javascript)
Dan wordt je gedwongen om alles OO te doen.
Gewijzigd op 27/11/2013 18:30:40 door Mark Hogeveen
R van der Meer op 27/11/2013 17:41:33:
... ik waar dan ook in mijn script kan zeggen dat mijn auto 4 deuren heeft (moet dat dan via $auto-setDeuren; ?)
Maar ook als ik dan naar een andere pagina ga?
Maar ook als ik dan naar een andere pagina ga?
Wel, dat is net het probleem dat ik aankaart.
Bij php is elke pagina een afgezonderd verzoek.
Dus, als de gebruiker naar een andere pagina gaat, of op F5 drukt, moet php het object helemaal opnieuw opbouwen.
Bij mijn verhaal van het windows programma zou het wel gelden.
Daar kan die ene variabele (object) minuten lang (zelfs langer) al zijn eigenschappen bewaren, en kan je gelijk wanneer eigenschappen toevoegen.
R van der Meer op 27/11/2013 17:41:33:
... ook iets nieuws kan toevoegen wat helemaal niet in het object auto zit? Bijvoorbeeld $auto->setToetsenbord(tekst);?
Hier moet ik ook verwijzen naar de laatste reactie van Harry:
De klasse bepaalt welke eigenschappen en methoden zijn toegelaten. De klasse is een blauwdruk van een object.
Een object is een instance van een klasse.
Dus, als setToetsenbord() niet in de klasse Auto staat, mag het object $auto die functie niet gebruiken.
Harry hogeveen op 27/11/2013 18:29:45:
Een object moet altijd een enkelvoudig zelfstandig naamwoord zijn.
"Moet" is een groot woord. Je kunt bijvoorbeeld een class hebben waarin je je paden opslaat. Deze class kun je dan Paths noemen.
Wouter J op 27/11/2013 17:48:18:
Het was niet lullig of kort door de bocht bedoelt, R.
Ok, thanks. Het kwam alleen zo over van.. Goh, wat een noob. Normaal gesproken red ik mij prima in de PHP wereld, alleen deze drempel komt er bij mij niet in, waardoor ik toch denk een hoop leuke dingen te missen..
Harry hogeveen op 27/11/2013 18:29:45:
Bij een gastenboek heb je bijvoorbeeld het formulier, de input checks, de verwerking, de database etc.
Van alleen al een formulier zou je makkelijk 10 klasses kunnen maken.
Van alleen al een formulier zou je makkelijk 10 klasses kunnen maken.
Maak ik dan een klasse aan voor bijvoorbeeld het checken van een telefoonnummer (mobiel) die alleen controlleert of een 06 nummer daadwerkelijk ook strat met 06 ( en voor andere landen bijvoorbeeld 049 gebruikt als een bepaalde voorwaarde waar is)?
Harry hogeveen op 27/11/2013 18:29:45:
Als je echt goed OO wilt kunnen, zou jet het beste Java kunnen leren (Java is niet Javascript)
Dan wordt je gedwongen om alles OO te doen.
Dan wordt je gedwongen om alles OO te doen.
Een collega van mij kaartte dit al aan inderdaad. Die heeft vroeger veel Java gebruikt en kan alleen de link met PHP niet uitleggen, vandaar dat ik vandaag op zoek ging naar "het" antwoord.
Ozzie PHP op 27/11/2013 20:20:05:
"Moet" is een groot woord. Je kunt bijvoorbeeld een class hebben waarin je je paden opslaat. Deze class kun je dan Paths noemen.
Harry hogeveen op 27/11/2013 18:29:45:
Een object moet altijd een enkelvoudig zelfstandig naamwoord zijn.
"Moet" is een groot woord. Je kunt bijvoorbeeld een class hebben waarin je je paden opslaat. Deze class kun je dan Paths noemen.
Maar als ik het goed begrijp klopt de uitleg van Harry juist wel. De class Path is in zekere zin wel juist, alleen is het zo dat deze meerdere "wegen" kan bevatten.
Want je zegt ook niet "cars" omdat de auto's meerdere kleuren kunnen hebben. De input is variabel, maar het gene wat er mee gebeurt is het zelfde.
ALS ik het goed begrijp..
*verder gaat lezen*
Allemaal wel erg veel bedankt! Denk dat ik er meer van opsteek als ik gewoon (domme) vragen kan stellen.
Gewijzigd op 27/11/2013 21:01:11 door R van der Meer
Want je zegt ook niet "cars" omdat de auto's meerdere kleuren kunnen hebben. De input is variabel, maar het gene wat er mee gebeurt is het zelfde."
Nee, een "Car" object bevat daadwerkelijk slechts 1 auto. Een Paths class bevat meer dan 1 pad. Je zou het ook een PathCollection kunnen noemen, maar persoonlijk vind ik dat nogal lang.
$pathto['imgages'];
waarbij images => 'path/naar/de/afbeelding/vanaf/relatief/ofzo/' in de array geplaatst wordt door een while loop op een db query.
$this->services->get('paths')->get('image');
Quote:
Maak ik dan een klasse aan voor bijvoorbeeld het checken van een telefoonnummer (mobiel) die alleen controlleert of een 06 nummer daadwerkelijk ook strat met 06 ( en voor andere landen bijvoorbeeld 049 gebruikt als een bepaalde voorwaarde waar is)?
Even een voorbeeldje.
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
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
<?php
class phoneNumber {
private $number;
public function __construct($number) {
$this->number = $number;
}
public function validate() {
// kijk of de gegeven waarde geen float(10.5) is en wel een integer (1234)
if(is_numeric($this->number) && !(strpos($this->number, "."))) {
$this->number = intval($this->number);
}
if(!is_int($this->number)) {
throw new InvalidArgumentException('Gebruiker heeft geen integer ingevoerd: ' . $this->number);
return false;
}
// check of dit nummer uit 10 cijfers bestaat. > 9 omdat 0 niet meegeteld wordt ( ik ben geen regex expert)
elseif(!(preg_match('/^\d{9}$/', $this->number))) {
throw new LengthException('Nummer voldoet niet aan de nederlandse notatie: ' . $this->number);
return false;
}
else {
return true;
}
}
}
$number = new phoneNumber(0613266263);
echo $number->validate();
?>
class phoneNumber {
private $number;
public function __construct($number) {
$this->number = $number;
}
public function validate() {
// kijk of de gegeven waarde geen float(10.5) is en wel een integer (1234)
if(is_numeric($this->number) && !(strpos($this->number, "."))) {
$this->number = intval($this->number);
}
if(!is_int($this->number)) {
throw new InvalidArgumentException('Gebruiker heeft geen integer ingevoerd: ' . $this->number);
return false;
}
// check of dit nummer uit 10 cijfers bestaat. > 9 omdat 0 niet meegeteld wordt ( ik ben geen regex expert)
elseif(!(preg_match('/^\d{9}$/', $this->number))) {
throw new LengthException('Nummer voldoet niet aan de nederlandse notatie: ' . $this->number);
return false;
}
else {
return true;
}
}
}
$number = new phoneNumber(0613266263);
echo $number->validate();
?>
In het voorbeeldje hierboven zie je dat dit werkt voor de nederlandse manier. maar wat als je nu een systeem nodig hebt die kan checken voor zowel een Nederlandse, Buitenlandse 1, Buitenlandse 2, Buitenlandse 3.. tsja dan stel je natuurlijk een contract op waarbij je klasses dwingt om op een bepaalde manier nummers te gaan controleren Hoe die klasses dat doen? dat mogen ze zelf weten. als ze maar wel de benodigde methoden implementeren. Wat je nu kan doen hiervoor is een interface gebruiken ( alleen methoden declareren ) of een abstracte klasse maken waarbij je de validate methode als abstract declareert en deze door de klassen die deze abstracte methode overerven het validate gedeelte doen.
Hier geef ik je de tip om wanneer mogelijk een interface te gebruiken omdat je waar mogelijk moet programmeren naar een interface en niet naar een implementatie toe.
Wat onze code nu dus kan worden is
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
<?php
interface phoneNumber {
public function validate();
}
class dutchPhoneNumber implements phoneNumber{
private $number;
public function __construct($number) {
$this->number = $number;
}
public function validate() {
// kijk of de gegeven waarde geen float(10.5) is en wel een integer (1234)
if(is_numeric($this->number) && !(strpos($this->number, "."))) {
$this->number = intval($this->number);
}
if(!is_int($this->number)) {
throw new InvalidArgumentException('Gebruiker heeft geen integer ingevoerd: ' . $this->number);
return false;
}
// check of dit nummer uit 10 cijfers bestaat. ( regex niet getest )
elseif(!(preg_match('/^\d{10}$/', $this->number))) {
throw new LengthException('Nummer voldoet niet aan de nederlandse notatie: ' . $this->number);
return false;
}
else {
return true;
}
}
}
class germanPhoneNumber implements phoneNumber{
private $number;
public function __construct($number) {
$this->number = $number;
}
public function validate() {
// kijk of de gegeven waarde geen float(10.5) is en wel een integer (1234)
if(is_numeric($this->number) && !(strpos($this->number, "."))) {
$this->number = intval($this->number);
}
if(!is_int($this->number)) {
throw new InvalidArgumentException('Gebruiker heeft geen integer ingevoerd: ' . $this->number);
return false;
}
// hier kijken we of er 11 cijfers voorkomen. ( regex niet getest )
elseif(!(preg_match('/^\d{11}$/', $this->number))) {
throw new LengthException('Nummer voldoet niet aan de duitse notatie: ' . $this->number);
return false;
}
else {
return true;
}
}
}
$number = new dutchPhoneNumber(06123456789);
echo $number->validate();
$number = new germanPhoneNumber(06123456789);
echo $number->validate();
?>
interface phoneNumber {
public function validate();
}
class dutchPhoneNumber implements phoneNumber{
private $number;
public function __construct($number) {
$this->number = $number;
}
public function validate() {
// kijk of de gegeven waarde geen float(10.5) is en wel een integer (1234)
if(is_numeric($this->number) && !(strpos($this->number, "."))) {
$this->number = intval($this->number);
}
if(!is_int($this->number)) {
throw new InvalidArgumentException('Gebruiker heeft geen integer ingevoerd: ' . $this->number);
return false;
}
// check of dit nummer uit 10 cijfers bestaat. ( regex niet getest )
elseif(!(preg_match('/^\d{10}$/', $this->number))) {
throw new LengthException('Nummer voldoet niet aan de nederlandse notatie: ' . $this->number);
return false;
}
else {
return true;
}
}
}
class germanPhoneNumber implements phoneNumber{
private $number;
public function __construct($number) {
$this->number = $number;
}
public function validate() {
// kijk of de gegeven waarde geen float(10.5) is en wel een integer (1234)
if(is_numeric($this->number) && !(strpos($this->number, "."))) {
$this->number = intval($this->number);
}
if(!is_int($this->number)) {
throw new InvalidArgumentException('Gebruiker heeft geen integer ingevoerd: ' . $this->number);
return false;
}
// hier kijken we of er 11 cijfers voorkomen. ( regex niet getest )
elseif(!(preg_match('/^\d{11}$/', $this->number))) {
throw new LengthException('Nummer voldoet niet aan de duitse notatie: ' . $this->number);
return false;
}
else {
return true;
}
}
}
$number = new dutchPhoneNumber(06123456789);
echo $number->validate();
$number = new germanPhoneNumber(06123456789);
echo $number->validate();
?>