Рейтинг@Mail.ru
 
Самое начало

PHP - очень демократичный язык. Достаточно прочитать какой нибудь букварь или посмотреть сомнительный видеокурс, и можно уже собрать вполне рабочий простенький сайт. И это хорошо, как бы не возмущались с пеной у рта функционеры от программирования, обзывая всех быдлокодерами. Не всем нужно становиться профессиональными программистами. Многим вполне достаточно начальных знаний, что бы радоваться своей собственной страничке в интернете.

Но те, кто не останавливается на достигнутом, рано или поздно встречаются с таким синтаксисом, который не описан в пособиях для начинающих. И впадают в ступор. Что это за стрелочки, что за непонятные $this-> и так далее.

На самом деле это совсем не страшно, Достаточно понять один раз.

Попытаемся. Начнем с самого нуля.

И так, вот это простой, процедурный код:
1
2
3
4
5
<?php

    echo 'Привет, Мир!';


Вот это чуть посложнее - функция. Нам уже известная.
1
2
3
4
5
6
7
8
9
10
<?php

    
function helloWorld() 
    { 
        return 
'Привет, Мир!';     
    } 
     
    echo 
helloWorld();

Результат один и тот же, просто другая реализация.

А вот и то, чем пугают маленьких детей - класс.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php

    
class My_First_Class 
    

        function 
helloWorld() 
        { 
            return 
'Привет, Мир!';     
        } 
    } 
     
     
    
$obj = new My_First_Class();
     
    echo 
$obj -> helloWorld();


Прослеживаете эволюцию? Сначала команду поместили в одну обертку - функцию, потом функцию поместили в класс.
Функция в классе называется метод. На примере не трудно разглядеть, как этот метод вызывается.

Но по порядку. Для того, что бы отправить строку в поток, мы использовали конструкцию echo. Это понятно.
Для того, что бы вернуть строку из функции, используется return и прямой вызов функции. Тоже ничего особенного.

А вот дальше появляются непонятные стрелочки. Дело в том, что класс, это как бы отдельная программа, которую можно записать в переменную. Называется объект.
То есть мы что сделали. Сначала в переменную $obj поместили эту программу (экземпляр класса), затем нам нужно из этого экземплра вызвать функцию (метод). Вот это и делается стрелочкой.
Вот так вызывается функция из глобальной области видимости:
1
2
3
4
5

echo helloWorld();


а так из объекта, который мы поместили в переменную $obj:
1
2
3
4
5
6
7

    $obj 
= new My_first_class();
      
    echo 
$obj -> helloWorld();


Теперь дальше. Для чего было нужно совать функцию в класс? Не ради красивого словца же. (Хотя встречаются и такие, кто любую, самую простенькую штатную конструкцию типа echo, одевают в три фуфайки, дабы код выглядел особо крутым, как первый парень на деревне).

Дело в том, что в классе может находиться несколько функций (методов). Для наглядности сделаем второй метод:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php

    
class My_first_class 
    

        function 
helloWorld() 
        { 
            return 
'Привет, Мир!';     
        } 
         
        function 
goodBye() 
        { 
            return 
'Всем пока.';     
        }                 
    } 
     
     
    
$obj = new My_first_class();
     
    echo 
$obj -> helloWorld(), '<br>'
    echo 
$obj -> goodBye();


Эти методы:
a) могут взаимодействовать между собой
б) им доступны общие переменные, которые видны только внутри класса и не видны снаружи.

Тот кто то читал лирическое вступление, должен понять, какие выгоды это несет. Не будет конфликтов имен, если программа достаточно большая и плохо контролируемая.

Кроме того, в методы, так же как и в обычные функции, можно передать аргументом значения переменных. Как это все выглядит в натуральную величину.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php

    
class My_first_class 
    

        function 
helloWorld($name
        { 
            return 
'Привет, '$name .'!';     
        } 
         
        function 
goodBye($name
        { 
            return 
'Будь здоров, '$name .'!';     
        }                 
    } 
     

    
$name 'Денис'
     
    
$obj = new My_first_class();
     
    echo 
$obj -> helloWorld($name), '<br>'
    echo 
$obj -> goodBye($name); 


Так вот, если имя одно, то нет необходимости передавать его в каждый метод. Достаточно сделать это один раз, а потом организовать внутриклассовую переменную:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php

    
class My_first_class 
    

        function 
helloWorld($name
        { 
            
$this->name $name
            return 
'Привет, '$name .'!';     
        } 
         
        function 
goodBye() 
        { 
            return 
'Будь здоров, '$this->name .'!';     
        }                 
    } 
     

    
$name 'Денис'
     
    
$obj = new My_first_class();
     
    echo 
$obj -> helloWorld($name), '<br>'
    echo 
$obj -> goodBye();


Вот она и попалась, эта непонятная $this->
Фокус в том, что внутри класса переменная объявляется не просто знаком доллара, а этой конструкцией. Всего то навсего.
То есть если внутри метода переменная обычная ($name), то она, как и в простой функции, видна только внутри метода. А если ей приляпать это: ($this->name), то её будет видно во всех методах, но не за пределами класса.
Важно помнить - это совершенно разные переменные, хоть и одинаково называются.

Вот мы можем спокойно попрощаться, не успев поздороваться. Имя будет иметь место, хотя в метод мы ничего не передавали.

Но тут есть подвох. Дело в том, что если мы захотим использовать только второй метод (допустим Денис, не приведи Господи, чихнул), то имени уже не будет. Так как присвоение идет в первом методе, а мы не здоровались, потому что со вчерашнего под хорошую закуску расстаться не можем к примеру.

Как быть? А очень просто. Можно передать значение прямо в сам класс. Если сделать метод с таким же как класс названием:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php

    
class My_first_class 
    

        function 
My_first_class($name
        { 
            
$this->name $name;    
        }         
         
        function 
helloWorld() 
        { 
            return 
'Привет, '$this->name .'!';     
        } 
         
        function 
goodBye() 
        { 
            return 
'Будь здоров, '$this->name .'!';     
        }                 
    } 
     

    
$name 'Денис'
     
    
$obj = new My_first_class($name); 
         
    echo 
$obj -> helloWorld(), '<br>'
    echo 
$obj -> goodBye();


Вообще так было в 4-й версии PHP, хотя в пятой тоже работает. Но в пятой, более продвинутой, придумали специальный метод, который обязательно вызывается при инициализации объекта. Называется "конcтруктор" (__construct()). Делается так:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php

    
class My_first_class 
    

        function 
__construct($name
        { 
            
$this->name $name;    
        }         
         
        function 
helloWorld() 
        { 
            return 
'Привет, '$this->name .'!';     
        } 
         
        function 
goodBye() 
        { 
            return 
'Будь здоров, '$this->name .'!';     
        }                 
    } 
     

    
$name 'Денис'
     
    
$obj = new My_first_class($name); 
         
    echo 
$obj -> helloWorld(), '<br>'
    echo 
$obj -> goodBye();


В конструкторе можно инициализировать внутриклассовые переменные, вызвать функции, методы или сделать другие действия. Важно что это сработает сразу, как только мы запустим эту строчку:
1
2
3
4
5

    $obj 
= new My_first_class($name);


Есть еще деструктор (__destruct())Это метод, вызываемый перед уничтожением объекта. Пишется в конце класса и нужен для того, что бы прибраться там, где класс успел нагадить - освободить память, закрыть соединение с базой данных к примеру или еще чего.

Ну вот, основной принцип такой. Дальше попробуем разобраться с уровнями доступов, способами обращения к методам и переменным, и пошло-поехало развеевать туман полиморфизм-наследование-инкапсуляция, интерфейсы и иже с ними.

Наберитесь терпения.