Inheritance

Een van de onderwerpen waar de grote kracht van OOP naar voren komt, is inheritance (overerving). Inheritance is het principe waarbij classes uitgebreid (extend) kunnen worden door een nieuwe class (child) te schrijven die de eigenschappen van de oorspronkelijke class (parent) erft. Het resulterende object van een child class heeft alle eigenschappen van de parent class plus de nieuw gedefinieerde eigenschappen van de child class.

Wanneer is extenden toegestaan?
Voordat we verder gaan wil ik je aandacht vestigen op de belangrijkste regel als het gaat om extenden van classes. Je kunt namelijk alleen een child class 'X' van de parent class 'Y' aanmaken als je kunt zeggen 'elke X is een Y'. Zo zou Premium_User een child van de parent User kunnen zijn omdat je kunt zeggen 'elke Premium_User is een User'. Andersom daarentegen kan nooit, want je kunt niet zeggen 'elke User is een Premium_User'.

Correcte voorbeelden:

- MySQL extends Database -> kan, MySQL is een type database
- Mens extends Dier -> kan, ieder mens is een dier
- Dier extends Organisme -> kan, ieder dier is een organisme
- Mens extends Organisme -> kan ook, ieder mens is immers een organisme


Incorrecte voorbeelden:

- Query extends MySQL -> kan niet, een query is geen database!
- Dier extends Konijn -> kan niet, niet ieder dier is een konijn!


De code
Zoals je misschien al vermoedde (of in het hoofdstuk over Visibility gezien hebt), extenden doe je met het 'extends' keyword. Laten we onze User class er weer eens bij pakken:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class User {
    protected $_username;

      public function __construct($name) {
        $this->_username = $name;
    }

    public function getUsername() {
        return $this->_username;
    }
}
?>

Merk op dat de visibility van de property $_username veranderd is naar 'protected'. We gaan deze class uitbreiden en we willen deze variabele vanuit de child class kunnen benaderen en manipuleren.

Stel nu dat we voor een webshop de class Customer nodig hebben. Iedere klant is een gebruiker van de webshop, we kunnen de User class dus extenden en zo de Customer class maken. Iedere klant heeft een eigen klantnummer, iets dat een gebruiker niet per se hoeft te hebben. Dat is dus een specifieke eigenschap van de klant en dus een property van de Customer class.
Code (php)
PHP script in nieuw venster Selecteer het PHP script
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
<?php
class User {
    protected $_username;

      public function __construct($name) {
        $this->_username = $name;
    }

    public function getUsername() {
        return $this->_username;
    }
}

class Customer extends User {
    private $_customerId;
    
    public function __construct($username, $customerId) {
        $this->_username = $username;
        $this->_customerId = $customerId;
    }
}

$customer = new Customer('jan', 1);
echo $customer->getUsername();
?>
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
jan

De nieuwe class Customer heeft een property $customerId en de constructor van deze class initialiseert zowel de property van de child class als die van de parent User class. Tevens zien we dat we het Customer object $customer kunnen gebruiken om methods uit de parent class aan te roepen. Dit laat zien dat het child object de eigen eigenschappen heeft maar ook de eigenschappen van de parent class zonder dat we daar extra regels code voor hoeven toe te voegen aan de child class.

Dit is een klassiek voorbeeld van hoe OOP het benodigd aantal regels code kan reduceren, dezelfde methods hoeven niet telkens opnieuw geschreven te worden.

Methods overschrijven
Soms komt het voor dat je bestaande methods uit de parent class wilt overschrijven in de child class. Met andere woorden, je wilt een andere werking toekennen aan een bepaalde method. Dit doe je heel eenvoudig door een method met dezelfde naam als die in de parent class, te definiëren in de child class.
Code (php)
PHP script in nieuw venster Selecteer het PHP script
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
<?php
class User {
    protected $_username;

      public function __construct($name) {
        $this->_username = $name;
    }

    public function getUsername() {
        return $this->_username;
    }
}

class Customer extends User {
    private $_customerId;
    
    public function __construct($username, $customerId) {
        $this->_username = $username;
        $this->_customerId = $customerId;
    }
    
    public function getUsername() {
        return 'De gebruikersnaam is: '.$this->_username;
    }
}

$customer = new Customer('jan', 1);
echo $customer->getUsername();
?>
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
De gebruikersnaam is: jan

We zien dat hier de method uit de Customer class uitgevoerd wordt en dat er een uitgebreidere string geretourneerd wordt.

Methods uit de parent class uitvoeren
Bij het overschrijven van methods kan het in sommige gevallen voorkomen dat je toch de oorspronkelijke method uit de parent class uit wilt voeren. Dat kun je doen door het 'parent' keyword te gebruiken.
Code (php)
PHP script in nieuw venster Selecteer het PHP script
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
<?php
class User {
    protected $_username;

      public function __construct($name) {
        $this->_username = $name;
    }

    public function getUsername() {
        return $this->_username;
    }
}

class Customer extends User {
    private $_customerId;
    
    public function __construct($username, $customerId) {
        $this->_username = $username;
        $this->_customerId = $customerId;
    }
    
    public function getUsername() {
        if($this->_username == 'jan') {
            return parent::getUsername();
        }
        else {
            return 'De gebruikersnaam is: '.$this->_username;
        }
    }
}

$jan = new Customer('jan', 1);
$inge = new Customer('inge', 2);

echo $jan->getUsername(). '<br />' .$inge->getUsername();
?>
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
jan
De gebruikersnaam is: inge

In de method getUsername() in de Customer class hebben we als voorwaarde gesteld dat de getUsername() method uit de User class aangeroepen moet worden als de gebruikersnaam gelijk is aan 'jan'. In de output zien we dat gebeuren.

Tot zover dit hoofdstuk over inheritance. We kunnen concluderen dat ook dit onderwerp vooral terug grijpt op de denkwijze die achter OOP schuil gaat. De bijbehorende PHP code is niet bijzonder lastig, je zult alleen moeten zorgen dat de logica van je applicatie ook in orde is. Mocht je tijdens het programmeren op dit soort punten vastlopen, dan is het verstandig om al je (denk)stappen nog eens na te lopen en te controlen of de opzet die je gebruikt eigenlijk wel klopt. Vaak ligt daar namelijk het probleem.

In de handleiding op phptuts.nl is een extra voorbeeld toegevoegd over dit onderwerp.

« vorige pagina | volgende pagina »

« Lees de omschrijving en reacties

Inhoudsopgave

  1. Inleiding
  2. Object geörienteerd denken
  3. Foute denkwijze
  4. Object georiënteerd programmeren
  5. Visibility
  6. Naamgeving
  7. Constructor __construct()
  8. Voorbeeld: HTML tabel
  9. Inheritance
  10. Static methods en properties
  11. Abstract classes en Interfaces
  12. Slotwoord en referenties

PHP tutorial opties

 
 

Om de gebruiksvriendelijkheid van onze website en diensten te optimaliseren maken wij gebruik van cookies. Deze cookies gebruiken wij voor functionaliteiten, analytische gegevens en marketing doeleinden. U vindt meer informatie in onze privacy statement.