[PHP] OOP => extended classes

[Cavorka]

Hallo,

ik ben al een tijdje geleden begonnen met het gebruik van Classes in PHP (no comment on PHP's classes plz ) en tot nu toe was het allemaal meer een verzameling van functies die dan een klasse vormen. Handig, maar nog niet echt het uitbuiten van klasse-functionaliteit.

Nu ben ik echter begonnen met een nieuw project en ik wilde een bepaalde klasse een uitbreiding laten zijn op een andere klasse. Het idee is dat ik met klasse A het dataverkeer regel tussen het script en mijn database en dat in die klasse een aantal queries staan. Je kan dus geen losse queries doen, maar alleen queries die al in de klasse zelf staan, je roept dan dus bijv. myspecialquery('DropTableTest') aan en dan wordt de querie die het 'ID' DropTableTest heeft uitgevoerd.

Wat ik nu wil is dus een basisklasse maken, en daarop een klasse extenden zodat ik voor elk module een klasse heb met de queries behorende bij een module. Op die manier blijft alles schaalbaar en onafhankelijk.

Het probleem (met voorbeeldscript):

In de klasse B zullen dus weer queries staan die je alleen kan aanroepen met hun ID, deze wil ik dan via klasse A laten uitvoeren.

PHP:

<?php

error_reporting(E_ALL) ;

class a{
    
    var $bla = 1 ;
    
    function setbla() {
        $this->bla = 5 ;
        print $this->bla . "<br>" ;
    }
    
    function display(){
        print $this->bla ;
    }
}
class b extends a{
    
    function disp(){
        a::display();
    }
}

$y = new a ;
$y->setbla() ;

$x = new b ;
$x->disp();

?>

Wat is dus niet begrijp is waarom print ie eerst 5 ($y->setbla()) en dan 1 ($x->disp)? Waarom print ie niet twee keer 5? Dit probleem ben ik nu al een paar keer in verschillende vormen tegengekomen en ik snap het niet. Kennelijk is mijn begrip van klasses (nog) niet toereikend.

Is er iemand die het me uit kan leggen? Ik heb de manual echt al tig keer doorgelezen (het stuk over Classes dan), maar ik vind dit erg unexpected behaviour.

PS: Een soortgelijk script geeft ook errors en een verkeerd resultaat:

PHP:

<?php

error_reporting (E_ALL) ;

Class A {

    function getMicrotime(){ 
        list($usec, $sec) = explode(" ", microtime()) ;
        return ((float)$usec + (float)$sec) ;
    }   // EoF: getMicrotime
    
    // Start Time
    function Start() {
        $this->timestamp_start = $this->getMicrotime() ;
    }   // EoF: Time
    
    // End / Stop Time
    function Stop() {
        $this->timestamp_stop = $this->getMicrotime() ;
    }   // EoF: Stop
    
    // Parse Time with wanted accuracy
    function ParseTime($accuracy) {
        if(!isset($this->timestamp_stop)) {
            $this->Stop() ;
        }
        
        $this->parse_time = $this->timestamp_stop - $this->timestamp_start ;
        
        if(isset($accuracy) && is_int($accuracy)) {
            return round($this->parse_time, $accuracy) ;
        }
        else {
            return $this->parse_time ;
        }
    }   // EoF: ParseTime
    
}

Class B extends A {
    
    function Bar() {
        return A::ParseTime(3) ;
    }
    
}

$a = new A ;

$a->Start() ;

sleep(1) ;

$a->Stop() ;

print $a->ParseTime(3) . "<br>" ;

$b = new B ;

print $b->Bar() ;

?>

Hier krijg ik als resultaat:

code:

1.063

Notice: Undefined property: timestamp_start in class-test.php on line 28
1087901654.61

[ Voor 49% gewijzigd door Cavorka op 22-06-2004 12:59 ]

[drm]

Nee, dit is gewoon keurig OO. Elke keer als jij de new operator gebruikt instantieer_zoekwoordje je een object van het type klasse dat jij aangeeft. Op dat moment krijgt dat object de initialisatiewaarden die je in de klassedefinitie opgeeft.

$y en $x zijn dus twee verschillende objecten met hun eigen properties (in dit geval '$bla')

edit:

En kijk eens naar het gebruik van Constructors _{nog een zoekwoordje}

Een basiscursusje object-oriented principes zou geen kwaad kunnen

edit:

Eigenlijk zit het probleem dus niet zo zeer in het extenden van classes, maar het begrip van instanties.

PHP:

class A {
   var $b = 1;
   function piet () {
      $this->b ++;
      print ( $this->b ):
   }
}

$obj1 = new A ();
$obj2 = new A ();
$obj1->piet ();
$obj1->piet ();
$obj2->piet ();

Misschien dat dat het duidelijker maakt wat ik bedoel

[ Voor 46% gewijzigd door drm op 22-06-2004 12:58 ]

[Cavorka]

Ja inderdaad, nu ik erover nadenk is dat wel erg basic. Mijn gedachten waren de verkeerde kant op gegaan en ik heb helemaal niet meer over het feit dat de instanties onafhankelijk van elkaar zijn, nagedacht.

Hartelijk dank voor deze duw in de werkelijke richting van OOP.

Ik zal inderdaad even wat gaan zoeken naar wat OO principes informatie.