✔ oop Grunsatzprobleme

Hast Du Dir das Kapitel über Sichtbarkeit auf der von mir verlinkten Seite angeschaut?
Genau aus diesem Grund deklarierst Du an dieser Stelle die Variablen, damit Sie innerhalb der ganzen Klasse Sichtbar sind, und die Werte während der ganzen Lebenszeit des Objektes halten.
 
Das heisst ich schleuse die Daten entweder über den Konstruktor oder eine andere Funktion in die Klasse ein und bestimme über die Kapselung wie wiederverwendbar diese sein sollen.


Gibt es eigentlich eine Möglichkeit diese Daten angenehmer zu Übergeben?
Ich meine, wenn ich ein Formular mir z.B.:20 Variablen habe, welche ich an die Klasse zum verarbeiten geben will ist das doch ziemlch unübersichtlich. vor allem wenn ich auch noch die db Daten und andere Formularunabhängige Daten üergeben will.
 
Da gibt es mehrere Möglichkeiten, entweder übergibst Du Objekte, oder Arrays oder eben eine Parameterliste.

Anderseits verwendet man Get und Set Methoden um Klassenvariablen zu befüllen.
 
Hier mal zum verdeutlichen der Sichtbarkeitsbereiche innerhalb einer Klasse...
PHP: 
<?php
header('Content-Type: text/html;charset=utf-8');

class EineKlasse
{
	/* Mich sieht und ändert nur meine Klasse. Ich werde auch NICHT vererbt */
	private $privat = 'Eigentum von EineKlasse';
	
	/* Mich können auch meine Kindklassen sehen und ändern. Ich werde an meine Kinder vererbt */
	protected $beschuetzt = 'Eigentum von EineKlasse und allen Erben.';
	
	/* Ich bin für alle sicht- und änderbar. */
	public $oeffentlich = 'Öffentliches Eigentum';
	
	public function __construct ()
	{		
		$methodenVariable = 'Ich bin nur in einer Methode sichtbar...';
	}
	
	public function getAll()
	{
		return sprintf('<b>privat:</b> %s; <b>beschützt:</b> %s; <b>öffentlich:</b> %s, <b>$methodenVariable:</b>', $this->privat, $this->beschuetzt, $this->oeffentlich, $methodenVariable);
	}
}

/* Eine Kindklasse */
class KindEinerKlasse extends EineKlasse
{
	protected $beschuetzt = 'Das Eigentum der Erben wurde geändert';
	
	/* Konstruktor wurde von EineKlasse geerbt, würde ich getAll() nicht überschreiben, hätte KindEinerKlasse jedoch auch "Zugriff" auf $privat,
	   da $eineKindK->getAll() nur ein "Synonym" für $eineK->getAll() wäre. Testweise kannst du die folgende Methode rausnehmen, umes zu verdeutlichen. */
	
	public function getAll()
	{
		return sprintf('<b>privat:</b> %s; <b>beschützt:</b> %s; <b>öffentlich:</b> %s, <b>$methodenVariable:</b>', $this->privat, $this->beschuetzt, $this->oeffentlich, $methodenVariable);
	}
}

$eineK = new EineKlasse();
echo $eineK->getAll().'<br />';

$eineKindK = new KindEinerKlasse();
echo $eineKindK->getAll().'<br />';

/* Auf public deklarierte Klassenvariablen kann man auch von außerhalb zugreifen... */
echo $eineK->oeffentlich.'<br />'.$eineKindK->oeffentlich.'<br />';

/* Man kann die öffentlichen Variablen auch ändern */
$eineK->oeffentlich = 'Hallo!';
echo $eineK->oeffentlich.'<br />';

/* Folgendes wird aber einen Fehler erzeugen... */
echo $eineK->beschuetzt;
echo $eineKindK->beschuetzt;
echo $$eineK->privat;
?>
Ich hoffe das klärt dich etwas auf :) Wenn was unklar ist, bitte fragen ;) Wenn was schlichtweg falsch ist, bitte schlagen... *duck*

Nachtrag
Der Konstruktor der KindEinerKlasse-Klasse wurde von EineKlasse vererbt.
 
Zuletzt bearbeitet:
Danke mAu, das check ich jetzt.

Wegen der Übergabe nochmal, Array ist klar, Objekt auch, das hab ich ja mehr oder weniger vorhin gemacht, aber was ist eine Parameterliste bzw. SET.
Ich nehme an GET meinst du, dass ich sie mir aus der URL hole.
 
Set/Get Methoden sind so gedacht, das man von aussen nicht auf die Klassenvariablen zugreifen kann. Sondern nur via Get/Set Methoden.
Ein kleines Beispiel:

PHP: 
class Beispiel{
  private das;
  private ist;
  
   public Beispiel(){
   //hier initialisiere ich nur.
   $this->das=0;
   $this->ist=0;
    }

}

jetzt stellt sich natürlich die Frage wie komme ich an den Inhalt der Variablen ran bzw wie Schreibe ich da überhaupt was sinnvolles rein?
Ganz einfach man verwendet Get/Set Methoden.
Set Methoden bestehen immer aus dem Wort "set"+Variablenname. (set ist das Prefix)
PHP: 
class Beispiel{
private das;
private ist;
public Beispiel(){
//hier initialisiere ich nur.
$this->das=0;
$this->ist=0;
}

public function setdas($val){
$this->das=$val;
}
public function setist($val){
$this->ist=$val;
}

}
Nun kannst du die Variablen mit Inhlat füllen. Und wie liest Du Sie nun aus? Richtig man verwendet die entsprechende Get Methode.
Get Methoden setzten sich immer aus dem Wort "get" + dem Variablennamen zusammen. (get ist das Prefix)
PHP: 
class Beispiel{
private das;
private ist;
public Beispiel(){
//hier initialisiere ich nur.
$this->das=0;
$this->ist=0;
}

public function setdas($val){
$this->das=$val;
}
public function setist($val){
$this->ist=$val;
}
public function getist(){
return $this->ist;
}

public function getdas(){
$this->das;
}

}
So nun kannst du auch den Inhalt der Variablen abfragen.
Wozu den ganzen Aufwand? Ganz einfach, auf diese Weise steuerst Du den Zugriff auf die Klassenvariable. In den Set Methoden kannst Du zB noch Werteprüfungen einbauen oder ähnliche Funktionen. Bei den Get Methoden kannst Du noch Ausgabefilter hinzufügen zB wenn der Wert als Float zurückgegeben werden soll.
Kleiner Hinweis am Rande in der Literatur werden diese Methoden auchoft als Set'er und Get'er Bezeichnet.

Alles Klar?
Ein Parameterliste ist zB
PHP: 
public function beispiel ($a,$b,$c)
hier besteht deine Parameterliste aus den Variablen a,b,c.
Klar?
 
Man kann auch die magische Funktion __call() "missbrauchen", um bei vielen set und get Methoden die Arbeit zu verkürzen. Das Gesundheitsministerium warnt: Bei unüberlegter Anwendung dieser Methode kann es zu erheblichen Sicherheitslücken kommen ;)
PHP: 
<?php
class TestKlasse
{
	/* Irgentwelche Klassenvariablen */
	private $var;
	private $array;
	
	/* Magische Methode __call, die aufgerufen wird, wenn eine angeforderte Methode nicht existiert */
	public function __call($method, $params)
	{
		$do = substr($method, 0, 3);
		$var= strtolower(substr($method, 3));
		/* Existiert die Variable $var (alle Zeichen nach dem 3 der angeforderten Funktion, bei getVar() wäre die Variable dann $var... */
		if(isset($this->{$var}))
		{
			/* Existiert, dann stelle set und get "bereit" */
			switch ($do)
			{
				case 'set':
					$this->{$var} = $params;
				break;
				case 'get':
					return $this->{$var};				
				break;
			}	
			return true;
		}	
		/* Klassenvariable exisiert nicht... */
		return false;
	}
}

$test = new TestKlasse;

$test->setVar('Bablubb!');
echo $test->getVar();
?>
Wie gesagt, ist nur eine Spielerei. Ich hab mich noch nicht ganz damit auseinandergesetzt. Vielleicht fällt ja dem einen oder anderen auf, was und ob da was unsicher ist an der Methode... Der einzige (große) Nachteil ist halt, dass man nicht spezifische Überprüfungen bei den einzelnen Set'ern und Get'ern machen kann... Außer man schreibt hierzu wieder eigene Methoden und verwendet die __call()-Methode nur für "unwichtige" Variablen...
 
Zuletzt bearbeitet:
Alles klar,
ich danke euch beiden.
Habt mir super weitergeholfen.

War nach meiner letzten Frage (PDO Funktionalität => 0 Antworten) ein bisschen enttäuscht über das Forum. Aber das war echt spitze.

Gruß Niko
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück