[TUT: PHP] Klassen, deel 2: Basis uitbreiding

[marcootje]

PHP: Klassen

Deel 2: Basis uitbreiding

Deel 1: De basis

Deel 2: Basis uitbreiding

Deel 3: Klassen in praktijk 1

Deel 4: Klassen in praktijk 2

Introductie

Je vorige site in php werd op een gegeven moment een grote hooiberg. Overal stond code, je wist niet meer waar je moest zoeken. Aanpassingen waren nauwelijks mogelijk, en eigenlijk stond heel veel dubbel in je website, maar net weer een tikkie anders. Deze keer wil je het beter aanpakken, maar hoe?

Hiervoor kun je klassen gebruiken, waarmee je een structuur aanbrengt in je site. Je krijgt aparte klassen voor elk aparte onderdeel, hierbij kun je denken aan klassen voor je database, de gebruiker, de taal, error-handling, het systeem, de layout, etc...

In dit deel van de tutorial ga ik je kennis van deel 1 uitbreiden.

Herhaling

Als je dat nog niet gedaan hebt en nog weinig van klassen afweet, neem dan deel 1 van deze tutorial door!

Benodigde functies en taal-constructies

echo: schrijf iets naar het scherm

Klassen

Je hebt een klasse, maar een instantie daarvoor maken is eigenlijk helemaal niet nodig. Waarom zou je er dan een maken?

Stel, je hebt een klasse met alle eigen functies erin staan. Hiervoor is eigenlijk geen instantie nodig.

Met een Scope Resolution Operator kun in plaats van het pijltje kun je gewoon een klasse gebruiken, zonder hiervan een instantie van te hebben gemaakt.

Voorbeeld

<?php
class voorbeeld {
function zegHoi() {
	echo('hoi');
}
}

voorbeeld::zegHoi();
?>

Hier komt vanzelfsprekend 'hoi' uit. Merk op dat er dus geen variabele/instantie is gemaakt van de klasse!

Inheritance/overerving

Je hebt 2 dieren, een hond en een vogeltje. Ze hebben vergelijkbare eigenschappen (ogen, bek, oren) maar ook verschillende (vleugels, aantal poten, soort vacht). Hiervoor kennen we de term overerving. We hebben 1 algemene klasse voor dieren, en die breiden we uit voor beide de hond en het vogeltje.

Voorbeeld

<?php
class dier {
var $aantal_ogen;
var $aantal_oren;

function __construct($ogen, $oren) {
	$this->aantal_ogen = $ogen;
	$this->aantal_oren = $oren;
}
}

class hond extends dier { // hond heeft dier ge-extend, dus nu is dier de 'parent', en hond het 'kind'
var $aantal_poten = 4; // je kunt de waarde ook hier instellen
var $lengte; // een hond is eerder lang dan hoog

function __construct($ogen, $oren, $lengte) {
	/*
	een parent construct word niet automatisch aangeroepen, dus moet handmatig aangeroepen worden
	parent staat gelijk aan de klasse dier, die hier ge-extend word door hond:
	*/
	parent::__construct($ogen, $oren);

	$this->lengte = $lengte;
}
}

class vogel extends dier {
var $aantal_poten = 2;
var $hoogte; // een vogel is eerder hoog dan lang
var $lengte_vleugels;

function __construct($ogen, $oren, $hoogte, $lengte_vleugels) {
	/*
	een parent construct word niet automatisch aangeroepen,
	dus je kunt de variabelen ook zelf instellen.
	Let wel op dat hier je hier geen parent maar $this gebruikt:
	*/
	$this->aantal_ogen = $ogen;
	$this->aantal_oren = $oren;
	$this->hoogte = $hoogte;
	$this->lengte_vleugels = $lengte_vleugels;
}
}

// lengtes in meter
$hond = new hond(2, 2, 1.57);
$hond = new vogel(2, 2, 0.18, 0.10);
?>

Oefen wat met bovenstaande klassen. Let wel op: in een uitbreidende klasse (hond, vogel) moet je een functie in de parent die dezelfde naam heeft als in het kind aanroepen met 'parent::', zeker als je de parent-construct wilt aanroepen in het kind. Je kan anders namelijk oneindige lussen krijgen!

Zichtbaarheid van variabelen en klassen

Je hebt een variabele in je klasse staan die je eigenlijk alleen vanuit die klasse wil laten benaderen, niet van buitenaf.

Of: je hebt een variabele die je alleen vanuit die klasse, of een uitbreidende klasse wilt laten benaderen.

Hoe doe je dat?

Tot nu toe hebben we variabelen aangeduid met 'var' en functies met 'function'. Dit kan ook anders, er zijn namelijk 3 woorden die allemaal een andere toegankelijkheid geven aan de variabele:

woord:	gebruik in dezelfde instantie van de klasse:	gebruik in uitbreidende klasse:	gebruik ergens anders (andere klasse, of in 'gewone' php):
public	ja	ja	ja
protected	ja	ja	nee
private	ja	nee	nee

Als een variabele of functie dus public is, kun je er vanaf overal bij komen. Met protected kun je er niet bij komen buiten de klasse zelf en kinderen van de klasse (uitbreidingen). Een private kun je alleen benaderen vanuit de klasse zelf.

Deze woorden kunnen zowel bij variabelen als bij functies worden gebruikt:

<?php
class voorbeeld {
public $var_public;
protected $var_protected;
private $var_private;

public function __construct($a) { // in de meeste gevallen moeten de constructor en destructor wel public zijn
	$this->var_public = $a;
	$this->var_protected = $a;
	$this->var_private = $a;

	$this->var_public = 6; // werkt
	$this->var_protected = 6; // werkt
	$this->var_private = 6; // werkt

	$this->func_public(); // werkt
	$this->func_protected(); // werkt
	$this->func_private(); // werkt
}

public function setMyProtectedVar($value) {
	// vanuit deze public functie kun je de protected variabele altijd veranderen!
	$this->var_protected = $value;
}

public function setMyPrivateVar($value) {
	// vanuit deze public functie kun je de private variabele altijd veranderen!
	$this->var_private = $value;
}

public function func_public() {
	echo('public');
}

protected function func_protected() {
	echo('protected');
}

private function func_private() {
	echo('private');
}

}

class voorbeeldKind extends voorbeeld {

function __construct($a) {
	parent::__construct($a);

	$this->var_public = 5; // werkt, de variabele is public
	$this->var_protected = 5; // werkt, de variabele is protected en kan vanuit een kind (uitbreiding/extend) benaderd worden
	$this->var_private = 5; // werkt, maar de variabele wordt aangemaakt in voorbeeldKind, en niet in voorbeeld!!

	$this->func_public(); // werkt, de functie is public
	$this->func_protected(); // werkt, de functie is protected en kan vanuit een kind benaderd worden
	$this->func_private(); // werkt niet, de functie is private en kan niet van buitenaf benaderd worden
}						
}


$vbk = new voorbeeldKind(2);

$vbk->var_public = 3; // werkt, de variabele is public
$vbk->var_protected = 3; // werkt niet, de variabele is protected en kan niet van buitenaf benaderd worden
$vbk->var_private = 3; // werkt niet, de variabele is private en kan niet van buitenaf benaderd worden

// maar:
$vbk->setMyProtectedVar(4); // werkt, functie is public
$vbk->setMyPrivateVar(4); // werkt, functie is public
?>

Hier kun even mee oefenen om het door te krijgen. Let er vooral op dat er 2 manieren zijn om een private variabele te veranderen vanuit een andere omgeving, waarvan er 1 niet werkt en de andere wel!

Er zijn meer termen dan public, protected en private, maar deze 3 zijn het meest gebruikt.

Als je niet aangeeft of een functie public, protected of private moet zijn, wordt hij automatisch public.

In PHP 5 moet je eigenlijk altijd aangeven vanaf waar een variabele benaderd mag worden. Het woordje 'var' voor de variabele in deel 1 komt nog van PHP 4, en dat werkt alleen nog maar door de backwards compatibility van PHP 5 voor PHP 4.

Einde deel 2

Dit was deel 2 van deze tutorial. Deze was wat korter dan deel 1, maar waarschijnlijk ook iets ingewikkelder.

Voor je met deel 3 begint is het handig om met dit deel nog wat te oefenen.

Beoordelingen, correcties en tips zijn welkom!

Bewerkt: 9 augustus 2009 door marcootje

[-Omar-]

, zeker goede tutorial! Ik ben benieuwd naar de "real world" examples in versie drie .