PHP/Class/Class Definition

A Basic PHP 4 Class

 
<?php
    class myPHP4Class {
        var $my_variable;
        function my_method($param) {
            echo "my_method($param)!\n";
            echo "my variable is: ";
            echo "{$this->my_variable}\n";
        }
    }
     $myinstance = new myPHP4Class();
     $anotherinstance = new myPHP4Class();
?>

A Basic PHP 5 Class

 
<?php
     class myPHP5Class {
          public $my_variable;
          public function my_method($param) {
               echo "called my_method($param)!\n";
               echo "my variable is: ";
               echo "{$this->my_variable}\n";
          }
     }
?>

A class is a collection of variables and functions working with these variables.

 
<?php
class Cart {
    var $items; 
    
    function add_item ($artnr, $num) {
        $this->items[$artnr] += $num;
    }
    function remove_item ($artnr, $num) {
        if ($this->items[$artnr] > $num) {
            $this->items[$artnr] -= $num;
            return true;
        } else {
            return false;
        }
    }
}
class Named_Cart extends Cart {
    var $owner;
    function set_owner ($name) {
        $this->owner = $name;
    }
}

$ncart = new Named_Cart; 
$ncart->set_owner ("kris"); 
print $ncart->owner; 
$ncart->add_item ("10", 1); 
?>

Aggregating an address object

 
<?
class Address {
    protected $city;
    public function setCity($city) {
        $this->city = $city;
    }
        
    public function getCity() {
        return $this->city;
    }
}
class Person {
    protected $name;
    protected $address;
    public function __construct() {
        $this->address = new Address;
    }
    public function setName($name) {
        $this->name = $name;
    }
    public function getName() {
        return $this->name;
    }
    public function __call($method, $arguments) {
        if (method_exists($this->address, $method)) {
            return call_user_func_array(
                array($this->address, $method), $arguments);
        }
    }
}
?>

Basic Object Accessing

 
<?php
    class myPHP4Class {
        var $my_variable;
        function my_method($param) {
            echo "my_method($param)!\n";
            echo "my variable is: ";
            echo "{$this->my_variable}\n";
        }
    }
     $myinstance = new myPHP4Class();
     $anotherinstance = new myPHP4class();
     $myinstance->my_variable = 10;
     $anotherinstance->my_variable = 20;
     $myinstance->my_method("MyParam");
?>

Bird class

 
<?php 
class Bird { 
    function __construct($name, $breed){ 
        $this->name = $name; 
        $this->breed = $breed; 
    } 
} 
?>

book class

 
<?php
    class book
    {
        private $title;
        private $isbn;
        private $copies;
        public function __construct($isbn)
        {
            $this->setIsbn($isbn);
            $this->getTitle();
            $this->getNumberCopies();
        }
        public function setIsbn($isbn)
        {
            $this->isbn = $isbn;
        }
        public function getTitle() {
            $this->title = "Python";
            print "Title: ".$this->title."<br />";
        }
        public function getNumberCopies() {
            $this->copies = "5";
            print "Number copies available: ".$this->copies."<br />";
        }
    }
    $book = new book("11111111X");
    ?>

Class Type Hints

 
<?
    class Dog {
            public function do_drool( ) {
                    echo "Sluuuuurp\n";
            }
    }
    class Cat { }
    function drool(Dog $some_dog) {
            $some_dog->do_drool( );
    }
    $poppy = new Dog( );
    drool($poppy);
    
    $poppy = new Cat( );
    drool($poppy);
?>

Empty class

<?php
class StringThing {}
$st = new StringThing();
print $st;
?>

Implementing a Simple Class

 
<?php
class SimpleClass {
    public $data;
    public function echoMyData() {
        echo $this->data;
    }
}
$sc_object = new SimpleClass();
$sc_object->data = "Hello, world! ";
$another_object = new SimpleClass();
$another_object->data = "Goodbye, world! ";
$sc_object->echoMyData();
$another_object->echoMyData();
?>

Person class

 
class Person {
    public $name;
    protected $spouse;
    private $password;
    
    public function __construct($name) {
        $this->name = $name
    }
    public function getName() {
        return $name;
    }
    protected function setSpouse(Person $spouse) {
        if (!isset($this->spouse)) { 
            $this->spouse = $spouse;
        }
    }
    private function setPassword($password) {
        $this->password = $password;
    }
}

PHP class declaration structure

 
<?
class Class_name {
     var $attribute_1;
     var $attribute_N;
     function function1() {
     }
     function functionN() {
     }
}
?>

Pre-defined methods

 
__construct() is called when a new instance of the class is created. 
__destroy() is called when an instance of the class passes out of memory (calling unset()). 
__autoload() is called when you refer to a class for the first time. 
__clone() is called when you copy the object using the clone keyword. 
__get() and __set() are called when you get or set an object property that is not defined. 
__get() takes a single parameter, the name of the property; 
__set() takes two parameters: the name of the property and the value. 
__call() is called when you try to call an undefined method. 
__call() takes two arguments: the method name that was used and an array containing any values that were passed to the method. 
__sleep() and __wakeup: __sleep() is called when you try to serialize() an object. 
__wakeup() is called when you unserialize() an object. 
__toString() is called when a string representation of the object is required.

Using an aggregated class

 
<?
class Address { 
  protected $city;
  protected $country;
 
  public function setCity($city) { $this->city = $city; }
  public function getCity() { return $this->city; } 
  public function setCountry($country) { $this->country = $country; }
  public function getCountry() { return $this-> country;}
}
class Person {
 protected $name;
 protected $address;
 public function __construct() { $this->address = new Address; }
 public function setName($name) { $this->name = $name; }
 public function getName() { return $this->name; }
 public function __call($method, $arguments) { 
  if (method_exists($this->address, $method)) { 
   return call_user_func_array( array($this->address, $method), $arguments);
  }
 }
}
?>