5. Die Objekte

5.1. Jede Variable kann zu einem Objekt mit Attributen werden (exemple_14)

<?php

// Jede Variable kann per Definition Attribute haben
$obj1->attr1 = "un";
$obj1->attr2 = 100;
// Zeigt das Objekt an
print "objet1=[$obj1->attr1,$obj1->attr2]\n";
// ändert das Objekt
$obj1->attr2+=100;
// zeigt das Objekt an
print "objet1=[$obj1->attr1,$obj1->attr2]\n";
// weist Objekt2 den Wert von Objekt1 zu
$obj2 = $obj1;
// ändert Objekt2
$obj2->attr2 = 0;
// zeigt beide Objekte an
print "objet1=[$obj1->attr1,$obj1->attr2]\n";
print "objet2=[$obj2->attr1,$obj2->attr2]\n";
// weist Objekt3 die Referenz von Objekt1 zu
$obj3 = &$obj1;
// ändert „Obj3“
$obj3->attr2 = 10;
// zeigt beide Objekte an
print "objet1=[$obj1->attr1,$obj1->attr2]\n";
print "objet3=[$obj3->attr1,$obj3->attr2]\n";
// Ist ein Objekt ein Dictionary?
print count($obj1)."\n";
while (list($attribut, $valeur) = each($obj1))
  print "obj1[$attribut]=$valeur\n";
// Ende
exit;
?>

Ergebnisse:

objet1=[un,100]
objet1=[un,200]
objet1=[un,0]
objet2=[un,0]
objet1=[un,10]
objet3=[un,10]
1
obj1[attr1]=un
obj1[attr2]=10

Anmerkungen

• Zeile 4: Die Notation $obj->attr bezeichnet das Attribut attr der Variablen $obj. Falls es nicht existiert, wird es erstellt, wodurch die Variable $obj zu einem Objekt mit Attributen wird.
• Zeile 13: Der Ausdruck $obj2=$obj1 ist, sofern $obj1 ein Objekt ist, eine Kopie von Objekten per Referenz. Somit sind $obj2 und $obj1 Referenzen auf dasselbe Objekt. Das Objekt selbst kann durch jede der beiden Referenzen geändert werden.
• Zeile 20: Der Ausdruck $obj3=&$obj1 weist $obj3 die Referenz (die Adresse) der Variablen $obj1 zu. Wenn $obj1 ein Objekt ist, wie es hier der Fall ist, entspricht der vorstehende Ausdruck $obj3=$obj1.
• Zeilen 28–29: zeigen, dass ein Objekt wie ein Wörterbuch durchlaufen werden kann. Die Schlüssel des Wörterbuchs sind die Namen der Attribute und die Werte des Wörterbuchs die Werte dieser Attribute.
• Zeile 27: Die Funktion count kann auf ein Objekt angewendet werden, liefert jedoch nicht, wie man erwarten könnte, die Anzahl der Attribute. Ein Objekt weist also Ähnlichkeiten mit einem Wörterbuch auf, ist aber keines.

5.2. Eine Klasse „Person“ ohne deklarierte Attribute (exemple_15)

<?php

class Personne {

  // Attribute der Klasse
  // nicht deklariert – können dynamisch erstellt werden
  
  // Methode
  function identité() {
    // verwendet offenbar nicht vorhandene Attribute
    return "[$this->prénom,$this->nom,$this->âge]";
  }
}

// Test
// Die Attribute sind öffentlich und können dynamisch erstellt werden
$p = new Personne();
$p->prénom = "Paul";
$p->nom = "Langevin";
$p->âge = 48;
// Aufruf einer Methode
print "personne=" . $p->identité() . "\n";
// Ende
exit;
?>

Ergebnisse:

personne=[Paul,Langevin,48]

Kommentare

• Zeilen 3–13: Definieren eine Klasse Personne. Eine Klasse ist eine Vorlage, anhand derer Objekte erstellt werden. Eine Klasse ist eine Sammlung von Attributen und Funktionen, die als Methoden bezeichnet werden. Es besteht keine Verpflichtung, Attribute zu deklarieren.
• Zeilen 9–12: Die Methode identité gibt den Wert von drei Attributen aus, die in der Klasse nicht deklariert sind. Das Schlüsselwort $this bezeichnet das Objekt, auf das die Methode angewendet wird.
• Zeile 17: Es wird ein Objekt $p vom Typ Personne erstellt. Das Schlüsselwort „new“ dient dazu, ein neues Objekt zu erstellen. Der Vorgang gibt eine Referenz auf das erstellte Objekt zurück (also eine Adresse). Es sind verschiedene Schreibweisen möglich: new Personne(), new Personne, new personne. Bei der Klasse wird die Groß-/Kleinschreibung nicht berücksichtigt.
• Zeilen 18–20: Die drei für die Methode identité erforderlichen Attribute werden im Objekt $p angelegt.
• Zeile 22: Die Methode identité der Klasse Personne wird auf das Objekt $p angewendet. Im Code (Zeilen 9–11) der Methode identité verweist $this auf dasselbe Objekt wie $p.

5.3. Die Klasse „Person“ mit deklarierten Attributen (exemple_16)

<?php

class Personne {

  // Attribute der Klasse
  var $prénom;
  var $nom;
  var $âge;

  // Methode
  function identité() {
    return "[$this->prénom,$this->nom,$this->âge]";
  }
}
// Test
// Die Attribute sind öffentlich
$p = new Personne();
$p->prénom = "Paul";
$p->nom = "Langevin";
$p->âge = 48;
// Aufruf einer Methode
print "personne=" . $p->identité() . "\n";
// Ende
exit;
?>

Ergebnisse:

personne=[Paul,Langevin,48]

Kommentare

• Zeilen 6–8: Die Attribute der Klasse werden explizit mit dem Schlüsselwort „var“ deklariert.

5.4. Die Klasse „Person“ mit einem Konstruktor (exemple_17)

Die vorherigen Beispiele zeigten exotische Klassen wie Personne, wie sie in PHP 4 zu finden waren. Es wird nicht empfohlen, diesen Beispielen zu folgen. Wir stellen nun eine Personne-Klasse vor, die den Best Practices von PHP 5 entspricht:

<?php

class Personne {

// Attribute der Klasse
  private $prénom;
  private $nom;
  private $âge;

// Getter und Setter
  public function getPrénom() {
    return $this->prénom;
  }

  public function getNom() {
    return $this->nom;
  }

  public function getAge() {
    return $this->âge;
  }

  public function setPrénom($prénom) {
    $this->prénom = $prénom;
  }

  public function setNom($nom) {
    $this->nom = $nom;
  }

  public function setAge($age) {
    $this->âge = $age;
  }

// Konstruktor
  function __construct($prénom, $nom, $âge) {
    // man geht über die Setter
    $this->setPrénom($prénom);
    $this->setNom($nom);
    $this->setAge($âge);
  }

// Methode toString
  function __toString() {
    return "[$this->prénom,$this->nom,$this->âge]";
  }

}

// Test
// Anlegen eines Personenobjekts
$p = new Personne("Paul", "Langevin", 48);
// Identität dieser Person
print "personne=$p\n";
// Das Alter wird geändert
$p->setAge(14);
// Identität der Person
print "personne=$p\n";
// Ende
exit;
?>

Ergebnisse:

personne=[Paul,Langevin,48]
personne=[Paul,Langevin,14]

Kommentare

• Zeilen 3–48: die Klasse Personne
• Zeilen 6–8: die privaten (private) Attribute der Klasse. Diese Attribute sind nur innerhalb der Klasse sichtbar. Weitere verwendbare Schlüsselwörter sind:
• public: Macht das Attribut zu einem öffentlichen Attribut, das von außerhalb der Klasse sichtbar ist
• protected: Macht das Attribut zu einem geschützten Attribut, das innerhalb der Klasse und in von ihr abgeleiteten Klassen sichtbar ist.
• Da die Attribute privat sind, kann von außerhalb der Klasse nicht auf sie zugegriffen werden. Daher kann der folgende Code nicht geschrieben werden:

$p=new Personne() ;
$p->nom="Landru" ;

Hier befinden wir uns außerhalb der Klasse Personne. Da das Attribut nom privat ist, ist Zeile 2 falsch. Um die privaten Felder des Objekts $p zu initialisieren, gibt es zwei Möglichkeiten:

• (Fortsetzung)
  • die öffentlichen Methoden „set“ und „get“ (die Namen dieser Methoden können beliebig sein) aus den Zeilen 11–33 verwenden. Man könnte dann schreiben:

$p=new Personne() ;
$p->setNom("Landru") ;

• (Fortsetzung)
  • den Konstruktor in den Zeilen 36–41 verwenden. Dann schreibt man:

$p=new Personne("Michel","Landru",44) ;

Der obige Code ruft automatisch die Methode der Klasse Personne namens __construct auf.

• Zeile 54: Diese Zeile gibt die Person $p in Form einer Zeichenkette aus. Dazu wird die Methode der Klasse Personne namens __toString verwendet.

5.5. Die Klasse „Person“ mit Gültigkeitsprüfung im Konstruktor (exemple_18)

Der Konstruktor einer Klasse ist der richtige Ort, um zu überprüfen, ob die Initialisierungswerte des Objekts korrekt sind. Ein Objekt kann jedoch auch über seine Methoden set oder gleichwertige Methoden initialisiert werden. Um zu vermeiden, dass dieselben Überprüfungen an zwei verschiedenen Stellen erfolgen, werden diese in die Methoden set integriert. Sollte sich ein Initialisierungswert eines Objekts als falsch erweisen, wird eine Ausnahme ausgelöst. Hier ein Beispiel:

<?php

class Personne {

// Attribute der Klasse
  private $prénom;
  private $nom;
  private $âge;
  
// Getter und Setter
  public function getPrénom() {
    return $this->prénom;
  }

  public function getNom() {
    return $this->nom;
  }

  public function getAge() {
    return $this->âge;
  }

  public function setPrénom($prénom) {
    // Der Vorname darf nicht leer sein
    if (!preg_match("/^\s*(.+?)\s*$/", $prénom, $champs)) {
      throw new Exception("Le prénom doit être non vide");
    } else {
      $this->prénom = $champs[1];
    }
  }

  public function setNom($nom) {
    // Der Nachname darf nicht leer sein
    if (!preg_match("/^\s*(.+?)\s*$/", $nom, $champs)) {
      throw new Exception("Le nom doit être non vide");
    } else {
      $this->nom = $champs[1];
    }
  }

  public function setAge($âge) {
    // Das Alter muss gültig sein
    if (!preg_match("/^\s*(\d+)\s*$/", $âge, $champs)) {
      throw new Exception("L'âge doit être un entier positif ou nul");
    } else {
      $this->âge = $champs[1];
    }
  }

// Konstruktor
  function __construct($prénom, $nom, $âge) {
    // Wir verwenden die Setter
    $this->setPrénom($prénom);
    $this->setNom($nom);
    $this->setAge($âge);
  }

  // Methode toString
  function __toString() {
    return "[$this->prénom,$this->nom,$this->âge]";
  }
}

// Test
// Anlegen eines Objekts vom Typ „Person“
$p = new Personne("Paul", "Langevin", 48);
// Identität dieser Person
print "personne=$p\n";
// Anlegen eines fehlerhaften Personenobjekts
try {
  $p = new Personne("xx", "yy", "zz");
} catch (Exception $e) {
  print $e->getMessage();
}
// Ende
exit;
?>

Ergebnisse:

personne=[Paul,Langevin,48]
L'âge doit être un entier positif ou nul

Kommentare

• Zeilen 23–30: Initialisierung des Attributs prénom und Überprüfung des Initialisierungswerts
• Zeile 25: Verwendung eines regulären Ausdrucks. Der Vorname ist eine Folge aus einem oder mehreren Zeichen, der gegebenenfalls von Leerzeichen vorangestellt oder gefolgt wird.
• Zeile 26: Ist der Nachname leer, wird eine Ausnahme ausgelöst, andernfalls wird der Vorname gespeichert (Zeile 28)
• Zeile 66: Verwendung des Konstruktors der Klasse Personne
• Zeile 68: Verwendung der Methode __toString der Klasse Personne
• Zeilen 70–74: Behandlung einer eventuell vom Konstruktor der Klasse Personne ausgelösten Ausnahme.

5.6. Hinzufügen einer Methode, die als zweiter Konstruktor fungiert (exemple_19)

In PHP 5 ist es nicht möglich, mehrere Konstruktoren mit unterschiedlichen Parametern zu haben, die es ermöglichen würden, ein Objekt auf verschiedene Arten zu erstellen. Man kann daher Methoden verwenden, die als Konstruktor fungieren:

<?php

class Personne {

// Attribute der Klasse
  private $prénom;
  private $nom;
  private $âge;
  
// Getter und Setter
  public function getPrénom() {
    return $this->prénom;
  }

….

// Konstruktor
  function __construct($prénom, $nom, $âge) {
    // Wir verwenden die Setter
    $this->setPrénom($prénom);
    $this->setNom($nom);
    $this->setAge($âge);
  }

  // Methode
  public function initWithPersonne($p) {
    // initialisiert das aktuelle Objekt mit einer Person $p
    $this->__construct($p->prénom, $p->nom, $p->âge);
  }

  // Methode toString
  function __toString() {
    return "[$this->prénom,$this->nom,$this->âge]";
  }

}

// Test
// Erstellung eines Personenobjekts
$p = new Personne("Paul", "Langevin", 48);
// Identität dieser Person
print "personne=$p\n";
// Anlegen einer zweiten Person
$p2 = new Personne("Laure", "Adeline", 67);
// Initialisierung der ersten Person mit den Werten der zweiten
$p->initWithPersonne($p2);
// Überprüfung
print "personne=$p\n";
// Ende
exit;
?>

Ergebnisse:

personne=[Paul,Langevin,48]
personne=[Laure,Adeline,67]

Kommentare

• Zeilen 26–29: Mit der Methode initWithPersonne können die Werte der Attribute eines anderen Objekts (Personne) dem aktuellen Objekt zugewiesen werden. Hier wird der Konstruktor __construct aufgerufen, dies ist jedoch nicht zwingend erforderlich.

5.7. Ein Array von „Person“-Objekten (exemple_20)

Das folgende Beispiel zeigt, dass Arrays von Objekten möglich sind.

<?php

class Personne {

// Attribute der Klasse
  private $prénom;
  private $nom;
  private $âge;
  
// Getter und Setter
  public function getPrénom() {
    return $this->prénom;
  }

...

// Konstruktor
  function __construct($prénom, $nom, $âge) {
    // Wir gehen die Setter durch
    $this->setPrénom($prénom);
    $this->setNom($nom);
    $this->setAge($âge);
  }

  // Methode
  public function initWithPersonne($p) {
….
  }

  // Methode toString
  function __toString() {
    ...
  }

}

// Test
// Erstellung eines Arrays mit „Person“-Objekten
$groupe = array(new Personne("Paul", "Langevin", 48), new Personne("Sylvie", "Lefur", 70));

// Identität dieser Personen
for ($i = 0; $i < count($groupe); $i++)
  print "groupe[$i]=$groupe[$i]\n";
// Ende
exit;
?>

Ergebnisse:

groupe[0]=[Paul,Langevin,48]
groupe[1]=[Sylvie,Lefur,70]

Kommentare

• Zeile 39: Erstellung eines Arrays mit 2 Elementen
• Zeile 42: Durchlaufen des Arrays
• Zeile 43: $groupe[$i] ist ein Objekt vom Typ Personne. Zur Anzeige wird die Methode __toString verwendet.

5.8. Erstellung einer von der Klasse „Person“ (exemple_21) abgeleiteten Klasse

<?php

class Personne {

// Attribute der Klasse
  private $prénom;
  private $nom;
  private $âge;
  
// Getter und Setter
  public function getPrénom() {
    return $this->prénom;
  }
...

// Konstruktor
  function __construct($prénom, $nom, $âge) {
    // man nutzt die Setter
    $this->setPrénom($prénom);
    $this->setNom($nom);
    $this->setAge($âge);
  }

  // Methode
  public function initWithPersonne($p) {
    // initialisiert das aktuelle Objekt mit einer Person $p
    $this->__construct($p->prénom, $p->nom, $p->âge);
  }

  // Methode toString
  function __toString() {
    return "[$this->prénom,$this->nom,$this->âge]";
  }

}

// eine von „Person“ abgeleitete Klasse
class Enseignant extends Personne {

  // Attribute
  private $discipline;   // unterrichtetes Fach

  // Getter und Setter

  public function getDiscipline() {
    return $this->discipline;
  }

  public function setDiscipline($discipline) {
    $this->discipline = $discipline;
  }

  // Konstruktor

  public function __construct($prénom, $nom, $âge, $discipline) {
    // übergeordnete Attribute
    parent::__construct($prénom, $nom, $âge);
    // weitere Attribute
    $this->setDiscipline($discipline);
  }

  // Überschreiben der Funktion __toString der übergeordneten Klasse
  public function __toString() {
    return "[" . parent::__toString() . ",$this->discipline]";
  }

}

// Test
// Anlegen eines Arrays mit Objekten vom Typ „Person“ und abgeleiteten Objekten
$groupe = array(new Enseignant("Paul", "Langevin", 48, "anglais"), new Personne("Sylvie", "Lefur", 70));

// Identität dieser Personen
for ($i = 0; $i < count($groupe); $i++)
  print "groupe[$i]=$groupe[$i]\n";
// Ende
exit;
?>

Ergebnisse:

groupe[0]=[[Paul,Langevin,48],anglais]
groupe[1]=[Sylvie,Lefur,70]

Anmerkungen

• Zeilen 3–35: Die Klasse Personne
• Zeile 38: Die Klasse Enseignant leitet sich von der Klasse Personne. ab (extends). Die abgeleitete Klasse Enseignant erbt die Attribute und Methoden ihrer übergeordneten Klasse.
• Zeile 41: Die Klasse Enseignant fügt ein neues, ihr eigenes Attribut discipline hinzu
• Zeile 55: Der Konstruktor der Klasse Enseignant erhält 4 Parameter
  • 3 zur Initialisierung ihrer übergeordneten Klasse (Vorname, Nachname, Alter)
  • 1 für die eigene Initialisierung (Fach)
• Zeile 57: Die abgeleitete Klasse hat über das Schlüsselwort parent:: Zugriff auf die Methoden und Konstruktoren ihrer übergeordneten Klasse. Hier werden die Parameter (Vorname, Nachname, Alter) an den Konstruktor der übergeordneten Klasse übergeben.
• Zeile 64: Die Methode __toString der abgeleiteten Klasse nutzt die Methode __toString der übergeordneten Klasse.
• Zeile 71: Ein Array, das ein Objekt vom Typ Enseignant und ein Objekt vom Typ Personne enthält.
• Zeile 74: Es wird eine Schleife über die Elemente des Arrays durchlaufen
• Zeile 75: Die Methode __toString jedes Elements $groupe[$i] wird aufgerufen. Die Klasse Personne verfügt über eine Methode __toString. Die Klasse Enseignant verfügt über zwei Methoden: die ihrer übergeordneten Klasse und ihre eigene. Man könnte sich fragen, welche davon aufgerufen wird. Die Ausführung zeigt, dass die Methode der Klasse Enseignant aufgerufen wurde. Das ist immer so: Wenn eine Methode für ein Objekt aufgerufen wird, wird in folgender Reihenfolge danach gesucht: im Objekt selbst, in seiner übergeordneten Klasse, falls es eine gibt, dann in der übergeordneten Klasse der übergeordneten Klasse usw. Die Suche wird beendet, sobald die Methode gefunden wurde.

5.9. Erstellung einer zweiten Klasse, die von der Klasse „Person“ abgeleitet ist (exemple_22)

Das folgende Beispiel erstellt eine Klasse „Etudiant“, die von der Klasse „Personne“ abgeleitet ist:

<?php

class Personne {

// Attribute der Klasse
  private $prénom;
  private $nom;
  private $âge;

// Getter und Setter
  public function getPrénom() {
    return $this->prénom;
  }
...

// Konstruktor
  function __construct($prénom, $nom, $âge) {
    // man nutzt die Setter
    $this->setPrénom($prénom);
    $this->setNom($nom);
    $this->setAge($âge);
  }

  // Methode
  public function initWithPersonne($p) {
    // initialisiert das aktuelle Objekt mit einer Person $p
    ...
  }

  // Methode toString
  function __toString() {
    return "[$this->prénom,$this->nom,$this->âge]";
  }

}

// eine von „Person“ abgeleitete Klasse
class Enseignant extends Personne {

  // Attribute
  private $discipline;   // unterrichtetes Fach

  // Getter und Setter
...

  // Konstruktor

  public function __construct($prénom, $nom, $âge, $discipline) {
    // übergeordnete Attribute
    parent::__construct($prénom, $nom, $âge);
    // weitere Attribute
    $this->setDiscipline($discipline);
  }

  // Überladung der Funktion _identité__toString der übergeordneten Klasse
  public function __toString() {
    return "[" . parent::__toString() . ",$this->discipline]";
  }

}

// eine von „Person“ abgeleitete Klasse
class Etudiant extends Personne {

  // Attribute
  private $formation;   // Unterrichtsfach

  // Getter und Setter

  public function getFormation() {
    return $this->formation;
  }

  public function setFormation($formation) {
    $this->formation = $formation;
  }

  // Konstruktor

  public function __construct($prénom, $nom, $âge, $formation) {
    // übergeordnete Attribute
    parent::__construct($prénom, $nom, $âge);
    // weitere Attribute
    $this->setFormation($formation);
  }

  // Überschreiben der Funktion __toString der übergeordneten Klasse
  public function __toString() {
    return "[" . parent::__toString() . ",$this->formation]";
  }

}

// Test
// Erstellung eines Arrays von Personenobjekten und abgeleiteten Objekten
$groupe = array(new Enseignant("Paul", "Langevin", 48, "anglais"), new Personne("Sylvie", "Lefur", 70), new Etudiant("Steve", "Boer", 23, "iup2 qualité"));

// Identität dieser Personen
for ($i = 0; $i < count($groupe); $i++)
  print "groupe[$i]=$groupe[$i]\n";
// Ende
exit;
?>

Ergebnisse:

groupe[0]=[[Paul,Langevin,48],anglais]
groupe[1]=[Sylvie,Lefur,70]
groupe[2]=[[Steve,Boer,23],iup2 qualité]

5.10. Schnittstellen (exemple_23)

Eine Schnittstelle ist eine Struktur, die Methodenprototypen definiert. Eine Klasse, die eine Schnittstelle implementiert, definiert den Code aller Methoden der Schnittstelle.

<?php

// eine Schnittstelle
interface IExemple {
  function ajouter($i, $j);

  function soustraire($i, $j);
}

// Implementierung 1 der Schnittstelle
class Classe1 implements IExemple {

  public function ajouter($a, $b) {
    return $a + $b + 10;
  }

  public function soustraire($a, $b) {
    return $a - $b + 20;
  }

}

// Implementierung 2 der Schnittstelle
class Classe2 implements IExemple {

  public function ajouter($a, $b) {
    return $a + $b + 100;
  }

  public function soustraire($a, $b) {
    return $a - $b + 200;
  }

}

// Funktion
function calculer($a, $b, IExemple $interface) {
  print $interface->ajouter($a, $b)."\n";
  print $interface->soustraire($a, $b)."\n";
}

// ------------------- main
// Erstellung von 2 Objekten vom Typ Klasse1 und Klasse2
$c1 = new Classe1();
$c2 = new Classe2();
// Aufruf der Funktion „berechnen“
calculer(4, 3, $c1);
calculer(14, 13, $c2);
?>

Ergebnisse

17
21
127
201

Kommentare

• Zeilen 4–8: Die Schnittstelle IExemple definiert zwei Methoden: die Funktion ajouter (Zeile 5) und die Funktion soustraire (Zeile 7). Die Schnittstelle definiert den Code dieser Methoden nicht. Dies übernehmen die Klassen, die die Schnittstelle implementieren.
• Zeile 11: Die Klasse Classe1 implementiert die Schnittstelle IExemple. Sie definiert daher einen Code für die Methoden ajouter (Zeile 13) und soustraire (Zeile 17).
• Zeilen 24–34: Gleiches gilt für die Klasse Classe2
• Zeile 37: Die Methode calculer akzeptiert drei Parameter: zwei Ganzzahlen $a und $b sowie ein Objekt $interface, das die Schnittstelle IExemple implementiert. Man hätte auch function calculer($a, $b, $interface) schreiben können, ohne den Typ IExemple des Parameters $interface anzugeben. Durch diese Angabe ermöglicht man dem Interpreter PHP zu überprüfen, ob der tatsächliche Parameter tatsächlich ein Objekt ist, das die Schnittstelle IExemple implementiert.
• Zeilen 38–39: Verwendung der Methoden ajouter und soustraire des Objekts $interface. Da dieses die Schnittstelle IExemple implementiert, ist bekannt, dass es über diese beiden Methoden verfügt.
• Zeilen 44–45: Erstellung von zwei Objekten unterschiedlichen Typs, die jedoch beide die Schnittstelle IExemple implementieren.
• Zeile 47: Das Objekt $c1 vom Typ Classe1, das die Schnittstelle IExemple implementiert, wird an die Funktion calculer übergeben.
• Zeile 48: Es wird zur Funktion calculer übergegangen, wobei das Objekt $c2 vom Typ Classe2 die Schnittstelle IExemple implementiert.