1

Podstawy programowania II

dr inż. Paweł Róg  

2

Zagadnienia

■

Podstawy programowania obiektowego



Klasy i obiekty.



Pola i metody.



Dostęp do składowych, hermetyzacja.



Konstruktory i destruktory.



Typy argumentów funkcji i metod.



Dziedziczenie.

■

Zagadnienia zaawansowane



Pola i metody statyczne.

3

Klasa

■

Definicja klasy w języku PHP5

class

 nazwa_klasy 

{

// ciało klasy

}

Klasa jest to złożony typ będący opisem (definicją) pól 

i metod  obiektów  (opis  zbioru  wszystkich  obiektów 

mających wspólną strukturę i zachowanie).

Klasa jest to złożony typ będący opisem (definicją) pól 

i metod  obiektów  (opis  zbioru  wszystkich  obiektów 

mających wspólną strukturę i zachowanie).

4

Obiekt

■

Tworzenie obiektu w PHP5

$nazwa_zmiennej = 

new

 nazwa_klasy();

Obiekt  jest  konkretyzacją  (instancją)  danej  klasy 

i wypełnieniem  wzorca,  jakim  jest  klasa,  określonymi 

danymi. Obiekt posiada tożsamość, stan i zachowanie.

Obiekt  jest  konkretyzacją  (instancją)  danej  klasy 

i wypełnieniem  wzorca,  jakim  jest  klasa,  określonymi 

danymi. Obiekt posiada tożsamość, stan i zachowanie.

5

Pola

■

Stan obiektu jest określony przez wartości pól 
obiektu. Pola obiektu to zmienne przechowywane 
wewnątrz obiektu.

class Zarowka {
   

private $zapalona

;

}

6

Metody

■

Zachowanie obiektu jest określone przez 
metody. Metody są funkcjami zdefiniowanymi 
wewnątrz klasy.

class Zarowka {
   private $zapalona;

   

public function zapal() {

      $this->zapalona = True;

   

}

}  

7

Hermetyzacja

■

Poziomy dostępu



public – składowa klasy jest dostępna z dowolnego 

miejsca programu. Metody są domyślnie publiczne, 

chyba, że programista zdecyduje inaczej.



protected – składowa klasy jest dostępna w danej 

klasie i jej klasach pochodnych.



private – składowa klasy jest dostępna tylko w klasie, 

w której została zdefiniowana.

Hermetyzacja  pozwala  na  ukrycie  pewnych  danych 

i funkcji 

obiektu 

przed 

bezpośrednim 

dostępem 

z zewnątrz.

Hermetyzacja  pozwala  na  ukrycie  pewnych  danych 

i funkcji 

obiektu 

przed 

bezpośrednim 

dostępem 

z zewnątrz.

8

Dostęp do składowych

■

Aby uzyskać dostęp do składowych klasy, należy 
posłużyć się operatorem -> (minus i znak 
większości, bez spacji)

class prosta {

   

public

 $publiczna;

}

function test() {
   $obiekt = new prosta();

   $obiekt

->

publiczna = 123;

   print $obiekt

->

publiczna;

}

9

Dostęp do składowych

■

Oczywiście z zewnątrz klasy możliwy jest jedynie 
dostęp do składowych publicznych, dlatego 
w przypadku poniższego kodu otrzymamy błąd:

class prosta {
   

private

 $prywatna;

}

function test() {
   $obiekt = new prosta();

   $obiekt->prywatna = 123; // 

błąd !!!

   print $obiekt->prywatna; // 

błąd !!!

}

10

Wynik działania skryptu

Fatal error: Cannot access private property prosta::
$prywatna in C:\wamp\www\skrypty\prosta.php on 
line 8

11

Dostęp do składowych

class SzukamGuza {

   

public

 $problem; 

// nie ustawiać

                    

// na True !!!

   public function bum() {

      if ($this->problem == True) 
         print 'BUM !!!';

   }
}

function test() {

   $poCoToRobic = new SzukamGuza();
   $poCoToRobic->problem = 

True

;

   $poCoToRobic->bum();
}

12

Wynik działania skryptu

BUM !!!

13

$this

■

Dostęp do składowych z metod klasy odbywa się 
za pomocą specjalnej zmiennej $this, która 
odnosi się do aktualnego obiektu.

class Zarowka {

   private $zapalona;
   public function zapal() {

      

$this

->zapalona = True;

   }
   public function zgas() {

      

$this

->zapalona = False;

   }

}

14

Dostęp do definicji klasy

■

Aby móc używać klasy, która jest zdefiniowana 
w innym pliku, należy plik, w którym jest 
zdefiniowana klasa, załadować za pomocą 
require_once

require_once 'nazwa_pliku.php';

15

Powtórzenie

■

Pole jest to zmienna wewnątrz obiektu.

■

Metoda jest to funkcja wewnątrz klasy.

■

Wszystkie pola klasy muszą być zadeklarowane 
i poprzedzone jednym ze słów kluczowych 
określających ich widoczność: public, 
protected lub private.

■

W przypadku definiowania metod, określenie ich 
widoczności jest opcjonalne, lecz polecane. 
Domyślnie metody są publiczne.

■

Aby klasa była widoczna wewnątrz pliku, który 
z niej korzysta, należy załadować plik, w którym 
jest zdefiniowana z wykorzystaniem 
require_once

16

Powtórzenie

■

Do tworzenia obiektów klasy służy słowo kluczowe 
new

■

Zmienna $this wewnątrz klasy odnosi się do 
aktualnego obiektu

■

Dostęp do składowych (pól i metod) klasy 
zapewnia operator ->

■

Uzyskując dostęp do pola klasy za pomocą 
operatora -> opuszczamy znak $ przed nazwą 
pola

■

Próba dostępu do składowej chronionej lub 
prywatnej spoza klasy spowoduje błąd

■

Dostęp do pól prywatnych możemy zapewnić za 
pomocą publicznych metod klasy

17

Konstruktor

■

W PHP5 nazwa konstruktora __construct() 
rozpoczyna się od dwóch znaków podkreślenia „_”

class Zarowka {
   private $zapalona;

   public function 

__construct

($stan) {

      $this->zapalona = $stan;

   }
}

Konstruktorem

 nazywamy 

specjalną 

metodę 

automatycznie wywoływaną w trakcie tworzenia obiektu, 

pozwalającą  na  nadanie  początkowych  wartości  danym 

obiektu.

Konstruktorem

 nazywamy 

specjalną 

metodę 

automatycznie wywoływaną w trakcie tworzenia obiektu, 

pozwalającą  na  nadanie  początkowych  wartości  danym 

obiektu.

18

Destruktor

■

W PHP5 nazwa destruktora __destruct() 
rozpoczyna się od dwóch znaków podkreślenia „_”

class Zarowka {
   private $zapalona;

   public function 

__destruct

() {

      print 'I po żarówce ...';

   }
}

Destruktorem

 nazywamy 

specjalną 

metodę 

bezparametrową,  która  jest  wywoływana  zawsze 

w momencie usuwania obiektu

Destruktorem

 nazywamy 

specjalną 

metodę 

bezparametrową,  która  jest  wywoływana  zawsze 

w momencie usuwania obiektu

19

Przykład 1

class Zarowka {
   private $zapalona;
   public function __construct() {
      print 'Oto zgaszona żarówka !!!<br />';
      $this->zapalona = False;
   }
   public function __destruct() {
      print 'I po żarówce ...<br />';
   }
   public function zapal() {
      print 'Zapalam żarówkę...<br />';
      $this->zapalona = True;
   }
   public function zgas() {
      print 'Gaszę żarówkę...<br />';
      $this->zapalona = False;
   }

20

Przykład 1 cd.

   public function stan() {
      return $this->zapalona;
   }
}

function opis($zr) {
   print 'Żarówka jest ';
   if ($zr->stan()) print 'zapalona.<br />';
      else print 'zgaszona.<br />';
}

function test() {
   $zr = new Zarowka();
   $zr->zapal();
   opis($zr);
   $zr->zgas();
}

   

21

Wynik działania skryptu

Oto zgaszona żarówka !!!
Zapalam żarówkę...
Żarówka jest zapalona.
Gaszę żarówkę...
I po żarówce ...

22

Typy argumentów funkcji

■

Co się stanie, jeśli w poprzednim przykładzie 
zapomnimy o znaku „$” i napiszemy:

function test() {
   $zr = new Zarowka();
   $zr->zapal();
   opis(

zr

);

   $zr->zgas();
}

■

Otrzymamy mniej więcej następujące błędy:

Notice: 

Use of undefined constant zr - assumed 'zr'

 

in C:\wamp\www\skrypty\zarowka.php on line 33

Fatal error: 

Call to a member function stan() on a 

non-object

 in C:\wamp\www\skrypty\zarowka.php on 

line 25

23

Typy argumentów funkcji

■

Można tę sytuację zmienić określając 
typ argumentu przyjmowanego przez funkcję 
opis() 

function opis(

Zarowka

 $zr) {

   if ($zr->stan()) print "zapalona.";
      else print "zgaszona.";
}

■

Otrzymamy wtedy następujący błąd:

Catchable fatal error: 

Argument 1 passed to opis() 

must be an instance of Zarowka, string given

, called 

in C:\wamp\www\skrypty\zarowka.php on line 33 and 
defined in C:\wamp\www\skrypty\zarowka.php on line 
25

24

Typy argumentów funkcji

■

Na pierwszy rzut oka wydaje się, że sytuacja 
uległa pogorszeniu, jednak zyskujemy to, że:



Błąd zostaje wykryty wcześniej – w momencie 

przekazania obiektu do funkcji, a nie w momencie jego 

użycia



Błąd jest typu „

Catchable fatal error

”, co 

przy wykorzystaniu mechanizmu wyjątków umożliwia 

nam utrzymanie kontroli nad przebiegiem wykonania 

programu

25

Przykład 2

 class Lampa {
    

protected

 $zarowka;

    public function __construct (Zarowka $zarowka) {
       print 'Wkręcam żarówkę<br />';
       $this->zarowka = $zarowka;
    }
    public function zapal() {
       $this->zarowka->zapal();
       print 'Lampa zapalona<br />';
    }
    public function zgas() {
       $this->zarowka->zgas();
       print 'Lampa zgaszona<br />';
    }
}

26

Dziedziczenie

■

Dziedziczenie pozwala na powtórne 
wykorzystanie istniejącego kodu, ponieważ klasa 
pochodna dziedziczy po klasie bazowej pola 
i metody.

class pochodna 

extends

 bazowa {

   // ciało klasy pochodnej

}

Dziedziczenie  jest  operacją  polegającą  na  stworzeniu 

nowej  klasy  (pochodnej)  na  bazie  klasy  już  istniejącej 

(bazowej). 

Dziedziczenie  jest  operacją  polegającą  na  stworzeniu 

nowej  klasy  (pochodnej)  na  bazie  klasy  już  istniejącej 

(bazowej). 

27

Przykład 3

class LampkaNocna 

extends

 Lampa {

   private $sciemniacz;

   public function __construct (Zarowka $zarowka) {

      

parent::__construct($zarowka);

      $this->sciemniacz= new Sciemniacz($this->zarowka);

   }

   public function rozjasnij() {

      $this->sciemniacz->rozjasnij();

   }

   public function sciemnij() {

      $this->sciemniacz->sciemnij();

   }

}

■

Zapis

parent::

__construct($zarowka);

oznacza wywołanie konstruktora klasy bazowej (Lampa) 

i przekazanie mu wartości zmiennej $zarowka.

28

Przykład 3 cd.

 class Sciemniacz {

    private $zarowka;

    private $poziomJasnosci = 100;

    public function __construct (Zarowka $zarowka) {

       $this->zarowka = $zarowka;

    }

    public function rozjasnij() {

       if ($this->poziomJasnosci < 100) {

          $this->poziomJasnosci++;

          print 'Rozjaśniam światło żarówki<br>';

       }

    }

    public function sciemnij() {

       if ($this->poziomJasnosci > 1) {

          $this->poziomJasnosci--;

          print 'Przyciemniam światło żarówki<br>';

       }

    }

 }

29

Przykład 3 cd.

$zarowka = new Zarowka();

$lampka = new LampkaNocna($zarowka);
$lampka->zapal();
$lampka->rozjasnij();

$lampka->sciemnij();
$lampka->sciemnij();

$lampka->rozjasnij();
$lampka->rozjasnij();

$lampka->rozjasnij();
$lampka->zgas();

30

Wynik działania skryptu

Oto zgaszona żarówka !!!
Wkręcam żarówkę
Zapalam żarówkę...
Lampa zapalona
Przyciemniam światło żarówki
Przyciemniam światło żarówki
Rozjaśniam światło żarówki
Rozjaśniam światło żarówki
Gaszę żarówkę...
Lampa zgaszona
I po żarówce ...

31

Przykład 4

class LampaOgrodowa 

extends

 Lampa {

  private $czujnikRuchu;
  public function __construct (Zarowka $zarowka) 
     {
     parent::_construct($zarowka);
     $this->czujnikRuchu = new   
CzujnikRuchu($this->zarowka);
     $this->czujnikRuchu->uruchom();
     }
}

32

Przykład 4 cd.

class CzujnikRuchu {
  private $zarowka;
  public __construct(Zarowka $zarowka) {
    $this->zarowka = $zarowka;
  }
  public function uruchom() {
    print 'Czujnik ruchu uruchomiony<br>';
    //wykrywanie ruchu...
  }
  private function wykrytoRuch() {
    print 'Wykryto ruch<br>';
    $this->zarowka->wlacz();
  }
  private function ruchZanikl() {
    print 'Ruch zanikl<br>';
    $this->zarowka->wylacz();
  }
}

33

Przykład 5

function test(Lampa $lampa) {
  $lampa->zapal();
  $lampa->zgas();
}

$zarowka = new Zarowka();
$lampkaNocna = new LampkaNocna ($zarowka);
test($lampkaNocna);
print '<br>';
$lampaOgrodowa = new LampaOgrodowa 
($zarowka);
test($lampaOgrodowa);

34

Wynik działania skryptu

Oto zgaszona żarówka !!!
Wkręcam żarówkę
Zapalam żarówkę...
Lampa zapalona
Gaszę żarówkę...
Lampa zgaszona

Wkręcam żarówkę
Czujnik ruchu uruchomiony
Zapalam żarówkę...
Lampa zapalona
Gaszę żarówkę...
Lampa zgaszona
I po żarówce ...

35

Wiele klas pochodnych

■

Klasa pochodna może mieć tylko jedną klasę 
bazową, ale może być klasą bazową dla wielu 
klas pochodnych

class Samochod {
// ...
}

class SamochodCiezarowy 

extrends

 Samochod {

// ...
}

class SamochodOsobowy 

extrends

 Samochod {

// ...
}

36

Nadpisywanie

■

Pola i metody dziedziczone z klasy bazowej mogą 
być nadpisywane w klasie pochodnej

class Zarowka {
   private $zapalona;
   public function __construct() {
      

print "Oto zgaszona żarówka !!!";

      $this->zapalona = False;
   }
   public function __destruct() {
      print "I po żarówce ...";
   }
   public function zapal() {
      print "Zapalam żarówkę...";
      $this->zapalona = True;
   }
// ...
}

37

Nadpisywanie

class ZarowkaEnergooszczedna extends Zarowka {
   public function __construct() {
      parent::__construct();
      

print "Energooszczędna !!!";

   }
   public function __destruct() {
      parent::__destruct();
      print "Utylizacja ...";
   }
   public function zapal() {
      parent::zapal();
      print "Taniej !!!";
   }
// ...
}

38

Składowe statyczne

■

Do deklarowania składowych statycznych służy 
słowo kluczowe static:

class Zarowka {
// ...
   private 

static

 $licznikZarowek = 0;

   public 

static

 function ileZarowek() {

      return $licznikZarowek;
   }
//...
}

Składowe  (pola  i  metody)  statyczne  są  to  składowe 

klasy,  które  nalezą  się  do  całej  klasy,  a  nie,  tak  jak 

zwykłe  składowe,  do  pojedynczej  instancji  (obiektu) 

klasy.

Składowe  (pola  i  metody)  statyczne  są  to  składowe 

klasy,  które  nalezą  się  do  całej  klasy,  a  nie,  tak  jak 

zwykłe  składowe,  do  pojedynczej  instancji  (obiektu) 

klasy.

39

Składowe statyczne

■

Ponieważ składowe statyczne należą do całej 
klasy, a nie do konkretnego obiektu, można ich 
używać nawet wtedy, kiedy nie istnieje żaden 
obiekt danej klasy.

■

Dostęp do składowych statycznych zapewnia 
operator zasięgu „::”

print Zarowka

::

ileZarowek();

40

Przykład 6

class Zarowka {
   

private static $licznikZarowek = 0;

   private $zapalona;
   public function __construct() {
      

print 'Oto zgaszona żarówka !!!<br>';

      $this->zapalona = False;
      

self::

$licznikZarowek++;

   }
   public function __destruct() {
      print 'I po żarówce ...<br>';

      self::

$licznikZarowek--;

   }
   public function zapal() {
      print 'Zapalam żarówkę...<br>';
      $this->zapalona = True;
   }
   public function zgas() {
      print 'Gaszę żarówkę...<br>';
      $this->zapalona = False;
   }

41

Przykład 6 cd.

   public function stan() {
      return $this->zapalona;
   }
   

public static function ileZarowek() {

      return 

self::

$licznikZarowek;

   }

}

function test() {
   

// w tym momencie nie istnieje jeszcze żaden      

   // obiekt klasy Zarowka !!!
   print Zarowka::ileZarowek().'<br>';

   $zr = new Zarowka();
   

print Zarowka::ileZarowek().'<br>';

   $zr->zapal();
   $zr->zgas();
   $zr2 = new Zarowka();
   

print Zarowka::ileZarowek().'<br>';

}

42

Wynik działania skryptu

0
Oto zgaszona żarówka !!!
1
Zapalam żarówkę...
Gaszę żarówkę...
Oto zgaszona żarówka !!!
2
I po żarówce ...
I po żarówce ...

43

Powtórzenie

■

Aby zdefiniować klasę pochodną, należy 
wykorzystać słowo kluczowe extends podając 
nazwę klasy bazowej.

■

Klasa pochodna może mieć tylko jedną klasę 
bazową, ale może być klasą bazową dla wielu 
klas pochodnych.

■

Klasa pochodna ma dostęp do wszystkich 
składowych swojej klasy bazowej i jej klas 
bazowych (jeśli istnieją), z wyjątkiem składowych, 
które zostały zadeklarowane jako prywatne.

■

Pola i metody dziedziczone z klasy bazowej mogą 
być nadpisywane w klasie pochodnej.

44

Powtórzenie

■

Dostęp do składowej klasy bazowej nadpisanej 
w klasie pochodnej można uzyskać za pomocą 
parent::

■

Aby zdefiniować składową w zasięgu klasy należy 
użyć static

■

Dostęp do składowych statycznych można 
uzyskać za pomocą parent::, self:: lub 
nazwa_klasy::