Variabele uit boven liggende class krijgen

[phobia]

Ik het een class, waarin een andere class wordt gedeclareerd.

class ONE {

public $var = "iets";

function __construct() {
$this->class = new TWO();
}
}

Nu wil ik in class TWO de variabele gebruiken die in class ONE gedeclareerd is.

Maar hoe moet ik dat doen?
Ik heb ook geen flauw idee waar ik op moet zoeken.
Met parent:: werkt niet, want daarmee krijg ik alleen toegang tot de gegevens die in de class staan die ik exstends.

 

[Frats]

Over het algemeen is de gedachte van OO programmeren dat je classes niet weten door wie ze aangemaakt zijn, zodat je geen verwovenheid krijgt. Als je class iets van bovenaf nodig heeft moet je het meegeven in de constructor, zodat de class een eigen kopie heeft, over het algemeen.

Tenzij je een specifieke vraag hebt, dan moet je even je probleem uitleggen, misschien kunnen we dan een betere oplossing vinden.

 

[migthy84]

kan wel hoor je kan een functie schrijven die het terugkaats.

public function givePublic()
{
return $this.iets
}

function iets()
{
  $this.iets = iets
}

 

[Frats]

Dat kan inderdaad, maar dat is over het algemeen niet netjes omdat het bepaalde verwachtingen schept tussen twee classes die voor problemen kunnen zorgen als je een van de twee classes wilt hergebruiken of vervangen door iets anders.

Het is vaak beter om het zo te bouwen dat de twee classes niets van elkaar hoeven te weten om te blijven werken. En dat betekent dat je de values die je nodig hebt meegeeft in de constructor, of aan andere functies.

In code dus zo:

class ONE {

public $var = "iets";

function __construct() {
$this->class = new TWO( $this->$var );
}
}

Als je de huidige waarde nodig hebt van ONE en niet de originele, moet ONE em meegeven aan TWO bij het aanroepen van een functie, óf ONE moet een functie van TWO aanroepen met een update iedere keer als $var veranderd. Afhankelijk van wat je precies aan het doen bent.

 

[migthy84]

__constuctor is inderdaad hiervoor bebouwd om de andere klassen variablen(objecten) mee te geven die nodig zijn bij het opstarten van de klassen. Het kan namelijk best zo dat je variable uit de klasse nodig. Je hebt niks voor niks setters en getters in klassen.

voorbeeld (bank)
methode 1:

public class klant
{
function __constructor(klantid)
{
  this->id  = klantid;
}
function getNaam()
{
   //code om de naam op te halen 
// .. iets van  select naam from klant where id = this->id
return "naam"
}
function getMoney()
{
     //code om de geld op te halen 
// .. iets van  select mon fromey klant where id = this->id
return 100;
}
}

public class bank
{
 // klant ophalen.
  $klant = new klant(id);
 ... etc (alle functie die aan een klant wilt koppelen
}

methode 2:

public class klant
{
function __constructor(klantid)
{
  this->id  = klantid;
}
function getNaam(id)
{
   //code om de naam op te halen 
// .. iets van  select naam from klant where id = id
return "naam"
}
function getMoney(id)
{
     //code om de geld op te halen 
// .. iets van  select mon fromey klant where id = id
return 100;
}
}

public class bank
{
 // klant ophalen.
  $klant = new klant();
 ... etc (alle functie die aan een klant wilt koppelen
}

methode 3:

public class bank
{
   $klant = new klant(); // hier verwerk dus geen variable , waardoor een algemeen object krijgt
   $klant.setIDS(1);
}
public class klant
{
$ids;
 public function getNaam()
{
  // code ophalen naam
 // ..... where id = $this->ids
}
 public function getMoney()
{
  // code ophalen naam
 // ..... where id = $this-ids
}
public function setIDs(id)
{
  $this->ids = id
}

}

Alle 3 methodes halen de zelfde gegevens op.
Echter er zijn verschillen.

object
1: specifiek object met alle waarden ter behoeven van de ené case
2: Algemeen object zonder specifieke waarde -> de waarde worden via de functie in geplaats
3: Algemeen object zonder specifieke waarde-> de waarde word via setIds in geplaats waardoor het object zijn waarde krijgt.

ophalen gegeven
1: het object geeft deze terug zonder herberekening.(dus let goed op wanneer je het ophaalt het zou zonde zijn als je object de verkeerd info ophaalt)
// klant.getNaam() en klant.getMoney()
2: de waarde worden per functie op nieuw berekend ookal is de id het zelfde
// klant.getNaam(id) en klant.getMoney(id)
3: de waarde word naar het invoeren van setIDs berekend
// klant.getNaam() en klant.getMoney()

Voordelen. / nadelen
1: Je kan op elke moment het volledig object ophalen. echter dien je er ook voor te zorgen dat je object vernietig. Vaak doet php dit naar dat je pagina herlaad etc.

2: Je kan op elke willekeurig moment beslissen om andere gegevens op te halen zonder het object te vernietigen nadeel elke keer dient het object een herrekening te doen ook al haal je 2 keer de zelfde gevens op. bijvoorbeeld id= 1 en id=1

3: je kan op elk willekeurig moment beslissen om object andere waardes te geven zonder het object op niew te maken bij methode 1 vernietig je eerst het object en maak je een nieuwe aan.

overal
Je dient heel goed te bedenken hoe je wilt gebruiken. Zijn de classen afhankelijk van elkaar , krijgen hij een standaard waarde mee. etc.
O(bject) O(georienteerd) is er op gebaseerd dat je object aan maakt en bij wijzigingen het liefst aan nieuwe aanmaak.Je kan zo behalen waneer een object aangemaakt word en vernietigd. Door slim onafhankelijke object te maken kan je veel performance schelen. Het gebruik van functies binnen ander objecten zorgt er voor dat je maar 1 keer een functie dient te wijzigen die over het gehele scala valt en je dus geen rekening meer mee hoeft te houden. Echter stuurd de hoofdklasse altijd de functies aan waardoor je de functie kan aanpassen

gebruik :
1. Wanneer je verwacht dat er weinig verandering zou plaats vinden. 1 of meerdere object maken is niet erg. Soms wel verstandig als je "dezelfde" objecten met elkaar wil vergelijken :: klant a met klant b
2. Wanneer je specifiek weinig gegevens nodig hebt en het object te groot wordt , let wel elke wijzing in het zelfde object "kan" echter ruimte / performance kosten let op elke functie aanroep kost performance
3: Als het een groot object is en je verwacht dat je object dient te verander. Let op dit is een tussen oplossing van 1 en 2 wordt wel vaak gebruikt
3.

 

[imacbest]

Misschien is global wat je zoekt?
Daarmee kun je gegevens uit een andere class in je class gebruiken

 

[phobia]

Ik heb Frats raad op gevolgd en de benodigde variables via de constructor verzonden.

Thnx allemaal voor jullie input, ik zet er nu een slotje op