OOP begrijp er nog weinig van
Na het lezen van een aantal tutorials over OOP ben ik tot de conclusie gekomen dat ik er nog maar weinig van snap (om er iets functioneels mee te doen).
Ik begrijp nog niet helemaal de flexibiliteit van classes. Wanneer ik een object aanmaak dmv $obj = new ding; kan ik dan variabelen meegeven $obj->echo_iets("halloooo"); die ik dan bijvoorbeeld echo dmv een functie binnen een class (even buiten beschouwing nemen of dat handig is of niet).
Ik ben net begonnen maar ik loop hierop stuk en de tutorials geven wat mij betreft te weinig voorbeelden in het gebruik van classes met name het aanroepen van geschreven classes.
Thanks
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
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
<?php
class blaat
{
private $variabele ;
public function __construct()
{
echo "instantie van de class" ;
}
public function setVar($waarde)
{
$this->variabele = $waarde ;
}
public function getVar()
{
return $this->variabele ;
}
}
$blaat = new blaat(); //Hier krijg je de echo
$blaat->setVar("Dit is een test") ; // Hiermee geef je de private var de waarde die je aan je functie mee geeft
echo $blaat->getVar(); // En hiermee haal je hem weer op
?>
class blaat
{
private $variabele ;
public function __construct()
{
echo "instantie van de class" ;
}
public function setVar($waarde)
{
$this->variabele = $waarde ;
}
public function getVar()
{
return $this->variabele ;
}
}
$blaat = new blaat(); //Hier krijg je de echo
$blaat->setVar("Dit is een test") ; // Hiermee geef je de private var de waarde die je aan je functie mee geeft
echo $blaat->getVar(); // En hiermee haal je hem weer op
?>
Dit voorbeeldje duidelijk :)?
@ robin, die heb ik nog niet gezien, thanks.
bv. vierkantswortel(25); zou 5 kunnen weergeven.
Indien je meer returns verwacht, kan je de waarden eerst in een array steken en die array weergeven.
Een class bundelt echter zowel variabelen (properties) als functies (methods), die enkel geassocieerd zijn met die class.
Een object, van een bepaalde class, behoudt zo lang je het nodig hebt alle properties (variabelen binnen een class) die je gezet hebt.
Dat maakt dus dat je een object in verschillende stappen kan opbouwen, terwijl je bij een functie alles in 1 keer moet regelen.
Een class is meer een verzameling van bij elkaar horende functies, die al dan niet achter elkaar uitgevoerd kunnen worden.
Het voordeel van classes ten opzichte van losse functies is dat je altijd de benodigde functies bij elkaar hebt staan in de instantie die je aanmaakt. (met $var = new Classname) Een class "gastenboek" zal alles bevatten (behalve misschien de database connectie) wat je voor je gastenboek nodig hebt. Met uitzondering van de html die terug komt, want dat moet je eigenlijk los definiëren.
De bedoeling van een class is dat je alleen de output teruggeeft, en dat je die in HTML (bijv een template) weergeeft. Een betere scheiding tussen php en html... :)
Wat jij zegt dat je maximum 1 ding terug krijgt is met een class in principe ook zo, je kan functies achter elkaar laten uitvoeren, en deze elke keer wat terug laten geven, maar dat kan op de "andere manier" ook wel..
Als we kijken naar het eerder genoemde voorbeeld van het 'gastenboek', dan zul je er waarschijnlijk snel achter komen dat je voor dat doeleinde met meer dan 1 klasse te maken hebt. Denk bijvoorbeeld aan de klasse 'gastenboek' die het gastenboek zelf voorstelt, maar denk ook aan een klasse/object 'bericht' dat een reactie in het betreffende gastenboek voorstelt. Beide objecten hebben andere eigenschappen en functionaliteiten die in je procedurele code met elkaar verweven worden. Maar daarnaast zou je je kunnen voorstellen dat je de bericht klasse ook nog eens in een andere applicatie (bijv. een forum) kunt gebruiken.
Dit zijn dus de grootste voordelen van het OO programmeren. Je programmeert losse objecten die je later in verschillende applicaties en toepassingen zou kunnen gebruiken.
Volgens mij begint het al te dagen
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
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
<?php
class table_css {
var $column_widths;
function open_css_tablediv($class){
echo "<div class=\"$class\" style=\"width:620px;border:1px solid #000;\"> \n";
}
function open_table_headers($array,$column_widths){
if(!is_array($array)){
echo "Geen array meegegeven in de functie. ";
} else {
for($i = 0;$i < count($array);$i++){
$width = $column_widths[$i];
$value = $array[$i];
echo "<div style=float:left;width=$width>$value</div>\n";
}
}
return $this->column_widths = $column_widths;
}
function show_table_content($array){
if(!is_array($array)){
echo "Geen array meegegeven in de functie. ";
} else {
$nr_columns = count($this->nr_columns);
$column_withs = $this->column_widths;
$ii=0;
for($i = 0;$i < count($array);$i++){
$value = $array[$i];
$width = $column_withs[$ii];
echo "<div style=float:left;width=$width>$value</div>\n";
if($ii == 2) $ii = 0;
else $ii++;
}
}
}
function close_css_tablediv(){
echo "</div>";
}
}
$column_widths = array("300","100","210");
$column_headers = array("kop1","kop2","kop3");
$column_content = array("hallo","ik","ben","sjonnie","en","het","maakt","even","niet","uit","wat dit is");
$table_object = new table_css();
$table_object->open_css_tablediv("hallo");
$nr_columns = $table_object->open_table_headers($column_headers,$column_widths);
$table_object->show_table_content($column_content);
$table_object->close_css_tablediv();
?>
class table_css {
var $column_widths;
function open_css_tablediv($class){
echo "<div class=\"$class\" style=\"width:620px;border:1px solid #000;\"> \n";
}
function open_table_headers($array,$column_widths){
if(!is_array($array)){
echo "Geen array meegegeven in de functie. ";
} else {
for($i = 0;$i < count($array);$i++){
$width = $column_widths[$i];
$value = $array[$i];
echo "<div style=float:left;width=$width>$value</div>\n";
}
}
return $this->column_widths = $column_widths;
}
function show_table_content($array){
if(!is_array($array)){
echo "Geen array meegegeven in de functie. ";
} else {
$nr_columns = count($this->nr_columns);
$column_withs = $this->column_widths;
$ii=0;
for($i = 0;$i < count($array);$i++){
$value = $array[$i];
$width = $column_withs[$ii];
echo "<div style=float:left;width=$width>$value</div>\n";
if($ii == 2) $ii = 0;
else $ii++;
}
}
}
function close_css_tablediv(){
echo "</div>";
}
}
$column_widths = array("300","100","210");
$column_headers = array("kop1","kop2","kop3");
$column_content = array("hallo","ik","ben","sjonnie","en","het","maakt","even","niet","uit","wat dit is");
$table_object = new table_css();
$table_object->open_css_tablediv("hallo");
$nr_columns = $table_object->open_table_headers($column_headers,$column_widths);
$table_object->show_table_content($column_content);
$table_object->close_css_tablediv();
?>
Gewijzigd op 01/01/1970 01:00:00 door sjonnie
Eigenlijk is het inderdaad niet zo gemakkelijk om uit te leggen waarom je in php classes zou gebruiken.
Php is in wezen een sequentiële taal.
Waarvoor dient php? De belangrijkste dingen lijken me
-communiceren met mySQL (lezen, invoegen, updaten)
-een string html opbouwen en in 1 keer "uitbraken" naar de client.
dat maakt dat wat php doet eigenlijk is wat een functie doet, met als parameters (vooral) $_GET, $_POST, $_SESSION.
De object-orientatie is trouwens nog maar deftig ontwikkeld sinds php5. In php4 stelde dat nog niet zo veel voor.
Uitleggen waarom je OO werkt, is veel eenvoudiger als je het bv. over javascript hebt. Javascript is heeeeel erg object georienteerd, hoewel het soms niet zo opvalt, aangezien het woord class er niet in voorkomt.
Dit gezegd zijnde: indien je weet wat OOP is, is het wel aangenaam om OO te werken in php. Uiteindelijk komt het allemaal meer natuurlijk over.
Gewijzigd op 01/01/1970 01:00:00 door Emmanuel Delay