OOP: APIE (abstraction)

July 18th, 2012 | 4 min read | Coding rules, Object oriënted, PHP

APIE is een afkorting voor de 4 grote peilers in OOP. Het staat voor:

  • Abstraction
  • Polymorphism
  • Inheritance
  • Encapsulation

Wat deze begrippen betekenen en wat je ermee kan doen, dat zal je in deze tutorial te weten komen.
Daarnaast ga ik ook nog even de volgende begrippen bespreken:

  • Interfaces
  • Exceptions

Heads up!

Deze tutorial sluit aan bij mijn vorige tutorial in de reeks van OOP tutorials, Classes & Objects.

Abstraction

Tijdens de vorige tutorial heb ik uitgelegd wat overerving is. Soms komt het echter voor dat we een superclass willen maken en anderen willen verplichten om een bepaalde methode aan te maken, zonder dat je er zelf de implementatie van kent.
Abstractie is dus eigenlijk een soort van uitbreiding op het voorgaande verhaal. Je moet dus opnieuw een superclass maken, maar deze noemen we een abstracte class, omdat ze niet de volledige implementatie bevat. Aangezien deze abstracte class niet volledig af is, is het ook vrij logisch dat het niet de bedoeling is om hier instanties van aan te maken, sterker nog, het kan gewoonweg niet.
Door een abstracte class te gebruiken, kan je bepaalde methodes implementeren en andere gewoon open laten. Zo’n methode die we open laten noemen we een abstracte methode.

Een voorbeeld:

<?php

// Abstracte class
abstract class Vogel {
        protected $vleugels = 2;

        public function LegEi() {
                return "*Legt een ei*";
        }

        public abstract function Beweeg(); // De signatuur van een abstracte methode, de implementatie ervan is leeg
}

class Kip extends Vogel { // Ook bij abstracte classes gebruiken we 'extends'

        public function Beweeg() {
                return "*Loopt*";
        }
}

class Eend extends Vogel {

        public function Beweeg() {
                return "*Zwemt*";
        }
}

$kip = new Kip();
$eend = new Eend();

echo "<h1>Kip</h1>". $kip->Beweeg() ."<br />". $kip->LegEi() ."<br />";
echo "<h1>Eend</h1>". $eend->Beweeg() ."<br />". $eend->LegEi() ."<br />";

?>

In dit voorbeeld maken we van de

Beweeg()

methode uit vorig voorbeeld een abstracte methode. Vanaf dat moment zijn we verplicht om bij elke subclass de methode

Beweeg()

te implementeren.
We kunnen eveneens geen instantie meer aanmaken van de class Vogel, aangezien deze class niet compleet is.

Zoals tijdens de vorige tutorial gezegd is, kunnen we via OOP regels opleggen. Nu kunnen we via abstractie zeggen tegen toekomstige developers dat ze bepaalde methodes MOETEN implementeren en andere methodes dan weer niet. Abstractie is dus een groot voordeel aan OOP en zal in volgende tutorials over design principes en design patterns zeker nog terugkomen.

Interfaces

Soms is het echter niet de bedoeling dat je een volledig of gedeeltelijk geïmplementeerde class wilt hebben om van over te erven. Soms wil je namelijk enkel en alleen de class die je aanmaakt gebruiken om bepaalde regels/constraints vast te leggen. Dit kan je doen via interfaces.

Een interface is vergelijkbaar met een abstracte class, waar je enkel en alleen abstracte methodes zou gebruiken. Een voorbeeld:

<?php

// Een interface
interface IVogel {

        public function Vlieg(); // Enkel de methode signaturen zijn toegestaan
        public function LegEi();

}

// In plaats van het keyword extends, gebruiken we nu implements
class Eend implements IVogel {

        // De methodes die in de interface beschreven staan, MOETEN geïmplementeerd worden
        public function Vlieg() {
                return "*Vliegt*";
        }

        public function Legei() {
                return "*Legt ei*";
        }
}

$eend = new Eend();
echo $eend->Vlieg();

?>

Alle methodes die we voorzien in onze interface, moeten geîmplementeerd worden in onze classes. In onze interface zelf mogen we geen implementatie schrijven, enkel de signatuur van de methode is toegestaan. We gebruiken hier (in PHP, maar ook in Java) het keyword implements om duidelijk te maken dat het hier over een interface gaat.
Er wordt meestal aangeraden om interfaces aan te duiden met een I alvorens de naam te beginnen, net zoals dat het geval is met IVogel.

Back to tutorialsContact me on TwitterDiscuss on Twitter

Profile picture

Dimitri "g00glen00b" Mestdagh is a consultant at Cronos and tech lead at Aquafin. Usually you can find him trying out new libraries and technologies. Loves both Java and JavaScript.