Объекты и классы в PHP

Инициализация переменных

Часто некоторым атрибутам класса бывает необходимо присваивать значения сразу после создания представителя класса. Когда мы создавали класс статей, для присваивания значений атрибутам ( свойствам ) класса мы использовали специальную функцию make_article(). Вообще говоря, мы поступили не совсем верно, потому что занялись изобретением велосипеда. Специально для задания начальных значений атрибутам класса существует два стандартных метода. В PHP4 можно инициализировать значения с помощью оператора var или с помощью функции конструктора. С помощью var можно инициализировать только константные значения. Для задания не константных значений используют функцию конструктор, которая вызывается автоматически, когда объект конструируется из класса. Функция- конструктор должна иметь имя, совпадающее с именем всего класса, в котором она определена.

Приведем пример. Допустим, при создании объекта "статья" мы хотим установить его свойства следующим образом: автора – равным строке "Иванов", название и краткое содержание – соответствующим элементам глобального массива $_POST, а дату публикации статьи – текущей дате. Тогда следующее описание класса не является корректным в PHP4:

<?
class Articles { // Создаем класс Статей
  var $title= $_POST["title"];
  var $author = "Иванов";
  var $description = $_POST["description"];
  var $published = date("Y-m-d");
// метод, который присваивает значения
// атрибутам класса
  }
?>

А вот такое описание класса в PHP4 будет работать так, как нужно:

<?
class Articles { // Создаем класс Статей
  var $title;
  var $author = "Иванов";
  var $description;
  var $published;
// метод, который присваивает значения
// атрибутам класса
 function Articles(){
  $this->title = $_POST["title"];
  $this->description = $_POST["description"];
  $this ->published = date("Y-m-d");
 }
//метод для отображения экземпляров класса
  function show_article(){
    $art = $this->title . "<br>" .
           $this->description .
      "<br>Автор: " . $this->author;
    echo $art;
  }
}
?>

Отметим, что в PHP3 и PHP4 конструкторы работают по-разному. В PHP3 функция становилась конструктором, если она имела то же имя, что и класс, а в PHP4 – если она имеет то же имя, что и класс, в котором она определена. Разница в подходах видна, когда один класс расширяет другой и происходит наследование свойств и методов базового класса. Но об этом мы поговорим чуть позже. В PHP5 конструктор класса именуется __construct. Кроме того, в PHP5 появились и деструкторы – функции, которые вызываются автоматически перед уничтожением объекта. В PHP5 функция-деструктор должна быть названа __destruct.

Объекты

В одной из первых лекций мы упоминали о существовании в PHP такого типа данных, как объект. Класс – это описание данных одного типа, данных типа объект. Классы являются как бы шаблонами для реальных переменных. Переменная нужного типа создается из класса с помощью оператора new. Создав объект, мы можем применять к нему все методы и получать все свойства, определенные в описании класса . Для этого используют такой синтаксис: $имя_объекта->название_свойства или $имя_объекта->название_метода(список аргументов). Заметим, что перед названием свойства или метода знак $ не ставят.

<?php
$art = new Articles; 
    // создаем объект $art
echo ($art ->title); 
    // выводим название объекта $art
$another_art = new Articles; 
    // создаем объект $another_art
$another_art->show_article(); 
    // вызываем метод для
    // отображения объекта в браузер
?>

Каждый из объектов класса имеет одни и те же свойства и методы. Так, у объекта $art и у объекта $another_art есть свойства title, description, author и методы Articles(), show_article(). Но это два разных объекта. Представим себе объект как директорию в файловой системе, а его характеристики – как файлы в этой директории. Очевидно, что в каждой директории могут лежать одинаковые файлы, но тем не менее они считаются различными, поскольку хранятся в разных директориях. Точно так же свойства и методы считаются различными, если они применяются к разным объектам. Чтобы получить нужный файл из директории верхнего уровня, мы пишем полный путь к этому файлу. При работе с классами нужно указывать полное имя функции, которую мы хотим вызвать. Директорией верхнего уровня в PHP будет пространство глобальных переменных, а путь указывается с помощью разделителя ->. Таким образом, имена $art->title и $another_art->title обозначают две разные переменные. Переменная в PHP имеет только один знак доллара перед именем, поэтому нельзя писать $art->$title. Эта конструкция будет рассмотрена не как обращение к свойству title объекта $art, а как обращение к свойству, имя которого задано переменной $title (например, $art->"" ).

<?php
$art->title = "Введение в Internet"; 
    // так можно установить
    // значение свойства объекта
$art->$title = "Введение в Internet"; 
    // так нельзя установить
    // значение свойства объекта
$property = "title";
$art->$property = "Введение в Internet"; 
    // так можно установить значение 
    // свойства объекта
?>

Создавая класс, мы не можем знать, какое имя будет иметь объект этого класса, тем более что объектов может быть много и все могут иметь разные имена. Соответственно мы не знаем, как обращаться к объекту внутри определения класса. Для того чтобы иметь доступ к функциям и переменным внутри определения класса, нужно использовать псевдопеременную $this. Например, $this->title возвращает значение свойства title у текущего объекта данного класса. Иногда эту переменную предлагают читать как "мое собственное" (к примеру, по отношению к свойству ).

Наследование

extends

Механизм наследования – очень важная часть всего объектно-ориентированного подхода. Попытаемся объяснить его суть на примере. Допустим, мы создаем описание человека. Очевидно, что сделать это мы можем по-разному, в зависимости от того, для чего нужно это описание. Можно описать человека как программиста: он знает такие-то языки программирования, операционные системы, участвовал в стольких-то проектах. Однако если человек программист, то он не перестает быть человеком вообще, т.е. он имеет имя, фамилию, место жительства и т.п. Если перевести наши рассуждения в термины объектно-ориентированного программирования, то можно сказать, что мы описали два класса – класс людей и класс программистов, каждый со своими свойствами и методами. Причем класс программистов, очевидно, обладает всеми свойствами класса людей и при этом имеет свои специфические характеристики, т.е. класс программистов является подклассом класса людей. Так, если у человека вообще есть имя, то у программиста оно тоже должно быть, но не наоборот. Кроме программистов можно выделить еще множество классов по профессиональной принадлежности людей. И все они будут подклассами класса людей. Часто на практике удобно определять общий класс, который может использоваться сразу в нескольких проектах (например, класс людей или личностей), и адаптировать его для специфических нужд каждого проекта (например, как класс программистов). Как это можно реализовать? С помощью механизма расширений. Любой класс может быть расширением другого класса. Расширяющий (или производный) класс, кроме тех свойств и методов, которые описаны в его определении, имеет все функции и свойства основного ( базового класса ). В нашем примере класс программистов – расширяющий, а класс всех людей – базовый. Из класса нельзя удалить никакие существующие свойства и функции, класс можно только расширить. Расширяющий класс в PHP4 всегда зависит только от одного базового класса, поскольку множественное наследование в PHP не поддерживается. Расширяются классы в PHP с помощью ключевого слова extends.

<?php
class Person { // определяем класс Личности
  var $first_name; // имя личности
  var $last_name; // фамилия личности
  function make_person($t,$a){ 
  // метод устанавливает
  // значения имени и фамилии объекта
    $this->first_name = $t;
    $this->last_name = $a;
  }
  function show_person(){ 
  // метод отображает информацию о личности
    echo ("<h2>" . $this->first_name . " " .
      $this->last_name . "</h2>");
  }
}
class Programmer extends Person{ 
    // определяем класс
    // Programmer, расширяющий Person
  var $langs = array ("Lisp"); 
    // константным массивом
    // задать переменную в var можно
    function set_lang($new_lang){ 
    // метод добавляет еще
    // один язык к списку известных
    $this->langs[] = $new_lang;
  }
}
?>

Класс Programmer имеет те же переменные и функции, что и класс Person, плюс переменную $langs, в которой содержится список изученных программистом языков, и функцию set_lang для добавления еще одного языка к списку изученных. Создать представителя класса программистов можно обычным способом с помощью конструкции new. После этого можно устанавливать и получать список языков, которые знает программист, и в то же время можно использовать функции, заданные для класса Person, т.е. устанавливать и получать имя и фамилию программиста и отображать сведения о нем в браузере:

<?php
$progr = new Programmer;
$progr->set_lang("PHP"); 
    // методы, определенные для
    // класса Programmer
print_r ($progr->langs);
// методы, определенные для класса Person
$progr->make_person("Bill","Gates");
$progr->show_person();
?>

Отношения, в которых состоят созданные нами классы Person и Programmer, называют также отношениями родитель–потомок. Класс Person – родитель, а его потомки, такие как класс Programmer, создаются, основываясь на нем, с помощью расширений. Любой класс может стать родительским и соответственно породить потомков.

Порядок определения классов имеет значение. Нельзя сначала определить класс Programmer, расширяющий класс Person, а уже потом сам класс Person. Класс должен быть определен перед тем, как он будет использоваться (расширяться).

Конструкторы

Теперь, после знакомства с механизмом наследования в PHP, мы можем прокомментировать различие между конструкторами PHP4 и PHP3 и более подробно рассказать о конструкторах вообще. Напомним, что в PHP3 конструктор – это функция, имя которой совпадает с именем класса. А в PHP4 – функция, имя которой совпадает с именем класса, в котором она определена.

<?php
class Programmer extends Person{ 
    // определяем класс
    // Programmer, расширяющий Person
  var $langs = array ("Lisp");
  function Programmer(){ 
    // этот конструктор будет
    // работать и в PHP3, и в PHP4
    $this->make_person("Иван","Петров");
  }
}
?>

Здесь функция Programmer() является конструктором, т.е. выполняется сразу после создания любого представителя класса Programmer, задавая ему имя "Иван" и фамилию "Петров". Конструкторы, как и любые другие функции, могут иметь аргументы. В этом случае, создавая представителя класса, нужно указать значения этих параметров. Аргументы конструктора могут иметь и значения по умолчанию. Если все аргументы имеют значения по умолчанию, тогда можно создавать экземпляр класса без параметров.

<?php
class Programmer extends Person{ 
    // определяем класс
    // Programmer, расширяющий Person
  var $langs = array ("Lisp");
  function Programmer($n = "Иван", 
                      $f = "Петров"){
    // это конструктор
    $this->make_person($n,$f);
  }
}
$default_progr = new Programmer(); 
    // создаст программиста Ивана Петрова
$new_progr = new Programmer("Вася",
                            "Сидоров");
    // создаст программиста Васю Сидорова
print_r($new_progr); 
/* выведет информацию о переменной 
$new_progr, т.е. свойства объекта 
и их значения */
?>

Приведенные примеры будут работать и в PHP3, и в PHP4, конечно если дописать в них определение базового класса Person. Допустим, ситуация немного другая: конструктор имеется только у базового класса Person:

<?php
class Person { // определяем класс Личности
  var $first_name;
  var $last_name;
  function Person($t,$a){ // конструктор
    $this->first_name = $t;
    $this->last_name = $a;
  }
        /* ...        */
}
class Programmer extends Person{ 
    // определяем класс
    // Programmer, расширяющий Person
  var $langs = array ("Lisp");
  function set_lang($new_lang){
    $this->langs[] = $new_lang;
  }
}
$new_progr = new Programmer("Вася",
                            "Сидоров");
?>

Что произойдет в этом случае при создании объекта класса Programmer, будет ли автоматически вызвана какая-либо функция? В PHP3 ничего не произойдет, поскольку в этом классе нет функции с именем Programmer() (здесь конструктор – это функция, имя которой совпадает с именем класса ). В PHP4 будет вызван конструктор базового класса, если он существует, т.е. вызовется функция Person() из класса Person (здесь конструктор – функция, имя которой совпадает с именем класса, в котором она определена).

Еще одна ситуация – в базовом классе есть функция, имя которой совпадает с именем расширяющего класса, а в расширяющем классе нет конструктора.

<?php
class Person { // определяем класс Личности
  var $first_name;
  var $last_name;
  function Person($t,$a){ // конструктор
    $this->first_name = $t;
    $this->last_name = $a;
  }
  function Programmer($new_lang){
    echo "Я – программист";
  }
}
class Programmer extends Person{ 
    // определяем класс
    // Programmer, расширяющий Person
  var $langs = array ("Lisp");
  function set_lang($new_lang){
    $this->langs[] = $new_lang;
  }
}
$new_progr = new Programmer("Вася",
                            "Сидоров");
?>

В этом случае PHP3 вызовет в качестве конструктора функцию Programmer() из описания класса Person. Поскольку конструктор – это функция, у которой то же имя, что и у класса. И неважно, определена ли эта функция в самом классе или она наследуется из базового класса. В PHP4 класс Programmer не будет иметь своего конструктора, поэтому вызовется конструктор базового класса.

Ни в PHP 3, ни в PHP 4 конструктор базового класса не вызывается автоматически из конструктора порожденного класса.

Оператор ::

Иногда внутри описания класса возникает необходимость сослаться на функции или переменные из базового класса. Бывает, что нужно ссылаться на функции в классе, ни один представитель которого еще не создан. Как быть в таком случае? В PHP4 для этого существует специальный оператор "::"

Например, вот так можно вызвать в описании класса Programmer функцию show_name() из базового класса Person и функцию say_hello(), заданную в описании класса Programmer, когда ни один объект этого класса еще не был создан:

<?php
class Person { // определяем класс Личности
  var $first_name;
  var $last_name;
  function Person($t,$a){ // конструктор
    $this->first_name = $t;
    $this->last_name = $a;
  }
function show_name(){ 
  // метод отображает информацию о личности
    echo ("Меня зовут, " . 
          $this->first_name . " " .
          $this->last_name . "!<br>");
  }
}
class Programmer extends Person{ 
    // определяем класс
    // Programmer, расширяющий Person
  function set_lang($new_lang){ 
    // метод добавляет еще
    // один язык к списку известных
    $this->langs[] = $new_lang;
    Person::show_name(); 
    // вызываем функцию из базового класса
    echo "И я знаю теперь еще и " . 
          $new_lang;
  }
  function show_name(){
  echo ("Я программист, " . 
        $this->first_name . " " .
        $this->last_name . "!<br>");
  }
  function say_hello(){
    echo "Привет!<br>";
  }
}
Programmer::say_hello(); 
    // вызываем функцию, когда ни
    // один объект ее класса еще не создан
$new_progr = new Programmer("Вася","Сидоров");
$new_progr->set_lang("PHP");
?>

В результате работы этой программы получим следующее:

Привет!
Меня зовут Вася Сидоров!
И я знаю теперь еще и PHP

С помощью команды Programmer::say_hello(); мы вызываем функцию say_hello класса Programmer как таковую, а не как метод, применяемый к объекту данного класса. В этот момент переменных класса нет. Поэтому функции, вызываемые до создания объекта, не могут пользоваться переменными класса и конструкцией this, но могут пользоваться локальными и глобальными переменными.

В определении класса Programmer мы переопределили функцию show_name(), поэтому вызвать функцию show_name() из базового класса Person можно только с помощью оператора "::" Вообще говоря, внутри определения класса мы можем вызывать любые методы и свойства, заданные в его базовом классе с помощью обычного $this, если только порожденный класс не переопределяет эти свойства и методы, как в нашем примере.

Оператор parent

В приведенном выше примере, обращаясь к базовому классу, мы использовали его имя (мы писали Person::show_name() ). Это не совсем удобно, потому что имя класса или иерархия классов может измениться, и тогда придется переписывать код описаний всех классов с тем, чтобы привести используемые в них имена в соответствие с новой иерархией. Чтобы избежать подобной ситуации, вместо имени базового класса нужно использовать ключевое слово parent (например, parent::show_name() ). Parent ссылается на класс, прописанный после extends в объявлении вашего класса. Поэтому если вдруг иерархия классов изменится, то достаточно будет внести изменения в имена, указанные после extends в описаниях классов.

Объектная модель PHP5

Кроме нового названия для конструкторов и появления деструкторов в PHP5 произошло еще достаточно много изменений. Мы не будем обсуждать их подробно, только опишем в общих чертах. Основное изменение – это передача значений параметров класса по ссылке и присвоение объектов по ссылке, а не по значению, как это было в PHP4. В PHP5 если создаются две равные переменные типа объект, то они указывают на одно значение и изменяются одновременно (мы приводили похожий пример с переменными строкового типа). В связи с этим появился новый механизм для создания копий объектов – так называемое клонирование. В PHP4 все методы и переменные класса доступны извне, т.е. они всегда являются открытыми. В PHP5 переменные и методы можно делать открытыми (доступными отовсюду), закрытыми (доступными только внутри класса ) и защищенными (доступными внутри класса и в его производных классах ). Кроме того, появилась возможность создавать интерфейсы и абстрактные классы и многое другое. В целом объектная модель в PHP5 значительно усовершенствована для более точного соответствия объектно-ориентированной парадигме программирования.

Решение задачи

Итак, мы хотели по выбору пользователя генерировать форму для ввода описания статьи или человека и отображать данные, введенные в эту форму. Попробуем решить эту задачу, используя объектно-ориентированный подход. Для начала создадим форму, где пользователь выбирает, что он хочет создать, – описание статьи или человека (точнее, это будут две формы):

<form action="task1.php">
Создать описание статьи: <input type=submit
    name=art_create
    value="Create Article">
</form>
<form action="task1.php">
Создать описание личности: <input 
   type=submit name=pers_create 
   value="Create Person">
</form>

Теперь напишем файл для обработки этих форм. В нем создадим два класса – статьи и личности. У каждого класса имеется метод для инициализации его переменных и метод для отображения объектов данного класса. При решении задачи будут использованы две функции, встроенные в PHP для работы с классами и объектами. Это функция get_class (объект), возвращающая имя класса, экземпляром которого является объект, переданный ей в качестве параметра. И функция get_class_vars (имя класса ), которая возвращает массив всех свойств класса и их значений по умолчанию. Аналогично можно получить массив имен всех методов класса: get_class_methods (имя класса )

<?php
// Создаем классы Статей и Личностей. 
// Статья имеет заголовок, автора и 
// описание. Личность имеет имя, фамилию
// и e-mail
class Article {
  var $title;
  var $author;
  var $description;
// метод, который присваивает значения
// атрибутам класса
  function Article($t="Название отсутствует",
      $a="Автор отсутствует",
      $d="Описание отсутствует"){
    $this->title = $t;
    $this->author = $a;
    $this->description = $d;
  }
//метод для отображения экземпляров класса
  function show(){
   $art = "<h2>$this->title</h2><font
   size=-1>$this->description</font><p>Автор:
   $this->author</p>";
    echo $art;
  }
}
// Определение класса Личностей
class Person {
  var $first_name;
  var $last_name;
  var $email;
//метод, который присваивает значения атрибутам класса
  function Person($t="Имя не введено",
    $a="Фамилия не введена",$d="Email не указан"){
    $this->first_name = $t;
    $this->last_name = $a;
    $this->email = $d;
  }
//метод для отображения экземпляров класса
  function show(){
    $art = "<h2>$this->first_name</h2><font
      size=-1>$this->last_name</font><p>e-mail:
$this->email</p>";
    echo $art;
  }
}
// Далее следует собственно создание и отображение
// экземпляров выбранного класса
if (isset($_GET["art_create"])){ //Если была выбрана статья
  $art = new Article; // создаем представителя класса статей
  $art_vars = get_class_vars(get_class($art)); //какие
                      // аргументы этого класса нужно задать
  Make_form($art,$art_vars,"art_create"); //вызов функции
                      // создания формы
  if (isset($_GET["create_real"])){ Show_($art_vars); }
  // если данные этой формы отправлены, то вызываем
  // функцию показа
}
//то же самое, если была выбрана личность
if (isset($_GET["pers_create"])){
  $art = new Person;
  $art_vars = get_class_vars(get_class($art));
  Make_form($art,$art_vars,"pers_create");
  if (isset($_GET["create_real"])){ Show_($art_vars); }
}
// функция создания формы
function Make_form($art,$art_vars,$glob){
  $str = "<form>";   // html код формы записывается
                     // в строку $str
  //перебираем список переменных класса объекта $art
  foreach ($art_vars as $var_name => $var_value){
    $str .="$var_name<input type=text name=$var_name><br>";
    //создаем элемент формы с именем свойства класса
  }
  $str .= "<input type=hidden name=$glob>"; // чтобы не
                                   // забыть, что мы создаем
  $str .= "<input type=submit name=create_real
    value='Create and Show'></form>";
echo "$str";   // выводим форму
}
// функция показа объекта
function Show_($art_vars){
  global $art; //используется глобальное имя объекта
  $k = count($art_vars); //число свойств класса
                         // (переменных в форме)
  $p=0; //вспомогательная переменная
  foreach ($art_vars as $name => $value){
    $p++;
      if ($_GET["$name"]=="") $val= $art->$name;
      else $val = $_GET["$name"];
      if ($p<>$k) $par .='"'. $val.'",';
      else $par .='"'. $val.'"';
  }
  $const=get_class($art);
  $par = '$art->'.$const ."(" .$par.");";
  // теперь $par представляет собой php-код для вызова
  // метода класса $art, изначально
  // записанного в $par
  // например,
  // $art->Person('Vasia','Petrov','vas@intuit.ru');
  eval($par); // функция eval выполняет код,
              // содержащийся в $par
  $art->show();
}
?>

Заключение

Итак, мы изучили основные понятия объектной модели, используемой в языке PHP. Были описаны правила создания классов и их представителей-объектов, способы задания начальных значений переменным класса, способы получения значений свойств и вызов методов классов.