XI. Klasy/Obiekty

Wstęp

Te funkcje pozwalają uzyskać informacje o klasach i ich egzemplarzach, obiektach. Możesz uzyskać informację o nazwie klasy do jakiej należy obiekt, a także jej właściwości i metody. Używając tych funkcji możesz dowiedzieć się nie tylko do jakiej klasy należy obiekt, ale także ustalić jego przodków (np. jaką klasę rozszerza klasa tego obiektu).

Wymagania

Do zbudowania tego rozszerzenia nie są wymagane żadne zewnętrzne biblioteki.

Instalacja

By używać tych funkcji, nie trzeba niczego instalować. Są one częścią jądra PHP.

Konfiguracja czasu wykonywania

To rozszerzenie nie definiuje posiada żadnych dyrektyw konfiguracyjnych w pliku php.ini.

Typy zasobów

To rozszerzenie nie posiada żadnych rodzajów zasobów.

Stałe predefinopwane

To rozszerzenie nie posiada żadnych stałych.

Przykłady

W tym przykładzie najpierw zdefiniujemy bazową klasę i jej rozszerzenie. Klasa bazowa opisuje normalne warzywo, czy jest jadalne czy nie oraz jego kolor. Podklasa Szpinak dodaje metodę pozwalającą go zagotować i drugą, która pozwala dowiedzieć się, czy jest zagotowany.

Przykład 1. classes.inc


<?php



// klasa bazowa wraz z jej właściwościami i metodami

class Warzywo {



    var $jadalne;

    var $kolor;



    function Warzywo($jadalne, $kolor="zielony") {

        $this->jadalne = $jadalne;

        $this->kolor = $kolor;

    }



    function czy_jadalne() {

        return $this->jadalne;

    }



    function jaki_kolor() {

        return $this->kolor;

    }



} // koniec klasy Warzywo



// rozrzesza klasę bazową

class Szpinak extends Warzywo {



    var $ugotowane = false;



    function Szpinak() {

        $this->Warzywo(true, "zielone");

    }



    function ugotuj() {

        $this->ugotowane = true;

    }



    function czy_ugotowane() {

        return $this->ugotowane;

    }



} // koniec klasy Szpinak



?>

Teraz możemy stworzyć dwa egzemplarze tych klas i wydrukować informacje o nich, włączając w to informacje o przodkach. Zdefiniujemy także kilka użytecznych funkcji, głównie po to by uzyskać ładny wydruk zmiennych.

Przykład 2. test_script.php


<pre>

<?php



include "classes.inc";



// funkcje użytkowe



function drukuj_wlasciwosci($obj) {

    $tab = get_object_vars($obj);

    while (list($wlasc, $wart) = each($tab))

        echo "\t$wlasc = $wart\n";

}



function drukuj_metody($obj) {

    $tab = get_class_methods(get_class($obj));

    foreach ($tab as $metoda)

        echo "\tfunkcja $metoda()\n";

}



function przodkowie_klasy($obj, $klasa) {

    global $$obj;

    if (is_subclass_of($GLOBALS[$obj], $klasa)) {

        echo "Obiekt $obj należy do klasy ".get_class($$obj);

        echo ", podklasy $klasa\n";

    } else {

        echo "Obiekt $obj nie należy do podklasy $klass\n";

    }

}



// tworzymy 2 egzemplarze obiektów



$warzywko = new Warzywo(true, "niebieski");

$lisciaste = new Szpinak();



// wydrukujemy informację o obiektach

echo "warzywko: KLASA ".get_class($warzywko)."\n";

echo "lisciaste: KLASA ".get_class($lisciaste);

echo ", PRZODEK ".get_parent_class($lisciaste)."\n";



// pokażmy właściwości warzywka

echo "\nwarzywko: Właściwości\n";

drukuj_wlasciwosci($warzywko);



// i metody liściastego

echo "\nlisciaste: Metody\n";

drukuj_metody($lisciaste);



echo "\nPrzodkowie:\n";

przodkowie_klasy("lisciaste", "Szpinak");

przodkowie_klasy("lisciaste", "Warzywo");

?>

</pre>

Wartą odnotowania rzeczą w powyższym przykładzie jest to, że obiekt $lisciaste jest egzemplarzem klasy Szpinak która to jest podklasą klasy Warzywo, i tak ostatnia część powyższego skryptu pokaże na wyjściu:

[...]
Przodkowie:
Obiekt lisciasty nie należy do podklasy Szpinak
Obiekt lisciasty należy do klasy Szpinak, podklasy Warzywo

Spis treści
call_user_method_array -- Wywołuje metodę użytkownika zadaną z tablicą parametrów [przestarzałe]
call_user_method -- Wywołuje metodę użytkownika na zadanym obiekcie [przestarzałe]
class_exists -- Sprawdza czy klasa została zdefiniowana
get_class_methods -- Zwraca tablicę nazw metod danej klasy
get_class_vars -- Zwraca tablicę domyślnych właściwości klasy
get_class -- Zwraca nazwę klasy zadanego obiektu
get_declared_classes -- Zwraca tablicę z nazwami zdefiniowanych klas
get_declared_interfaces -- Returns an array of all declared interfaces
get_object_vars -- Zwraca tablicę asocjacyjną właściwości obiektu
get_parent_class -- Pobiera nazwę klasy przodka dla obiektu lub klasy
interface_exists -- Checks if the interface has been defined
is_a -- Zwraca TRUE jeżeli obiekt jest tej klasy, lub ta klasa jest jednym z jego przodków
is_subclass_of -- Zwraca TRUE jeżeli klasa jest jednym z przodków obiektu
method_exists -- Sprawdza czy metoda klasy istnieje

User Contributed Notes


If anyone is interested in looking for a way to dynamically load existing objects into a class, here is what I found very useful.



//---------------------------------------------------------

// Dynamically load External Objects into a class



  function objRef ( &$obj ) {     

    eval("\$this->obj_".get_class($obj)." = \$obj;"); 

  }

//---------------------------------------------------------

// Reference by using: $this->obj_[object Name]->[var|f{}]



Example:



class date {  function date ( ) { $this->date = "March 3rd"; } }

class time {  function time ( ) { $this->time = "12:30pm"; } }



class show {

    function objRef ( &$obj ){

        eval("\$this->obj_".get_class($obj)." = \$obj;");

    }

   function test ( $var ){

       echo "$var".$this->obj_date->date." @ ".$this->obj_time->time;

   }

}



$date = new date;

$time = new time;

$show = new show;

    $show->objRef($date);

    $show->objRef($time);

    $show->test("Time Now => ");



// Output: Time Now => March 3rd @ 12:30pm



I found the prefix 'obj_' before the class name useful because it helped me to automatically identify external object references when scanning through my scripts. You can omit this if you want. Hope this helps someone.


to covertka at muohio dot edu and pillepop2003 at yahoo dot de:



There's a much easier solution to getting a class' name for working with a factory function.  Let's assume you're doing something like this:



<?php



  function FactoryFunction($whatever, $instancedata) {



    switch ($whatever) {

      case 'stuff'      : return new Stuff($instancedata);

      case 'otherstuff' : return new Otherstuff($instancedata);

    }



  }



?>



Now, consider the named parameter idiom and remember that PHP uses hashes for everything; as a result make the following changes:



<?php



  function FactoryFunction($whatever, $instancedata) {



    switch ($whatever) {



      case 'stuff'      : return array('typeis'=>'stuff',      'instance'=>new Stuff($instancedata));

      case 'otherstuff' : return array('typeis'=>'otherstuff', 'instance'=>new Otherstuff($instancedata));



    }



  }



?>



Nice 'n simple.  It seems that what the original poster wanted was something like C++ static data members; unfortunately as PHP4 has no static variables at all, there would need to be significant language change to support static-like behavior.  If you move to PHP5, the static keyword solves your problem cleanly.


To pillepop2003 at yahoo dot de:



I have the same issue.  I have a base class that manages database tasks for a number of child classes.  One of the functions in the base class is a find() method that returns instances of the child classes.  Since find() is usually called as a static method, it needs to know the name of the child class.  As you've found, this appears to be impossible to get in an easy fashion.



The only way I've found to get the child class name is to use the debug_traceback() function.  This requires me to have a find() method in every child class, but it does work.



Here's an example:



<?php

  require_once("Application.php");



  class parentClass {

    function find() {

      $className = NULL;

      foreach (debug_backtrace() as $bt) {

        if ($bt['function'] == __FUNCTION__) {

          $className = $bt['class'];

        }

      }



      // here should be some code to find the proper id, let's assume it was id 1

      $id = 1;

      return new $className($id);

    }

  }

  

  class foo extends parentClass {

    function __construct($id) {

      $this->id = id;

    }

    

    function find() {

      return parent::find();

    }

  }

  

  class bar extends parentClass {

    function __construct($id) {

      $this->id = id;

    }



    function find() {

      return parent::find();

    }

  }

  

  $a = foo::find();

  printf("Type for \$a: %s<br/>\n", get_class($a));

  $b = bar::find();

  printf("Type for \$b: %s<br/>\n", get_class($b));

?>


As programmers, you're probably more organized than me, but, I do try and maintain some order in my classes and codes and separate them in "packages" as in java.

This helped me keep them organized but caused havok when trying to use them, so what I did was to create a class that handles the loading of classes (which I instanciate in all pages) along with my error handling class all bundled up. This way, I can load my classes with a command similar to 

$baseClass->loadClass("package","className"[,"constructor"]);



the function responsible for this has some checking to see if they are loaded and stuff like that...



function loadClass($packageName,$className,$constructor=""){

  // if you dont have a constructor declare any function inside

  // the class

  if ($constructor==""){

    $constructor=$className;

  }

  if(!is_callable(array($className,$constructor))){

    if (defined("CLASS_DIR")){

      $pkg = CLASS_DIR.$packageName."/";

        if (is_dir($pkg)){

          // we have a directory with the package name

          $cls = $pkg.$className.".class.php";

          if(is_file($cls)){

            // we have a file

            include_once($cls);

          }else{

            die("Class <b>$className</b> could not be found in package <b>$packageName</b> , please check your instalation");

          }

        }else{

          die("Package <b>$packageName</b> could not be found, please check your instalation");

        }

      }

    }

}



Just remember to define CLASS_DIR as the physical path for the directories where you packages are...



Hope this comes in handy...



Here's an example of a diretory strucutre...

/var/www/classes/   <- this would be CLASS_DIR

in there I have:

package1/

     name.class.php

     name2.class.php

....



The loadClass would look like: loadClass("package1","name"); 



Cute and easy


Re: Looking for an uninstantiated class



# Loads data from a table into a class object

class LFPDataFactory extends LFPObject {

        var $object;

        var $class;

        var $table;

        function LFPDataFactory($args) {

                $this->unpackArgs($args); // assigns locals from $args

                if (in_array(strtolower($this->class), get_declared_classes())) {

                        $this->object = new $this->class;

                        // assemble the columns in the table...

                        // select their values and put them in our new object...

                } else { trigger_error("Class ".$this->class." not found", E_USER_ERROR); }

        }

}

$r = new LFPDataFactory("class=LFPLayout,table=layout");

$new_obj = $r->object; // this is a LFPLayout object.

print_r($new_obj);



This class looks to see if the class exists, then instantiates it -- a declared class is not the same as an instantiated class. As long as LFPLayout exists somewhere in the scripts, get_declared_classes() will find it. Remember strtolower on compare, however.



Why would I do this? Because I have my class layouts the same as their respective tables; the factory then selects the data (making sure that the variables match) and plugs in the data. (I've left out the actual code to do the selection/insertion).


to pillepop2003



Why do u want to know the classname of an non-existant object?



The only possible explanation for this question seems to me u want to know the class before u instantiate the object. Well, this is of no use since u always instantiate a class of ur choice. 



When the class is instantiated into an object u can find the class of the object by means of get_class(). This is all u need. In case of inheritance u can use get_class($this) to get the class of the instantiated object. Now u can differentiate according to which class the object belongs to.



e.g.:



<?php

class A{

   function A(){

      $class_of_this = get_class($this);

      echo 'Object is an instance of class '.$class_of_this.' which is the ';

      if(strcmp($class_of_this,'A')==0)

         echo 'parent-class';

      else if(strcmp($class_of_this,'B')==0)

         echo 'child-class';

      echo ".\n";

   }

}



class B extends A{

   function B(){

      $this->A();

   }

}



$object1 = new A();

$object2 = new B();

?>



When u run this code-snippet the output will be:



Object is an instance of class A which is the parent-class.

Object is an instance of class B which is the child-class.


<?php

/*

[Why Not Use Classes] 



Since PHP is object oriented OOP. Use it's features to the maximum.

 You can define ur business logic, data logic encapsulated in classes.

  For people who are not OOP,you might be wondering why this is needed.

   it is for code clarity, reusability, portability, ease of maintenace.

    Let's say for example, your site does a Login, Register, Feedback,

    Update, UnRegister and u are using a Informix database server.

You can */



//file user.php

class user {

    var $dbconn

    function user() {

        //do initialisation

        $this->dbconn = DB::getInformix();

    }

    function Login($uname, $pass) {

        //do login on uname and pass on Informix Server

        //run SQL queries on the Server

    }

    function Register($uname, $pass, $name, $email) {

        //do register by running SQL Queries on Informix Server

    }

    function FeedBack($name, $email, $msg) {

        //add feedback to informix server by running sql_queries

    }

    function Update($name, $email) {

        //update name, email on Informix Server

    }

    function UnRegister() {

        //delete user account from the informix server

    }

}



//file template.php

class template {

    function showlogin() {

        //show the login interface

    }

    function showwelcome() {

        //show welcoime when the person is logged in

    }

}



//file DBs.php

class DB {

    function getInformix() {

        //get informix database conn

    }

    function getMySQL() {

        //get MySQL conn

    }

    function getPostGRESQL() {

        //get  PostGRESQL

    }

}

/*

the file user will be included in all pages that can do a login or reg.

To get an informix database connection call DB::getInformix();

all username, server, password everything is handled in there.

Now the cue is to do login you just*/

$usr = new user();

$usr->Login($_POST["uname"], $_POST["pass"]);

//to do a register the same too is applied.

$usr->Register($_POST["uname"], $_POST["pass"], $_POST["name"], $_POST["email"]);

/* and so on..

all the logic of validation ands inserrting into the database is (login/register)

is done behind the bars of the class

to show the login interface you call template::showLogin()

You might have been wondering then what is new.

Consider if you want to change the login interface and the login has been declared

in 20 pages differently, it will be hard to add a [Forgot Password] link at the

bottom of the submit button. but if it were to be declared as a class function

just change the look in template::showLogin() and it will reflect in the 20 pages

immdeiately.

Consider again that you want users to specify that if they try to login from that

particular system IP address. They should be automatically logged in without

showing login interface. You can just extend the function to add an extra parameter */

Login($uname, $pass, $rememberIP);

/*and add a checkbox to template::showLogin(); call */

$usr->Login($_POST["uname"], $_POST["pass"], isset($_POST["remeberIP"]);

/*

and in the function interface you change your business logic to accomodate the

new parameter to taste.

Now let's say you just assume you connect to the informix database in 35 places

in your site and you want to change the login password to database. just chasnge

it in DB::getInformix(); and it will be reflected in the 35 pages if all of them

call DB::getInformix(). This will have saved u a headache of Search/Replace in

35 pages if you have connected explicitly in all the pages.

Another main issue is your IT manager comes the next morning and tells you that

he has heard that MySQL is now the bomb and wants a Database server change

to mySQL without the site getting down. if you are the wise one like me just

change $this->dbconn in the user class to DB::getMySQL(); in the constructor.

if u are not as wise. i am very sure this will give you at least a week long

HeadAche.



[Why Not Use Classes] is presented by Fasoro Oladipo, in Nigeria.

Fasoro Oladipo is a staunch advocate of OOP.

Thanks for reading this text, hope you have a change of mind.

*/

?>


I missed some kind of function to dynamicly override or extend an Object:



-----------------------------------------

function &extendObj(&$obj, $code) {

    static $num = 0;

    

    $classname = get_class($obj);

    $newclass = $classname.$num; 

    

    eval('class '.$newclass.' extends '.$classname.' { '.$code.' }');

    

    $newobj = new $newclass();



    $vars = get_class_vars($classname);

    foreach($vars AS $key=>$value) {

        $newobj->$key = &$obj->$key;

    }

    

    return $newobj;

}

-----------------------------------------



This creates a new class which extends the old one by the given code parameter, instanciates it and copy all vars from the old obj to the new one.



-----------------------------------------

class testA {

    var $prop = 'a';

    

    function funcA($val) {

        $this->prop = $val;

    }

    

    function value() {

        return $this->prop;

    } 

}



$obj = new testA();



$newobj = &extendObj(&$obj, 'function addX() { $this->prop .= "x"; }');



$newobj->funcA('abc');

$newobj->addX();

echo $newobj->value();

-----------------------------------------



Results in 'abcx'. You can use the function multiple times and also with class variables. Be carefull, even if $newobj is just a copy of $obj, $obj->value() will return 'abcx', too, because of the & operator: $newobj->$key = &$obj->$key;


If you want to be able to call an instance of a class from within another class, all you need to do is store a reference to the external class as a property of the local class (can use the constructor to pass this to the class), then call the external method like this:



$this->classref->memberfunction($vars);



or if the double '->' is too freaky for you, how about:



$ref=&$this->classref;

$ref->memberfunction($vars);



This is handy if you write something like a general SQL class that you want member functions in other classes to be able to use, but want to keep namespaces separate. Hope that helps someone.



Justin



Example:



<?php



class class1 {

    function test($var) {

        $result = $var + 2;

        return $result;

    }

}



class class2{

    var $ref_to_class=''; # to be pointer to other class



    function class1(&$ref){ #constructor

        $this->ref_to_class=$ref; #save ref to other class as property of this class

    }



    function test2($var){

        $val = $this->ref_to_class->test($var); #call other class using ref

        return $val;

    }

}



$obj1=new class1;

# obj1 is instantiated.

$obj2=new class2($obj1);

# pass ref to obj1 when instantiating obj2



$var=5;

$result=obj2->test2($var);

# call method in obj2, which calls method in obj1

echo ($result);



?>