13.1 Wat theorie
Veel programmeurs denken vaak dat ze OOP schrijven als ze gebruik maken van classes (objecten). Maar dit klopt niet geheel OOP wilt meer zeggen dan een gewoon object het is een bepaalde denkwijze die er toe aanzet een mooie structuur te bekomen die achteraf makkelijk uitbreidbaar is.
13.1.1 Eigenschappen
Een object stelt iets voor; neem als voorbeeld een persoon of een pen. Zo kunnen we een rode pen hebben zonder tekst erop en eentje die met zwart inkt schrijft. Maar die zelfde pen kunnen we niet zomaar van kleur laten wijzigen. We zouden hooguit er een verf laagje op kunnen leggen. In dit geval spreken we van 2 objecten die elkaar extenden en dus beinvloeden (aanpassen).
Een object heeft eigenschappen die alleen door zichzelf gewijzigd kunnen worden maar heeft ook eigenschappen die toegelaten zijn te wijzigen al dan niet met de nodige controle erop. Om het allemaal niet te ingewikkeld te maken gaan we nu wat meer praktijk gericht.
13.2 Praktijk gericht
In PHP kunnen we objecten aanmaken, objecten zijn instanties van klassen. Klassen hebben properties en methods. Een simpele klasse in PHP ziet er als volgt uit:
PHP-code:
<?php
class mijnKlasse
{
public $mijnPropertie = 0; //Dit is een property
public function drukAf() //Dit is een method
{
echo $this->var;
}
}
?>
Code:
mijnKlasse::staticMethod();
PHP-code:
<?php
$oVoorbeeld = new mijnKlasse();
?>
PHP-code:
<?php
$oVoorbeeld = new mijnKlasse();
$oNew = $oVoorbeeld; //Beide variabelen verwijzen nu naar dezelfde instantie.
$oNew = clone($oVoorbeeld); //Nu is er een kopie gemaakt.
?>
Er zijn 3 access modifiers in PHP:
- Public: overal bereikbaar
- Private: alleen in de klasse zelf bereikbaar
- Protected: beschikbaar in de klasse zelf en in alle subklasse (extends)
13.2.2 Magic Methods
Er zijn een aantal magic methods in PHP, de namen van magic methods kunnen voor niets anders gebruikt worden.
- __construct(): de constructor, automatische aangeroepen bij het instantieren van een object
- __destruct(): de destructor, automatische aangeroepen bij het afbreken van een object
- __clone(): wordt aangeroepen als het object gekopierd wordt met clone(), deze method wordt alleen in het originele object aangeroepen.
PHP-code:
<?php
mijnKlasse
{
public function __construct()
{
//Aangeroepen bij het instancieren
}
public function __destruct()
{
//Aangeroepen bij het vernietigen
}
public function __clone()
{
//aangeroepen bij clone();
}
}
?>
In PHP kunnen classes uitgebreid worden door ze te ‘extenden’, alle members van de parent-class bestaan ook in de subclasse. In de subklasse kunnen we deze overriden.
PHP-code:
<?php
class mijnKlasse
{
protected $mijnPropertie = 0;
public function drukAf()
{
echo $this->var;
}
}
class uitbreiding extends mijnKlasse
{
// In de klasse uitbreiding bestaan de members van mijnKlasse ook.
}
?>
PHP biedt ook ondersteuning voor interfaces, met een interface kunnen we een specifieke functionaliteit aan een klasse toevoegen, alle members die gedefinierd zijn in de interface moeten door de klasse geimplementeerd worden.
PHP-code:
<?php
class mijnKlasse implements mijnInterface
{
public $mijnPropertie = 0;
public function pasPropertieAan($nieuwewaarde)
{
$this->mijnPropertie = $nieuwewaarde;
}
public function drukAf()
{
echo $this->mijnPropertie;
}
}
interface mijnInterface
{
# Iedere klasse die deze interface implementeerd moet ook de pasPropertiesAan() functie implementeren.
public function pasPropertieAan($nieuwewaarde);
}
?>
Met het keyword final kunnen we vermijden dat bepaalde methods overriden worden door subklasse, een final class kan niet meer uitgebreid worden (extends), ze is final.
PHP-code:
<?php
class mijnKlasse
{
public $mijnPropertie = 0;
final public doeiets()
{
}
public function drukAf()
{
echo $this->var;
}
}
class uitbreiding extends mijnKlasse
{
public doiets() {} // Fout, mag niet (is final)
public function drukAf()
{
echo 'waarde: '.$this->var;
}
}
?>
Een klasse is abstract wanneer hij nog abstracten methods bevat, we kunnen geen instantie aanmaken van een abstracte klasse, we kunnen ze alleen als parent-class gebruiken.
PHP-code:
<?php
abstract class mijnKlasse
{
public $mijnPropertie = 0;
abstract public function drukAf();
}
$oNew = new mijnKlasse( ); // Werkt niet
?>
Met het keyword ‘instanceof’ kunnen we controleren of een object een instantie is van een bepaalde klasse:
PHP-code:
<?php
$oNew = new mijnKlasse( ); //Werkt niet
if($oNew instanceof mijnKlasse)
echo ‘Instantie van mijnKlasse’;
?>
PHP-code:
<?php
class mijnKlasse
{
public static $mijnPropertie = 0;
public $test;
public static function drukAf()
{
$var = $this->test; //Fout
$var = $this->mijnPropertie; //Fout
$var = mijnKlasse::mijnPropertie; //juist
}
}
$oNew = new mijnKlasse();
$oNew->test = ‘Hallo’; //Goed
$oNew->drukAf(); //Fout
$mijnKlasse::drukAf(); //Goed
?>
In PHP kunnen we eisen dat bepaalde parameters een instantie zijn van een bepaalde klasse.
PHP-code:
<?php
class mijnKlasse
{
public $mijnPropertie = 0;
public function drukAf(mijnKlasse $a)
{
echo $a->mijnPropertie;
}
}
?>
Code:
public function drukAf(array $a) { }
Aanpassingen door: Aerts Kurt.