Verschil tussen OOP en nomaal PHP
Ik heb een vraag over OOP en de normale scripting van php.
Wat kan OOP wel dat normale PHP niet kan?
Zijn er andere voordelen van OOP?
Zou iemand mij dit kunnen uitleggen?
Bij voorbaat dank,
Met OOP kan je een klassen maken die je steeds weer kan herbruiken en dus niet steeds weer opnieuw hoeft te schrijven.
Als je alles object geörienteerd script lijkt het alsof je meer code schrijft, maar je kan dit soort dingen veel vaker gebruiken.
Bij OOP zorg je dat een functie (method in OO) of class maar een bepaalde controle heeft. Hiermee zorg je dat je script heel flexibel is en je het vaker kunt hergebruiken.
Als je bijv. ooit een OOP inlog systeem hebt gemaakt voor een Webshop en je moet nu een CMS maken voor een klant, dan kun je heel simpel de inlog classes uit de webshop halen en zo gebruiken in je nieuwe project.
Ook werk je een stuk beter. Want als je alles via classes doet denk je heel goed na over je code. Het voordeel daarvan is dat de logica veel beter in elkaar zit, je script er beter uit ziet en misschien zelfs sneller wordt.
Dat word dus even OOP leren komende tijd.
Bedankt voor jullie nuttige informatie!!!
Groetjes,
Albert de Wit
Doordat OOP zo flexibel is kun je heel snel dingen aanpassen. Stel je voor dat je een CMS systeem in OOP hebt gemaakt op een MySQL database en je komt nu ineens in aanraking met een andere database type. Dan zal je in Flat PHP al je pagina's moeten doorzoeken en eigenlijk je hele scripting moeten aanpassen.
Omdat je in OOP classes de verantwoordelijkheid hebt gegeven om gegevens op te halen en andere classes om iets met die gegevens te doen wordt het een stuk makkelijker. Bijv:
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
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
<?php
class Page
{
protected $title;
protected $content;
// contructor wordt aangeroepen bij het aanmaken van een class
public function __construct( $data )
{
$this->title = $data['title'];
$this->content = $data['content'];
}
public function getTitel()
{
return $this->title;
}
public function getContent()
{
return $this->content;
}
}
// deze class handelt het ophalen van een pagina
class PageMapper
{
protected $db;
public function __construct( PDO $db )
{
$this->db = $db;
}
public static function getById( $id )
{
$sQuery = "SELECT title, content FROM pages WHERE id = ".(int) $id;
$stmt = $this->db->prepare($sQuery);
$stmt->execute();
$data = $stmt->fetch(PDO::FETCH_ASSOC);
return new Page( $data );
}
}
$page = PageMapper::getById(12);
$page->getTitle(); // de titel
$page->getContent(); // de content
?>
class Page
{
protected $title;
protected $content;
// contructor wordt aangeroepen bij het aanmaken van een class
public function __construct( $data )
{
$this->title = $data['title'];
$this->content = $data['content'];
}
public function getTitel()
{
return $this->title;
}
public function getContent()
{
return $this->content;
}
}
// deze class handelt het ophalen van een pagina
class PageMapper
{
protected $db;
public function __construct( PDO $db )
{
$this->db = $db;
}
public static function getById( $id )
{
$sQuery = "SELECT title, content FROM pages WHERE id = ".(int) $id;
$stmt = $this->db->prepare($sQuery);
$stmt->execute();
$data = $stmt->fetch(PDO::FETCH_ASSOC);
return new Page( $data );
}
}
$page = PageMapper::getById(12);
$page->getTitle(); // de titel
$page->getContent(); // de content
?>
Als je nu i.p.v. PDO MySQLi wilt gebruiken hoef je alleen de PageMapper class aan te passen. De Page class hoeft niet te weten hoe de gegevens worden opgehaald en dus kun je dit veel beter aanpassen.
Wat goede OOP tutorials:
- leer eerst OOP met de OOP beginnershandleiding
- ga dan scripten, laat je scripts hier controleren en kijk in het OOP forumdeel naar de topics en lees ze en kijk wat de experts te zeggen hebben en hoe hun code eruit ziet.
- als je OOP goed onder de knie hebt kom je vanzelf op problemen. Dan heb je Design Patterns (bepaalde technieken in OOP) nodig. Ga daar dan over in lezen, het voorbeeld hierboven gebruik het DataMapper pattern.
PS: Je zult van de code hierboven nog niet veel snappen. Maar wees gerust, na het lezen van de OOP beginnershandleiding begrijp je de code, zo moeilijk is de code van OOP niet (aangezien het veel op Flat PHP lijkt).
Gewijzigd op 22/02/2012 12:00:54 door Wouter J
Hartelijk dank voor de link, tips en informatie! Ik ga direct bezig ermee.
Nogmaals bedankt!
Gewijzigd op 22/02/2012 12:06:23 door Albert de Wit
Albert de Wit op 22/02/2012 10:12:31:
Wat kan OOP wel dat normale PHP niet kan?
Niets
Albert de Wit op 22/02/2012 10:19:46:
Ok dus in feite kan ik evenveel met spaghetti php als OOP?
Deze cartoon vind je op php.net, bij de operator goto ( http://php.net/manual/en/control-structures.goto.php )
Deze jongen vraagt zich de zelfde vraag als jij.
Maar serieus ... wat Wouter zegt.
Gewijzigd op 22/02/2012 12:53:47 door Kris Peeters
Toevoeging op 22/02/2012 13:12:21:
Nog 1 vraagje...
wat is het verschil tussen dit:
Code (php)
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
<?php
$jan = new User();
$jan->setUsername('jan');
$inge = new User();
$inge->setUsername('inge');
echo 'Dit script kent twee gebruikers: '.$jan->getUsername().' en '.$inge->getUsername().'.';
?>
$jan = new User();
$jan->setUsername('jan');
$inge = new User();
$inge->setUsername('inge');
echo 'Dit script kent twee gebruikers: '.$jan->getUsername().' en '.$inge->getUsername().'.';
?>
en dit
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
<?php
$jan = 'jan';
$inge = 'inge';
echo 'Dit script kent twee gebruikers: '.$jan.' en '.$inge.'.';
?>
$jan = 'jan';
$inge = 'inge';
echo 'Dit script kent twee gebruikers: '.$jan.' en '.$inge.'.';
?>
Basically groepeer je twee dingen: functies en variabelen.
In plaats van $jan en $piet als losse variabelen bij te houden (Dat zal dan juist hun naam zijn), kan je een object $jan en een ander object $piet bijhouden.
Beide zijn van de class Persoon.
Die objecten kunnen van alles van informatie groeperen
bv.
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$jan->geboortedatum = "1985-05-06"
$jan->leeftijd() // dit zal de leeftijd berekenen, op basis van $jan->geboortedatum
$jan->telefoonnummer = '...';
?>
$jan->geboortedatum = "1985-05-06"
$jan->leeftijd() // dit zal de leeftijd berekenen, op basis van $jan->geboortedatum
$jan->telefoonnummer = '...';
?>
Elk object van de class Persoon heeft alle eigenschappen (= variabele binnen de class) en methodes (= functie binnen een class) van de class Persoon ter beschikking.
Gewijzigd op 22/02/2012 13:28:34 door Kris Peeters
hartstikke bedankt :D
Een object moet je zien als bijv. een persoon, een reactie, een gastenboek, een website pagina, een header, een blog post, enz. Deze hebben ook meerdere varianten, bijv. een admin klasse als uitbouw van de persoon.
Een object heeft meerdere eigenschappen. Een persoon heeft bijv. een naam, een leeftijd en een blog post een titel, author, content, enz. Deze eigenschappen zijn de properties (variabele) van een class.
Elk object kan deze eigenschappen veranderen. De author van een post kan zijn content of titel veranderen en een persoon kan een andere naam krijgen. Deze veranderingen worden uitgevoerd door methods (functies) van een class.
nu snap ik het een stuk beter.
ik dacht al wat men toch met objecten bedoelde met personen.
Als je dat niet doet kan je ook gewoon even goed functie's schrijven.
http://www.amazon.com/PHP-Object-Oriented-Solutions-David-Powers/dp/1430210117
Gewijzigd op 04/04/2012 14:56:23 door Yanick vB
