<?

--------------------------------------------------
deklaracja klas, wywolywanie metod obiektow i klas
--------------------------------------------------

class A
{
   function foo()
   {
       echo __CLASS__; //wyswietli nazwe klasy
   }
}

class B
{
   function bar()
   {
       A::foo();
   }
}

$a = new A();   //tworzenie obiektu A
$a->foo();      //wywolanie metody obiektu A
A::foo();       //wywolanie metody klasy A



----------------------------------
Referencja i kopiowanie obiektow
----------------------------------

$a = new A();

$b =  $a    //Kopiowanie ( namiarow do obiektu, a nie obiektu, bo do tego sluzy clone(obiekt) )
$c =& $a;   //Referencja

$a = null;  // $a i $c staja sie null (puste)



-------------------------------------------
Proste Dziedziczenie metod i instacji klasy
-------------------------------------------

class A extends B
{
   function bar()       // Przedefiniowanie metody bar() nadrzednej klasy B
   {
       parent::bar();   //wywolanie metody bar() klasy nadrzednej przy uzyciu dyrektywy parent
   }
}



--------------------------
Konstruktory i destruktory
--------------------------

class B
{
   function __construct()
   {
   }

   function __destruct()
   {
   }
}

class A extends B
{
   function __construct()
   {
       parent::__construct();   //wywolanie konstruktora nadrzednej klasy B
   }
}



------------------------
Zakres metod i instancji
------------------------

class A
{
   public    $public    = 'Public';
   protected $protected = 'Protected';
   private   $private   = 'Private';

   function printHello()
   {
       echo $this->public;
       echo $this->protected;
       echo $this->private;
   }
}

$a = new A();
echo $a->public;      // zadziala
echo $a->protected;   // Fatal Error (protected: dostepnosc tylko dla klasy i klas dziedziczonych)
echo $a->private;     // Fatal Error (private: dostepnosc tylko dla klasy)
$a->printHello();     // wyswietli wszystkie instancje



class B extends A
{
   // Redeklaracja instancji (mozliwe tylko dla typow public i protected)
   protected $protected = 'Protected2';
}

$b = new B();
echo $b->public;      // zadziala
echo $e->private;     // instancja niezdefioniowana (bo instancji private nie mozna dziedziczyc)
echo $e->protected;   // Fatal Error (bo dostepnosc dziedziczonej instancji typu protected na to nie pozwala)
$e->printHello();     // wyswietli wszystkie instancje

dyrektywy te mozna takze dodawac metodom (procz __constructor i __destructor, ktore musza byc zawsze public)



------------------------
static
------------------------
Dyrektywa ta umozliwia dostepnosc metod i instancji spoza obiektu poprzez operator ::
a nie przez obiekt, np: $this->instancja

class A
{
   public static function metoda_statyczna()
   {
   }
}

A::metoda_statyczna();



class A
{
   public static $statyczna = 'statyczna';

   public function foo()
   {
       return self::$statyczna;
   }
}

class B extends A
{
   public function foo()
   {
       return parent::$statyczna;
   }
}

$a = new A();
$b = new B();

echo $a->statyczna();  //zadziala
echo $b->statyczna();  //zadziala

echo A::$statyczna;    //zadziala
echo B::$statyczna;    //zadziala

echo $a->statyczna;    //nie zadziala: Undefined "Property" statyczna
                       //$a::my_static nie jest mozliwe!



------------------------
const
------------------------
Dyrektywa dziala jak w przypadku static lecz nie mozna zmodyfikowac takiej instancji.
Dziala ona tylko w przypadku instancji (nie metod).
Nie mozna jej miksowac z protected czy private (static mozna)!

class A
{
   const stala = 'stala';

   function foo() {
       echo  self::stala;
   }
}

echo A::stala;     //zadziala
$a = new A();
echo $a->foo();    //zadziala
                   // echo $class::constant;  nie jest mozliwe!



------------------------
Operator ::
------------------------
Operator ten uzywamy w polaczeniu z instancjami typu static, const (patrz wyzej)

- Mozna za jego pomoca takze wywolywac metody klasy:

nazwa_klasy::metoda();


- Wewnatrz klasy uzywamy w polaczeniu z self oraz parent:

self::metoda();       //wywolanie metody klasy
echo self::$instancja //wyswietlenie statycznej instancji klasy
echo self::instancja  //wyswietlenie instancji typu const klasy

parent::metoda();       //wywolanie metody klasy nadrzednej ( dyrektywa extends )
echo parent::$instancja //wyswietlenie statycznej instancji klasy nadrzednej
echo parent::instancja  //wyswietlenie instancji typu const klasy nadrzednej



------------------------
abstract
------------------------

Dyrektywa ta odnosi sie do klas i metod. Klasa posiadajaca przynajmniej jedna abstrakcyjna metode,
takze musi miec ta dyrektywe (byc abstrakcyjna klasa).
Nie mozna tworzyc obiektow na podstawie klasy abstrakcyjnej!

W przypadku dziedziczenia klasy abstrakcyjnej metoda nadpisujaca metode abstrakcyjna,
musi miec taka sama lub gorsza widzialnoc np:
jezeli klasa abstrakcyjna ma metode abstrakcyjna o widzialnosci protected,
to klasa dziedziczaca musi miec nadpisywana metode o widzialnosci protected lub public.

abstract class A
{
   abstract protected function foo(); //Wymuszenie by ewentualna klasa dziedzica okreslila cialo tej metody

   public function bar()
   {
       echo $this->foo();
   }
}

class B extends A
{
   protected function foo() //widzialnosc musi byc ta sama lub gorsza
   {
       return "klasa B";
   }
}

class C extends A
{
   protected function foo()
   {
       return "klasa C";
   }

}

$b = new B;
$c = new C;

$b->bar(); //wyswietli "klasa B"
$c->bar(); //wyswietli "klasa C"



------------------------
Interface
------------------------

Interface okresla jakie metody musza byc w klasie. Zawiera w sobie deklaracje tych metod.
Takie metody musza byc typu public.
Klasa uzywajaca musi miec ustalone ciala wszystkich metod wymienionych w interface. W przypadku braku: fatal error


interface B
{
   public function foo();
   public function bar($arg0,$arg1);
}

class A implements B
{
   private $vars = array();

   public function foo()
   {
   }

   public function bar($arg0,$arg1)
   {
   }
}



------------------------
Overloading
------------------------
Przeciazenia dotycza instancji: __get __set oraz metod: __call

Takie funkcje __get i __set zostaja wywolane przed odniesieniem sie do jakiejs instancji.

Funkcja __get musi posiadac jeden argument, ktory bedzie przechowywal nazwe instancji
Funkcja __set musi posiadac dwa argumenty, jeden dla nazwy drugi dla wartosci instancji

Przyklad __get i __set:

class A
{
   function __get($name)
   {
       echo "get: [$name]\n";
   }

   function __set($name, $val)
   {
       echo "set: [$name] => $val\n";
   }
}
$a = new A();

$a->x  = 1;     //wywola set i zmieni wartosc instancji
$a->x += 1;     //wywola get i set i zmieni wartosc instancji
echo $a->x;     //wywola get i wyswietli wartosc instancji



Funkcja __call zostaje wywolana w przypadku braku danej metody.
Musi posiadac dwa argumenty, pierwszy zawierajacy nazwe wywolanej metody, drugi tablice argumentow.

Przyklad __call:

class koszyk_owoce
{
   private $jablka  = 4;
   private $gruszki = 2;
   private $banany  = 5;

   function __call($m, $a)
   {
       if ( $m == 'ile_suma' )
       {
            $i = 0;
            foreach( $this as $k => $v ) $i+= $v;
            return $i;
       }
       else if ( substr($m,0,4) == 'ile_' )
       {
           $i = substr($m, 4);
           foreach( $this as $k => $v )
            if ( $i == $k )
                return $v;
       }
       else
           die("Nie ma takiego owocu");
   }
}

$a = new koszyk_owoce();

echo $a->ile_jablka();      //Wyswietli wartosc instancji $jablka
echo $a->ile_suma();        //Wyswietli sume wszystkich instancji
echo $a->arbuzy();          //Spowoduje w powyzszym przykladzie uruchomienie funkcji die();



------------------------
Iteracja
------------------------
Iteracja okresla jak instancje klasy maja byc wyswietlone za pomoca foreach

Iteracja prosta (tylko wartosci public):

class A
{
   public    $v1 = 'v1';
   protected $p1 = 'p1';
   private   $u1 = 'u1';
}

$a = new A;

foreach( $a as $k => $v ) echo "$k => $v\n";

Istnieja jeszcze dwa sposoby iteracji, za pomocja implementacji dwoch gotowych interfacesow:
Iterator lub IteratorAggregate
Wiecej info na temat tych interfacesow w dokumentacji.



-----------------------------------
__clone (wyciete z dzialu patterns)
-----------------------------------

Metoda __clone jest wykonywana w przypadku klonowania (kopiowania) calego obiektu


class A
{
    function __clone()
    {
        trigger_error('Zakaz klonowania.', E_USER_ERROR); //generowanie bledu
    }
}

$a = new A;
$b = clone($a); //Wyswietli blad


------------------------
Magic Methods
------------------------

Lista wbudowanych metod:
__construct, __destruct, __call, __get, __set, __clone, __sleep, __wakeup, __toString

__sleep i __wakeup sa zwiazane z funkcjami odpowiednio: serialize() i unserialize()
Metoda __sleep zostanie wykonywana w przypadku serialize()
(funkcja sluzy do zwracania tablicy struktury klasy, nazw i wartosci instancji)

Metoda __wakeup zostanie wykonana w przypadku unseralize()
(funkcja sluzy do odtworzenia struktury zasobow uzyskanej przez serialize() )

Obie metody mozna wykorzystac do przygotowania danych obiektu przed "serializacj?"



Metoda __toString jest wykonywana w przypadku drukowania obiektu.

class A
{
    __toString()
    {
        return __CLASS__;
    }
}

$a = new A;
echo $a;    //wyswietli nazwe klasy obiektu $a



------------------------
final
------------------------
Dyrektywa final uzyta:
przed metoda klasy - powoduje, ze klasa nie moze nadpisac metody klasy dziedziczonej
przed klasa        - powoduje, ze klasa nie moze nie moze byc dziedziczona



------------------------
Klonowanie obiektow
------------------------

$a = new obiekt;
$b = clone $a;
$c = clone($a);



-----------------------
Porownanie obiektow
-----------------------

$ob1 ==  $ob2 //Czy obiekty maja te same metody i instancje
$ob1 === $ob2 //Czy to ten sam obiekt



-----------------------
Reflection
-----------------------

pominiete, niepotrzebne



-----------------------
Type Hinting
-----------------------

Ustalenie rodzaju obiektu jako argumentu metody lub funkcji zewnetrznej. Przyklad:

class A
{
    public zmienna = 10;
}


function foo(A $arg)
{
   return $arg->zmienna;
}

$a = new A;
echo foo($a);


?>