Luky.cc NetworkLuky.cc NetworkLuky.cc Network - AutoDetectLuky.cc Network - AutoDetectEinloggenLuky.cc Network - AutoDetect

LukyDeluxe8 1.0 
dAxEngine 1.0 powered 

LukyDeluxe8

LukyChat

LukyThoughts

PHP

MySQL

CS: S

Service

 

T
u
t
o
r
i
a
l
 

 


PHP Tutorial > Kapitel 11: Klassen und Objekte


Fortgeschrittenes Thema
D
as Thema "Klassen und Objekte" ist ein etwas fortgeschritteneres Kapitel als die vorherigen und es kann sein, dass Du etwas nach 3 mal durchlesen nicht verstehst.
Ich selbst habe mit Klassen erst mit 4 Jahren Erfahrung begonnen.
Es kann auch sein, dass Du es sofort verstehst. Ich versuche alles so einfach zu erklären wie es nur geht. ;)

Für dieses Kapitel benötigst du einen PHP 5 Server.

Klassen? Objekte?
W
ir haben schon von vielen verschiedenen Variablentypen gelernt. Und manchmal kam auch das Wort "Objekt" dazu.
Das Objekt ist der letzte Variablentyp den ich in diesem Tutorial erkläre.

Begriffserklärung
E
ine Klasse ist ein Stück PHP Code, der definiert, was für Funktionen und Eigenschaften diese Klasse überhaupt hat. Man kann normale Funktionen in eine Klasse hineinprogrammieren. Am Anfang werden alle nötigen Variablen eingestellt. Darauf können dann Funktionen folgen.
Eine Instanz (Einheit) von einer Klasse ist ganz einfach ein hineinspeisen von der gesamten Klasse in eine Variable (Objekt). Bei jeder Instanz kann dieses Objekt dann andere Variablenwerte haben.
Ein Objekt ist ein anderes Wort für Klasse.

Im Folgenden Beispiel ist unser Objekt Obst. Wir wollen uns nicht auf eine bestimmte Art von Obst wie einen Apfel beschränken, wir wollen die gesamte Palette von Obst in die folgende Klasse einfügen.

Tutorial_Kapitel11_Beispiel_1.php:
<?php

final class Obst
{
 private
$name = "";
 private
$farbe = "";
 private
$form = "";
 private
$gegessen = 0;
 public function
Obst($name, $farbe, $form) // void Obst(String $name, String $farbe, String $form)
 {
  
$this->name = $name;
  
$this->farbe = $farbe;
  
$this->form = $form;
  return;
 }
 public function
aufessen() // void aufessen(void)
 {
  
$this->gegessen = 1;
  return;
 }
 public function
status() // String status(void)
 {
  if(
$this->gegessen == 0)
  {
   return
$this->name." ist noch ".$this->farbe." und wurde noch nicht
aufgegessen."
;
  }
  else
  {
   return
$this->name." ist nicht mehr ".$this->farbe." und wurde
aufgegessen."
;
  }
 }
}

$apfel = new Obst("Der Apfel", "Rotgrün", "Rund");
$apfel->aufessen();
echo
$apfel->status();

$orange = new Obst("Die Orange", "Orangegelb", "Rund");
$orange->aufessen();
echo
$orange->status();

$kiwi = new Obst("Das Kiwi", "Grün", "Eiförmig");
echo
$kiwi->status();

?>


Aufbau einer typischen Klasse:

 [final] class KLASSENNAME
 {
  [public/private/protected] $variable = "standartwert";
  ...
  [public/private/protected] function KLASSENNAME($wert1, $wert2, ...)
  {
   ...
  }
  ...
 }


Die Dinger in den Klammern sind Optional und müssen jetzt noch nicht beachtet werden. Wenn Du eine Funktion innerhalb einer Klasse so nennst, wie die Klasse selber, wird diese Funktion beim Erstellen der Klasse mit dem "new" Befehl ausgeführt.

 $objekt = new KLASSENNAME("wert1", "wert2", ...);

Was bedeuten die Pfeile?
D
ie Pfeile bedeuten, dass PHP auf etwas innerhalb einer Klasse zugreifen soll. Wie Du in Beispiel 1 siehst, erstelle ich 3 Instanzen von der Klasse Obst. Den Apfel und die Orange lasse ich aufessen mit der Funktion aufessen(). Das Kiwi lasse ich, wie es ist. Die Funktion status() gibt einen String mit einem Satz zurück, der aussagt, ob die Instanz "aufgegessen" wurde.

Die Variable $this

Tutorial_Kapitel11_Beispiel_2.php:
<?php

final class Mensch
{
 public
$wach = 1;
 public
$name = "";
 public function
Mensch($name) // void Mensch(String $name)
 {
  
$this->name = $name;
  return;
 }
 public function
gehSchlafen() // void gehSchlafen(void)
 {
  
$this->wach = 0;
  return;
 }
 public function
aufwachen() // void aufwachen(void)
 {
  
$this->wach = 1;
  return;
 }
 public function
status() // String status(void)
 {
  if(
$this->wach == 1)
  {
   return
$this->name." ist wach.";
  }
  else
  {
   return
$this->name." ist nicht wach";
  }
 }
}

$markus = new Mensch("Markus");
echo
$markus->status();
$markus->gehSchlafen();
echo
$markus->status();
$markus->aufwachen();
echo
$markus->status();

echo
$markus->name;
echo
$markus->wach;

?>


Wenn du einen Blick in die Klasse hinein wirfst, siehst du sehr oft "$this".
Da wir beliebig viele Instanzen einer Klasse erschaffen können und diese wie bei $markus nennen können wie wir wollen ist das innerhalb der Klasse nicht so.
Die Klasse kann nicht wissen wie ihre Instanz heißt und benutzt deshalb $this.

Innerhalb der Klasse:
$this
Außerhalb der Klasse als Instanz:
$instanzname = new Klassenname();
$instanzname

Vererbung
W
as bedeutet "final" vor dem Wort "class"? Es definiert, dass die Klasse von keiner anderen Klasse "erben" kann und sie die "höchste Klasse" ist. Somit können nur andere Klassen die nicht "final" sind von ihr erben.
So zum Beispiel kann die Klasse "Schaf" von der Klasse "Tier" Funktionen erben.

Tutorial_Kapitel11_Beispiel_3.php:
<?php

class Tier
{
 public
$lebensenergie = 100;
 public
$alter = 0;
 public
$groesse = 0;
 public
$name = "";
 public function
setzen_lebensenergie($e) // void setzen_lebensenergie(int $e)
 {
  
$this->lebensenergie = $e;
  return;
 }
 public function
setzen_alter($a) // void setzen_alter(int $a)
 {
  
$this->alter = $a;
  return;
 }
 public function
setzen_groesse($g) // void setzen_groesse(int $g)
 {
  
$this->groesse = $g;
  return;
 }
 public function
setzen_name($n) // void setzen_name(String $n)
 {
  
$this->name = $n;
  return;
 }
}

?>


Tutorial_Kapitel11_Beispiel_4.php:
<?php

include("Tutorial_Kapitel11_Beispiel_3.php");

final class
Schaf extends Tier
{
 public
$baumwolle = 0;
 public function
Schaf($name, $alter, $groesse, $lebensenergie) // void Tier(String $name, int $alter, int $groesse, int $lebensenergie)
 {
  
$this->baumwolle = (mt_rand(1000, 5000)+(($groesse*$lebensenergie)/$alter));
  
$this->setzen_name($name);
  
$this->setzen_alter($alter);
  
$this->setzen_groesse($groesse);
  
$this->setzen_lebensenergie($lebensenergie);
  return;
 }
 public function
baumwolle_abschneiden() // int baumwolle_abschneiden(void)
 {
  
$gewonnenewolle = $this->baumwolle;
  
$this->baumwolle = 0;
  return
$gewonnenewolle;
 }
}

$insgesamtwolle = 0;

$schaf1 = new Schaf("Schaf1", 5, 150, 100);
$schaf2 = new Schaf("Schaf2", 25, 14, 200);
$schaf3 = new Schaf("Schaf3", 32, 44, 100);
$schaf4 = new Schaf("Schaf4", 12, 177, 200);
$schaf5 = new Schaf("Schaf5", 42, 555, 300);
$schaf6 = new Schaf("Schaf6", 22, 150, 400);

$insgesamtwolle += $schaf1->baumwolle_abschneiden();
$insgesamtwolle += $schaf2->baumwolle_abschneiden();
$insgesamtwolle += $schaf3->baumwolle_abschneiden();
$insgesamtwolle += $schaf4->baumwolle_abschneiden();
$insgesamtwolle += $schaf5->baumwolle_abschneiden();
$insgesamtwolle += $schaf6->baumwolle_abschneiden();

echo
$insgesamtwolle;

?>


Public
D
ank den guten Verbesserungen in PHP 5 am System der Klassen kannst Du entscheiden, ob eine Variable oder Funktion von außen angreifbar ist. Wenn du vor eine Variable wie in den Beispielen zuvor "public" schreibst, kann diese Variable mit

$instanzname->variablenname

aufgerufen werden. Dasselbe gilt für Funktionen.

Private
W
enn eine Funktion oder Variable auf "private" gesetzt wird, kann sie nur innerhalb der Klasse aufgerufen werden. Versucht man es trotzdem von außen, bekommt man einen Fehler. Private Funktionen / Variablen werden nicht an weitere Klassen vererbt.

Protected
D
u kannst Variablen auch "protected" setzen, sodass sie gar nicht von außen aufgerufen werden können. Von innen sind sie es. Wo liegt dann der unterschied zu Private? Protected verweigert das verändert der Variable. Eine "protected Function" kann nur von innen aufgerufen werden.
 
Alle Beispiele von Kapitel 11





 

Navigation «
 

Einführung
Basiswissen / HTML
Tutorial
Codeschnipsel
Links

Sitemap

LD unterstützen «
 

 

Developed by dAxpHpNIzER™
Copyright © Lukas Wojcik 2002 - 2021. Alle Rechte vorbehalten. AGB

 

Extesizer.at