У Вас в браузере заблокирован JavaScript. Разрешите JavaScript для работы сайта!

Объектное программирование

Объектно-ориентированное программирование (ООП) на PHP

Объект - это набор специальных переменных - свойств и специальных функций - методов . То, что в процедурном программировании называлось переменной - в ООП называется свойство. То, что в процедурном программировании называлось функцией - в ООП называется методом класса. Созданные на основе класса объекты называются экземплярами класса или просто объекты.

Обращение из метода к свойствам только через служебное слово $this: $this->name; (обратите внимание на отсутствие знака доллара перед name) Обращение внутри метода к другому методу тоже через $this: $this->foo(); Для доступа к свойствам и методам объекта служит оператор "->": $this->name; (обратите внимание на отсутствие знака доллара перед name)
Обращение внутри метода к другому методу тоже через $this: $this->foo(); . Объект создается с помощью оператора new на основании шаблона, называемого классом . Класс определяется ключевым словом class .

Пример 1

".$this->имя."! Привет!"; } function Пока($a) { $this->имя = $a; echo "

".$this->имя."! Пока!

"; } } $obj = new классN1(); $obj->Привет(); $obj->имя = "Миша"; $obj->Привет(); $obj->Пока("Яша"); $obj->Привет(); ?>

Модификаторы доступа в ООП :

• public - позволяет иметь доступ к свойствам и методам из любого места (глобальная область)
• protected - доступ к родительскому и наследуемому классу (область класса наследника)
• private - доступ только из класса, в котором объявлен сам элемент (область самого класса)

Метод по умолчанию - public. У свойств значения модификатора по умолчанию нет.

Константы класса в ООП

const NAME = 2; Таким образом можно создавать константы и вне класса. Это именно константы класса, они не принадлежат ни одному объекту, они общие на все объекты, поэтому использование внутри метода: function printname(){ echo self::NAME; } self - это сам класс! Обращение вне класса (можно вызывать из глобальной области видимости без инициализации экземпляра класса): echo OurClass::NAME;

this и self

Внутри класса использована специальная переменная this . Это указатель, с помощью которого объект может ссылаться на самого себя.

Для обращения к статическим методам используется self::

Методу Пока передан аргумент точно так же, как и обычной функции. При вызове этого метода объект меняет свое свойство имя.

РЕЗУЛЬТАТ ПРИМЕРА 1:

Маша! Привет!

Миша! Привет!

Яша! Пока!

Яша! Привет!

Конструктор - это метод, который автоматически вызывается при создании нового объекта: public function __construct(){} . При инициализации6 объекта через служебную конструкцию new, PHP ищет __construct и если он есть, то вызывается.

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

Пример 2

имя = $a; } function Привет() { echo "

".$this->имя."! Привет!

"; } } $obj0 = new классN2(); $obj1 = new классN2("Миша"); $obj2 = new классN2("Маша"); $obj0->Привет(); $obj1->Привет(); $obj2->Привет(); ?>

РЕЗУЛЬТАТ ПРИМЕРА 2:

Кто-то там! Привет!

Миша! Привет!

Маша! Привет!

Сложив все, изложенное выше, можно создать более осмысленный класс. Например, класс, который будет располагать данные в виде таблицы с поименнованными столбцами.

Пример 3

headers = $headers; } function addRow ($row) { $tmp = ; foreach ($this->headers as $header) { if (! isset($row[$header])) $row[$header] = ""; $tmp = $row[$header]; } array_push ($this->

";
 foreach ($this->
";
 foreach ($this->
";
 }
 echo "

"; } } $test = new Table (array("a","b","c")); $test->addRow(array("a"=>1,"b"=>3,"c"=>2)); $test->addRow(array("b"=>1,"a"=>3)); $test->addRow(array("c"=>1,"b"=>3,"a"=>4)); $test->output(); ?>

Свойства класса Table - массив имен столбцов таблицы и двумерный массив строк данных. Конструктор класса Table получает массив имен столбцов таблицы. Метод addRow добавляет в таблицу новую строку данных. Метод output выводит таблицу на экран.

РЕЗУЛЬТАТ ПРИМЕРА 3:

a b c 1 3 2 3 1 4 3 1

Скрытые свойства и методы

Свойства и методы класса могут быть как открытыми (public), так и скрытыми (private). Скрытые свойства и методы недоступны извне класса, т.е. из сценария, в котором используется данный класс, или из другого класса.

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

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

Чтобы создать новый класс, наследующий поведение существующего класса, надо использовать ключевое слово extends в его объявлении. Например:

Class классN2 extends классN1 { ....... }

Здесь классN1 - родительский класс, классN2 - производный.

Если производный класс не содержит собственного конструктора, то при создании его объекта используется конструктор родительского класса. Если в производном класса существует собственный конструктор, то конструктор родительского класса не вызывается. При необходимости вызвать конструктор родительского класса это надо сделать явно. Например:

КлассN1::классN1();

Производный класс будет иметь все свойства и методы родительского класса. Но их можно и переопределить в производном классе.

Пример 4

".$this->имя."! Привет!"; } } class классN4 extends классN3 { function Привет() { echo "

".$this->имя."! Какая встреча!

"; } } $obj = new классN4(); $obj->Привет(); ?>

Метод Привет переопределен для производного класса. Свойство имя наследуется от родительского.

РЕЗУЛЬТАТ ПРИМЕРА 4:

Маша! Какая встреча!

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

Пример 5

".$this->имя."! Привет!"; } function Пока() { echo "

".$this->имя.", пока!

"; } } /** * Class классN6 */ class классN6 extends классN5 { /** * */ function Привет() { echo "

".$this->имя."! Какая встреча!

"; классN5::Привет(); } } $obj = new классN6(); $obj->Привет(); $obj->Пока(); ?>

РЕЗУЛЬТАТ ПРИМЕРА 5:

Маша! Какая встреча!

Маша! Привет!

Маша, пока!

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

В следующем примере создан класс HTMLTable , основанный на классе Table из примера 3. Новый класс формирует данные, сохраненные методом addRow родительского класса, и выводит их в HTML-таблицу. Свойства $cellpadding и $bgcolor дают возможность изменять соответствующие аргументы, при этом переменной $cellpadding присваивается значение по умолчанию, равное 2.

Пример 6

headers = $headers; } function addRow ($row) { $tmp = ; foreach ($this->headers as $header) { if (! isset($row[$header])) $row[$header] = ""; $tmp = $row[$header]; } array_push ($this->data, $tmp); } function output () { echo "

";
 foreach ($this->headers as $header) echo "$header ";
 echo "
";
 foreach ($this->data as $y)
 {
 foreach ($y as $x) echo "$x ";
 echo "
";
 }
 echo "

"; } } class HTMLTable extends Tables { public $cellpadding = "2"; public $bgcolor; function HTMLTable ($headers, $bg="FFFFFF") { Tables::Tables($headers); $this->bgcolor = $bg; } function setCellpadding ($padding) { $this->cellpadding = $padding; } function output () { echo "cellpadding."">"; foreach ($this->headers as $header) echo ""; foreach ($y as $x) echo "

bgcolor."">".$header; foreach ($this->data as $y) { echo "
bgcolor."">$x"; } echo "

"; } } $test = new HTMLTable (array("a","b","c"), "#00FFFF"); $test->setCellpadding (7); $test->addRow(array("a"=>1,"b"=>3,"c"=>2)); $test->addRow(array("b"=>1,"a"=>3)); $test->addRow(array("c"=>1,"b"=>3,"a"=>4)); $test->output(); ?>

Обратите внимание на то, что значение свойства сellpadding меняется с помощью отдельного метода setCellpadding . Конечно, значения свойств можно менять непосредственно, вне объекта:

$test->сellpadding = 7 ;

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

РЕЗУЛЬТАТ ПРИМЕРА 6:

a	b	c
1	3	2
3	1
4	3	1

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

Удаление объектов

Удалить ранее созданный объект можно следующим образом:

Unset($objName);

Ниже приведен пример, в котором объект класса Саг создается, а затем удаляется.

$myCar = new Car; unset($myCar);

После вызова функции unset() объект больше не существует. В РНР имеется специальный метод __destruct(), который автоматически вызывается при удалении объекта. Ниже приведен класс, содержащий этот метод.

Class Bridge { function __destruct() { echo "Мост разрушен"; } } $bigBridge = new Bridge; unset($bigBridge);

При создании объекта класса Bridge, а затем его удалении отобразится следующее сообщение:

Мост разрушен

Оно отображается вследствие вызова метода __destruct() при вызове функции unset(). При удалении объекта может потребоваться акрыть некоторые файлы или записать информацию в базу данных.

Копирование (клонирование) объекта

Клонирование объекта:

$a = clone $b;

Конструктор не вызывается при клонировании, вызывается магический метод __clone() {} . Он НЕ принимает аргументов и к нему нельзя обратиться как к методу.

Преобразование объекта в строку

Для конвертации объекта в строку, и обратно, используются следующие функции:
serialize() - принимает объект и возвращает строковое представление его класса и свойств;
unserialize() - принимает строку, созданную при помощи serialize(), и возвращает объект.

serialize() и unserialize() работают со всеми типами данных, но они не работают с ресурсами.

Специальные методы для обслуживания функций serialize() и unserialize():
__sleep() - вызывается строго перед тем, как объект сериализуется с помощью функции serialize(). Функция __sleep() должна будет вернуть список полей класса, которые функция serialize() включит в возвращаемую строку. Вы можете использовать это для того, чтобы исключить ненужные поля из строкового представления объекта. Например:

Public function __sleep() { // почистить return array_keys(get_object_vars($this)); } __wakeup() - вызывается сразу после того, как объект десериализуется с помощью unserialize().

Абстрактный класс

Абстрактный класс - это класс, который не может быть реализован, то есть, вы не сможете создать объект класса, если он абстрактный. Вместо этого вы создаете дочерние классы от него и спокойно создаете объекты от этих дочерних классов. Абстрактные классы представляют собой шаблоны для создания классов. abstract class Person { private $firstName = ""; private $lastName = ""; public function setName($firstName, $lastName) { $this->firstName = $firstName; $this->lastName = $lastName; } public function getName() { return "$this->firstName $this->lastName"; } abstract public function showWelcomeMessage(); /* абстрактный метод showWelcomeMessage(). Так как он абстрактный, в нем нет ни строчки кода, это просто его объявление. Любой дочерний класс обязан добавить и описать метод showWelcomeMessage() */ }

Интерфейс

Интерфейс - это шаблон, который задает поведение одного или более классов. Вот основные отличия между интерфейсами и абстрактными классами:

• Ни один метод не может быть описан в интерфейсе. Они все абстрактны. В абстрактном классе могут быть и не абстрактные методы.
• Интерфейс не может содержать полей - только методы.
• Класс имплементирует интерфейс, и класс наследует или расширяет другой класс.
• Класс может имплементировать несколько интерфейсов одновременно. Этот же класс может наследовать другой класс. Но у дочернего класса может быть только один супер-класс (абстрактный или нет).

interface MyInterface { public function aMethod(); public function anotherMethod(); } class MyClass implements MyInterface { public function aMethod() { // (имплементация метода) } public function anotherMethod() { // (имплементация метода) } }

Методы-перехватчики (магические методы)

Пример использования необъявленных свойств класса

Где и зачем могут быть использованны методы-перехватчики?

Например есть у вас таблица в базе данных, называется user и есть в ней некие поля, например id, name, email, phone, password, avatar И Вы создали класс на для работы с юзерами, так его и назвали - User

Какие свойства будут у данного класса? Если вы сделаете такие же как в БД - id, name, email и так далее, то получается что при каждом изменении базы данных - вам нужно менять код в классе User, как то не очень удобно. Добавили вы например поле site - значит нужно его добавлять и в класс User, ну и так далее.
Используя же методы __get() и __set() Вы можете это всё автоматизировать. У вас в классе User вообще не будет ни одного свойства из БД, у нас есть допустим только одно $data - мы туда взяли, да и загрузили всё что есть в базе данных на данного пользователя. А потом, когда программист что то запрашивает, например $user->email мы просто в __get() методе можете посмотреть - если мы такую информацию загрузили из БД, и она лежит в $data["email"] - то вот мы её вам и возвращаем. А в __set() наоборот. Есть такое поле в БД? Значит присвоим ему новое значение.

/** * Class User * @property-read integer id текущего пользователя * @property-write String site возвращает ссылку на сайт пользователя */ class User { private $data; private $f_write=false; public function __set($name, $value) { $this->data[$name] = $value; $this->f_write=true; // признак, что нужно сохранить данные } public function __get($name) { if(empty($data)){ // читаем запись из БД в data } return $this->data[$name]; } function __destruct() { if(!empty($data)&&$this->f_write){ // сохраняем изменения в БД } } } $user=new User(); $user->site="http://kdg.сайт/"; //присваеваем переменной echo $user->site; //выводим значение переменной // записываем в БД. Можно это явно не делать, т.к. при окончании работы скрипта это поизойдет автоматически unset($user);

Пример использование необъявленного свойства класса как элемент массива

Обратите внимание на то, что из __get возвращается ссылка:

Class Foo { private $data = ; public function __set($name, $value) { $this->data[$name] = $value; } public function & __get($name) { return $this->data[$name]; } } $foo = new Foo(); $foo->bar = "lol"; var_dump($foo->bar);

Использоватние перехватчиков обращения к необъявленным методам класса

class OurClass { public function __call($name,array $params) { echo "Вы хотели вызвать $Object->".$name.", но его не существует, и сейчас выполняется ".__METHOD__."()"; return; } public static function __callStatic($name,array $params) { echo "Вы хотели вызвать ".__CLASS__."::".$name.", но его не существует, и сейчас выполняется ".__METHOD__."()"; return; } } $Object=new OurClass; $Object->DynamicMethod(); OurClass::StaticMethod();

Пример обхода закрытых метов класса:

Class _byCallStatic{ // Пример обхода "закрытых" методов класса, // при использовании метода "__callStatic()" для вызова статического метода. public static function __callStatic($_name, $_param) { return call_user_func_array("static::". $_name, $_param); } private static function _newCall(){ echo "Method: ". __METHOD__; } } echo _byCallStatic::_newCall(114, "Integer", 157); # Результат: Method: _byCallStatic::_newCall

Как вызвать через статический метод любой динамический:

/** * Class o * @method static void __f(int $a1 = 1) */ class o { public static function __callStatic($method, $args) { $class = get_called_class(); $obj = new $class($args); $method = substr($method, 2); $pass = array_slice($args,1); $reflection = new ReflectionMethod($obj, $method); return $reflection->invokeArgs($obj, $pass); } public function f($a1 = 1) { var_dump("oo", func_get_args()); } } class a extends o { public function f($a1 = 1, $a2 = 2) { var_dump("aa", $a1); } } class b extends o { public function f($b1 = 1) { var_dump("bb", $b1); } } a::__f(1,2,3); b::__f(4,5,6);

Полезное описание работы с ReflectionClass, когда вы можете проанализировать свойства и методы класса, проверить параметры по шаблонам и т.д.: http://habrahabr.ru/post/139649/

Как использовать объект как функцию?

class Dog { private $name; public function __construct($dogName = "Тузик") { $this->name = $dogName; } public static function __invoke() { $args = func_get_args(); echo "Собака получила: " . implode(" и ", $args); } } $dog = new Dog("Мухтар"); $dog("кость", "поводок");

Собака получила: кость и поводок

Как обращаться к объекту как к массиву?

Для этого необходимо создать такой объект который реализует интерфейс ArrayAccess из SPL. Следующий пример реализует объект доступ к данным которого можно получать как в стиле обращения к массиву, так и через получение свойств:

Class MyArray implements ArrayAccess { protected $arr = array(); public function offsetSet($key, $value) { $this->arr[$key] = $value; } public function offsetUnset($key) { unset($this->arr[$key]); } public function offsetGet($key) { return $this->arr[$key]; } public function offsetExists($key) { return isset($this->arr[$key]); } public function __get($key) { return $this->offsetGet($key); } public function __set($key, $val) { $this->offsetSet($key, $val); } } $a = new MyArray(); $a["whoam"] = "Я значение массива, или объекта?
"; echo $a["whoam"]; echo $a->whoam;

Я значение массива, или объекта? Я значение массива, или объекта?

Автозагрузка классов

Файлы автозагружаемых классов обычно располагаются в общем месте, например в /include/class/. Имя файла формируется в формате ИМЯ_КЛАССА.php. Данный код необходимо подключить во все PHP-скрипты: spl_autoload_register(function ($class_name) { //echo "Autoload ".$class_name; $file = $_SERVER["DOCUMENT_ROOT"] . "/include/class/" . strtolower($class_name) . ".php"; if (file_exists($file) == false) { if($GLOBALS["DEBUG"]) echo "Нет файла ".$file; return false; } include_once($file); return true; });

Для автоподгрузки классов можно также использовать определение функции __autoload();

Обработка исключений в ООП

Для обработки некритических ошибок используются исключения(Exception).

Try { $a = 1; $b = 0; if($b == 0) throw new Exception ("деление на ноль!"); $c = $a/$b; } catch (Exception $e) { echo $e->getMessage(); echo $e->getLine(); }

Exception - встроенный класс. Если попали в throw, то код ниже не выполняется и осуществляется переход к блоку catch.

Блок try-catch используется как в процедурном, так и в ООП программировании. Он используется для отлова ошибок - большой блок try с множеством throw и все отлавливаются в одном месте - блоке catch.

Exception можно наследовать, желательно при этом перезагрузить конструктор: class MyException extends Exception { function __construct($msg){ parent::__construct($msg); } }

Блоков catch может быть несколько - для каждого класса наследника Exception.

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

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

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

Если класс можно рассматривать как тип данных , то объект - как переменную (по аналогии). Скрипт может одновременно работать с несколькими объектами одного класса, как с несколькими переменными.

Внутри объекта данные и код (члены класса) могут быть либо открыты, либо нет. Открытые данные и члены класса являются доступными для других частей программы, которые не являются частью объекта. А вот закрытые данные и члены класса доступны только внутри этого объекта.

Описание классов в PHP начинаются служебным словом class :

class Имя_класса {
// описание членов класса - свойств и методов для их обработки
}

Для объявления объекта необходимо использовать оператор new :

Объект = new Имя_класса;

Данные описываются с помощью служебного слова var . Метод описывается так же, как и обыкновенная пользовательская функция . Методу также можно передавать параметры.

Подведем промежуточные итоги: объявление класса должно начинаться с ключевого слова class (подобно тому, как объявление функции начинается с ключевого слова function ). Каждому объявлению свойства, содержащегося в классе, должно предшествовать ключевое слово var . Свойства могут относиться к любому типу данных, поддерживаемых в РНР, их можно рассматривать как переменные с небольшими различиями. После объявлений свойств следуют объявления методов, очень похожие на типичные объявления пользовательских функций.

По общепринятым правилам имена классов ООП начинаются с прописной буквы, а все слова в именах методов, кроме первого, начинаются с прописных букв (первое слово начинается со строчной буквы). Разумеется, вы можете использовать любые обозначения, которые сочтете удобными; главное - выберите стандарт и придерживайтесь его.

Пример класса на PHP:

// Создаем новый класс Coor:
class Coor {
// данные (свойства):
var $ name ;
var $ addr ;

// методы:
function Name () {
echo "

John

" ;
}

}


$ object = new Coor ;
?>

Доступ к класам и объектам в PHP

Мы рассмотрели, каким образом описываются классы и создаются объекты. Теперь нам необходимо получить доступ к членам класса, для этого в PHP предназначен оператор -> . Приведем пример:

// Создаем новый класс Coor:
class Coor {
// данные (свойства):
var $ name ;

// методы:
function Getname () {
echo "

John

" ;
}

}

// Создаем объект класса Coor:
$ object = new Coor ;
// Получаем доступ к членам класса:
$ object -> name = "Alex" ;
echo $ object -> name ;
// Выводит "Alex"
// А теперь получим доступ к методу класса (фактически, к функции внутри класса):
$ object -> Getname ();
// Выводит "John" заглавными буквами
?>

Чтобы получить доступ к членам класса внутри класса, необходимо использовать указатель $this , которы всегда относится к текущему объекту. Модифицированный метод Getname() :

function Getname() {
echo $this->name;
}

Таким же образом, можно написать метод Setname() :

function Setname($name) {
$this->name = $name;
}

Теперь для изменения имени можно использовать метод Setname() :

$object->Setname("Peter");
$object->Getname();

А вот и полный листинг кода:

// Создаем новый класс Coor:
class Coor {
// данные (свойства):
var $ name ;

// методы:
function Getname () {
echo $ this -> name ;
}

function Setname ($ name ) {
$ this -> name = $ name ;
}

}

// Создаем объект класса Coor:
$ object = new Coor ;
// Теперь для изменения имени используем метод Setname():
$ object -> Setname ("Nick" );
// А для доступа, как и прежде, Getname():
$ object -> Getname ();
// Сценарий выводит "Nick"
?>

Указатель $this можно также использовать для доступа к методам, а не только для доступа к данным:

function Setname($name) {
$this->name = $name;
$this->Getname();
}

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

Довольно часто при создании объекта требуется задать значения некоторых свойств. К счастью, разработчики технологии ООП учли это обстоятельство и реализовали его в концепции. Конструктор представляет собой метод, который задает значения некоторых свойств (а также может вызывать другие методы). Конструкторы вызываются автоматически при создании новых объектов. Чтобы это стало возможным, имя метода-конструктора должно совпадать с именем класса, в котором он содержится. Пример конструктора:

class Webpage {
var $ bgcolor ;
function Webpage ($ color ) {
$ this -> bgcolor = $ color ;
}
}

// Вызвать конструктор класса Webpage
$ page = new Webpage ("brown" );
?>

Раньше создание объекта и инициализация свойств выполнялись раздельно. Конструкторы позволяют выполнить эти действия за один этап.

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

$page = new Webpage;

Во-вторых, объект можно создать при помощи конструктора, определенного в классе, - в этом случае вы создаете объект класса Webpage и присваиваете значение его свойству bgcolor :

$page = new Webpage("brown");

Деструкторы

В РНР отсутствует непосредственная поддержка. Тем не менее, вы можете легко имитировать работу деструктора, вызывая функцию РНР unset() . Эта функция уничтожает содержимое переменной и возвращает занимаемые ею ресурсы системе. С объектами unset() работает так же, как и с переменными. Допустим, вы работаете с объектом $Webpage . После завершения работы с этим конкретным объектом вызывается функция:

unset($Webpage);

Эта команда удаляет из памяти все содержимое $Webpage . Действуя в духе инкапсуляции, можно поместить вызов unset() в метод с именем destroy() и затем вызвать его:

$Website->destroy();

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

Инициализация объектов

Иногда возникает необходимость выполнить инициализацию объекта - присвоить его свойствам первоначальные значения. Предположим, имя класса Coor и он содержит два свойства:имя человека и город его проживания. Можно написать метод (функцию), который будет выполнять инициализацию объекта, например Init() :

// Создаем новый класс Coor:
class Coor {
// данные (свойства):
var $ name ;
var $ city ;

// Инициализирующий метод:
function Init ($ name ) {
$ this -> name = $ name ;
$ this -> city = "London" ;
}

}

// Создаем объект класса Coor:
$ object = new Coor ;
// Для инициализации объекта сразу вызываем метод:
$ object -> Init ();
?>

Главное не забыть вызвать функцию сразу после создания объекта, либо вызвать какой-нибудь метод между созданием (оператор new ) объекта и его инициализацией (вызовом Init ).

Для того, чтобы PHP знал, что определенный метод нужно вызывать автоматически при создании объекта, ему нужно дать имя такое же, как и у класса (Coor ):

function Coor ($name)
$this->name = $name;
$this->city = "London";
}

Метод, инициализирующий объект, называется конструктором. Однако, PHP не имеет деструкторов, поскольку ресурсы освобождаюся автоматически при завершении работы скриптов.

Обращение к элементам классов

Обращение к элементам классов осуществляется с помощью оператора :: "двойное двоеточие". Используя "двойное двоеточие", можно обращаться к методам классов.

При обращении к методам классов, программист должен использовать имена этих классов.

class A {
function example () {
echo "Это первоначальная функция A::example().
" ;
}
}

Class B extends A {
function example () {
echo "Это переопределенная функция B::example().
" ;
A :: example ();
}
}

// Не нужно создавать объект класса A.
// Выводит следующее:
// Это первоначальная функция A::example().
A :: example ();

// Создаем объект класса B.
$b = new B форум портала PHP . SU

Объект похож на функцию, но он гораздо сложней. Объект можно назвать совокупностью нескольких функций и переменных, объеденённых одним именем.

Понять что такое объект легче всего на примере, но тут сначала придётся набраться немного терпения и осилить теорию.

Дело в том, что объекты создаются на основе классов, а классы может писать сам программист, а может работать с классами, написанными другими программистами.

Теперь давайте создадим класс.

Class TestClass { // Это тело класса. }

В PHP мы используем слово class , чтобы объявить класс. Имя класса чувствительно к регистру.

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

Class TestClass { public $message = "Hi!"; function sayHello() { echo "Hello!"; } }

Перед объявлением переменной мы видим слово public , это определение области видимости для нашего свойства. По английски public значит общественный, так что из названия понятно, что это свойство класса общедоступно. Об области видимости подробнее мы поговорим позже. Пока терпение и грызём текущую теорию.

Теперь в нашем классе TestClass есть переменная $message со значением "Hi!", эта переменная является свойством класса, и функция sayHello, которая является методом класса.

Итак, мы имеем класс. Теперь на основании этого создадим объект при помощи оператора new .

Class TestClass { public $message = "Hi!"; function sayHello() { echo "Hello!"; } } $govorilka = new TestClass();

Наш объект является как бы копией класса.

Следующий шаг - это использование объекта. Для доступа к свойствам и методам объекта используется оператор -> .

Чтобы получить доступ к свойству $message объекта $govorilka нужно просто написать $govorilka->message. Обратите внимание, что перед названием свойства message мы уже не ставим знак $ .

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

Вот пример обращения к свойству и методу созданного нами объекта:

message; echo "
"; $govorilka->sayHello();

Мы можем менять значения свойств.

message = "Здравствуйте."; echo $govorilka->message; echo "
"; $govorilka->sayHello();

На основании одного класса можно создать сколько угодно объектов.

message = "Здравствуйте."; echo $govorilka->message; echo "
"; $govorilka->sayHello(); echo "
"; // Создаём второй объект $govorilka2 = new TestClass(); echo $govorilka2->message;

Как мы видим, изменение свойтва объекта $govorilka не привело к изменению свойства класса TestClass, и второй объект соответствует классу, экземпляром которого он является.

Стоит отметить, что объекты часто называют экземплярами класса, так что запомните этот термин.

Пока что не совсем понятно, зачем всё это нам надо, эти классы, объекты... Давайте создадим более реалистичный класс и на его примере будем дальше работать.

type \"$this->name\". Описание: $this->description. Цена: $this->price"; } } $Goods = new Goods(); $Goods->printGoods();

Обратите внимание на псевдопеременную $this , это зарезервированная в PHP переменная, которая используется для доступа к свойствам класса внутри его кода.

То есть, чтобы обратиться к свойству $name класса Goods из его же метода мы использовали конструкцию $this->name.

Теперь давайте немного увеличим пример, усложнением это назвать трудно. Итак:

type. Название: \"$this->name\". Описание: $this->description. Цена: $this->price."; } } $Goods = new Goods(); $Goods->type = "книга"; $Goods->name = "Война и мир"; $Goods->description = "Толстая книга из нескольких томов"; $Goods->price = "543.26"; $Goods->printGoods();

Конечно, нет смысла всё делать таким образом. Обычно объект получает уникальный идентификатор товара и берёт все данные из базы MySQL.

id = $id; $this->type = "книга"; $this->name = "Война и мир"; $this->description = "Толстая книга из нескольких томов"; $this->price = "543.26"; } function printGoods() { echo " ID товара: $this->id. Тип товара: $this->type. Название: \"$this->name\". Описание: $this->description. Цена: $this->price."; } } $Goods = new Goods(124); $Goods->printGoods();

В этом примере слишком много нового.

Первое, обратите внимание на название метода __construct() . Это зарезервированное слово в PHP и такой метод запустится автоматически при создании объекта. Такие методы называются конструкторами.

Когда мы создавали новый объект Goods(124), мы передали конструктору число 124. Конструктор, по легенде:), получил из базы данных соответствующий товар и определил свойства объекта в соответствии с информацией из базы данных.

Свойства объекта у нас имеют область видимости protected , то есть защищённую. К такому свойству мы не можем обратиться напрямую из клиентского кода.

Клиентский код - это код, который использует класс, объект или функцию. Это важный термин, запомните его.

Вот пример попытки обратиться из клиентского кода к защещённому свойству:

price;

Этот пример вернёт ошибку: "Cannot access protected property Goods". Так и должно быть, мы обращаемся туда, куда нет доступа.

Резюме

Итак, что мы узнали на этой странице:

• Что такое класс. Зачем нужен класс. Как создать класс при помощи зарезервированного слова class .
• Что такое свойства и методы класса.
• Как при помощи оператора new создать объект какого-то класса.
• Как из объекта получить доступ к свойствам и методам класса при помощи конструкции -> .
• Как изменять свойства класса из объекта.
• Область видимости свойств и методов. Как ограничить область видимости при помощи слова protected .
• Как обратиться к свойству метода в классе при помощи псевдопеременной $this .
• Создание конструкторов при помощи метода __construct() .

Это только первый шаг в освоении объектов. По большому счёту ещё не совсем понятно, зачем всё это нужно. Но картина с объектами станет ясной несколько позже, пока наберитесь терпения.

Следующее, что нам нужно изучить - это наследование в PHP. В этой части мы уже не только изучим механизм наследования, но и сможем привести действительно актуальный пример использования классов и объектов.

Из Зандстры

стр. 51 - проверка передаваемого методу аргумента на соответствие типу класса (можно и проверить на массив).

стр. 56 - оператор instanceof (англ. экземпляр), проверяет соответствие левого аргумента типу объекта в правом аргументе.

Добро пожаловать во второй урок из серии, посвященной ООП. В первой статье вы ознакомились с основами ООП в PHP, включая понятия классов, методов, полей и объектов. Также вы узнали, как создать простенький класс и реализовать его.

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

Вот список того, о чем я расскажу вам в этой статье:

• Конструкторы и деструкторы, которые позволяют назначить определенные действия объекту при его создании и удалении;
• Статические поля и методы - это такие поля и методы, которые не связаны с конкретными объектами класса;
• Константы класса, удобные для хранения фиксированных значений, относящихся к определенному классу;
• Явное указание типа, используемое для задания ограничения типов параметров, которые можно передавать в тот или иной метод;
• Специальные методы __get() и __set(), которые используются для задания и чтения значений полей классов;
• Специальный метод __call(), применяемый для вызова метода класса.

Вы готовы? Тогда вперед!

Конструкторы и деструкторы

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

Подобно этому, вам также может понадобиться выполнять определенные действия по удалению объекта из памяти, например, удаление объектов, зависящих от удаляемого, закрытие соединения с базой данных или файлов.

На заметку: как удалить объект? PHP автоматически удаляет объект из памяти, когда не остается ни одной переменной, указывающей на него. Например, если вы создадите новый объект и сохраните его в переменной $myObject, а затем удалите ее с помощью метода unset($myObject), то сам объект также удалится. Также, если вы создали локальную переменную в какой-либо функции, она (вместе с объектом) удалится, когда функция завершит работу.

В PHP есть два специальных метода, которые можно применять для совершения определенных действий по созданию и удалению объектов:

• Конструктор вызывается сразу после того, как вы создали объект;
• Деструктор вызывается строго перед тем, как объект удаляется из памяти.

Работа с конструкторами

Применяйте конструкторы, чтобы задать действия, которые будут выполняться по созданию объекта класса. Эти действия могут включать инициализацию полей класса, открытие файлов, чтение данных.

Чтобы создать конструктор, добавьте в ваш класс специальный метод __construct() (перед словом construct - два символа подчеркивания). PHP автоматически вызовет этот метод при реализации вашего класса, то есть, при создании объекта этого класса.

Вот пример конструктора:

Class MyClass { public function __construct() { echo "I"ve just been created!"; } } $myObject = new MyClass(); // отобразит "I"ve just been created!"

В классе MyClass есть конструктор, который выводит на страницу строку "I"ve just been created!". Последняя строка кода создает новый объект класса MyClass. Когда это происходит, PHP автоматически вызывает конструктор, и сообщение отображается в браузере. Теперь на практике - инициализация полей класса:

Class Member { private $username; private $location; private $homepage; public function __construct($username, $location, $homepage) { $this->username = $username; $this->location = $location; $this->homepage = $homepage; } public function showProfile() { echo "

"; echo "

Username:

$this->username

"; echo "

Location:

$this->location

"; echo "

Homepage:

$this->homepage

"; echo "

"; } } $aMember = new Member("fred", "Chicago", "http://example.com/"); $aMember->showProfile();

Данный скрипт отобразит на странице следующее:

Username: fred Location: Chicago Homepage: http://example.com/

В нашем классе Member есть три поля и конструктор, который принимает в качестве параметров 3 значения - по одному для каждого поля. Конструктор назначит полям объекта значения, полученные в качестве аргументов. В классе также есть метод для отображения на странице значений полей объекта.

Затем в коде создается объект класса Member, в который мы передаем 3 значения "fred", "Chicago", и "http://example.com/", так как конструктор принимает именно 3 параметра. Конструктор записывает эти значения в поля созданного объекта. В завершение, вызывается метод showProfile() для созданного объекта, чтобы отобразить полученные значения.

Работа с деструкторами

Применяйте деструктор, когда объект удаляется из памяти. Вам может понадобиться сохранить объект в базе данных, закрыть открытые файлы, которые взаимодействовали с объектом. Чтобы создать деструктор, добавьте в класс метод __destruct(). Он вызовется как раз перед удалением объекта автоматически. Вот простой пример:

Class MyClass { public function __destruct() { echo "I"m about to disappear - bye bye!"; // (очистить память) } } $myObject = new MyClass(); unset($myObject); // отобразит "I"m about to disappear - bye bye!"

Мы создали простенький деструктор, который отображает на странице сообщение. Затем мы создали объект нашего класса и сразу же удалили его, вызвав метод unset() для переменной, которая ссылается на объект. Перед самым удалением объекта вызвался деструктор, который отобразил в браузере сообщение "I"m about to disappear - bye bye!".

На заметку: в отличие от конструкторов, в деструкторы нельзя передавать никакие параметры.

Деструктор также вызывается при выходе из скрипта, так как все объекты и переменные при выходе из метода удаляются. Так, следующий код также вызовет деструктор:

Class MyClass { public function __destruct() { echo "I"m about to disappear - bye bye!"; // (очистить память) } } $myObject = new MyClass(); exit; // отобразит "I"m about to disappear - bye bye!"

Также, если работа скрипта прекратится из-за возникшей ошибки, деструктор тоже вызовется.

На заметку: при создании объектов класса-наследника, конструкторы класса-родителя не вызываются автоматически. Вызывается только конструктор самого наследника. Тем не менее вы можете вызвать конструктор родителя из класса-наследника таким образом:

parent::__construct(). То же самое касается деструкторов. Вызвать деструктор родителя можно так: parent:__destruct(). Я расскажу вам о классах-родителях и наследниках в следующем уроке, посвященном наследованию.

Статические поля класса

Мы рассмотрели статические переменные в статье PHP Variable Scope: All You Need to Know. Как обычная локальная переменная, статическая переменная доступна только в пределах функции. Тем не менее, в отличие от обычных локальных, статические переменные сохраняют значения между вызовами функции.

Статические поля класса работают по такому же принципу. Статическое поле класса связано со своим классом, однако оно сохраняет свое значение на протяжении всей работы скрипта. Сравните это с обычными полями: они связаны с определенным объектом, и они теряются при удалении этого объекта.

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

Чтобы создать статическую переменную, добавьте ключевое слово static в ее задании:

Class MyClass { public static $myProperty; }

Вот пример того, как работают статические переменные:

Class Member { private $username; public static $numMembers = 0; public function __construct($username) { $this->username = $username; self::$numMembers++; } } echo Member::$numMembers . "
"; // отобразит "0" $aMember = new Member("fred"); echo Member::$numMembers . "
"; // отобразит "1" $anotherMember = new Member("mary"); echo Member::$numMembers . "
"; // отобразит "2"

Есть несколько интересных вещей, так что давайте разберем данный скрипт:

• В классе Member два поля: частное поле $username и статическое $numMembers, которое изначально получает значение 0;
• Конструктор получает в качестве параметра аргумент $username и устанавливает полю только что созданного объекта значение этого параметра. В то же время, он инкрементирует значение поля $numMembers, тем самым давая понять, что число объектов нашего класса увеличилось на 1.

Отметьте, что конструктор обращается к статическому полю так: self::$numMembers. Ключевое слово self похоже на $this, которое мы рассмотрели в прошлом уроке. Тогда как $this ссылается на текущий объект, self - на текущий класс. Также тогда как для получения доступа к полям и методам объекта вы используете ->, то в этом случае используйте:: для получения доступа к полям и методам класса.

• В завершении скрипт создает несколько объектов класса Member и отображает на странице их количество, т.е. значение статической переменной $numMembers. Отметьте, что данная переменная сохраняет свое значение на протяжении всей работы скрипта, несмотря на объекты класса.

Итак, чтобы получить доступ к статическому полю класса, применяйте оператор::. Здесь мы не можем воспользоваться ключевым словом self, так как код находится за пределами класса, поэтому мы пишем имя класса, затем::, а затем имя поля (Member::$numMembers). В пределах конструктора тоже нужно использовать именно такую структуру, а не self.

На заметку: нашему скрипту ничего не стоило получить доступ к полю класса $numMembers перед тем, как создался первый объект данного класса. Нет необходимости создавать объекты класса для того, чтобы пользоваться его статическими полями.

Статические методы

Наряду со статическими полями класса, вы также можете создавать статические методы. Статические методы, так же как и поля, связаны с классом, но нет необходимости создавать объект класса, чтобы вызвать статический метод. Это делает такие методы полезными в случае, если вам нужен класс, который не оперирует реальными объектами.

Чтобы создать статический метод, нужно добавить в его объявлении ключевое слово static:

Class MyClass { public static function myMethod() { // (действия) } }

В нашем предыдущем примере, касающемся статических полей, было статическое поле $numMembers. Делать поля частными, а методы для доступа к ним - открытыми, - это хорошая практика. Давайте сделаем наше статическое поле частным и напишем статический метод public для получения значения данного поля:

Class Member { private $username; private static $numMembers = 0; public function __construct($username) { $this->username = $username; self::$numMembers++; } public static function getNumMembers() { return self::$numMembers; } } echo Member::getNumMembers() . "
"; // отобразит "0" $aMember = new Member("fred"); echo Member::getNumMembers() . "
"; // отобразит "1" $anotherMember = new Member("mary"); echo Member::getNumMembers() . "
"; // отобразит "2"

Здесь мы создали статический метод getNumMembers(), который возвращает значение статического поля $numMembers. Мы также сделали это поле частным, чтобы нельзя было получить его значение извне.

Мы также изменили код вызова, применив метод getNumMembers() для получения значения поля $numMembers. Отметьте, можно вызывать данный метод без того, чтобы создавать объект класса, потому что метод - статический.

Константы класса

Константы позволяют задать глобальное значение для всего вашего кода. Это значение фиксированное, оно не может быть изменено. Константы класса схожи с обычными константами. Основное их отличие заключается в том, что помимо того, что классовая константа глобальна, к ней можно получить доступ из класса, в котором она определена. Классовые константы полезны в случаях, когда вам нужно хранить определенные значения, которые относятся к определенному классу.

Определить классовую константу можно с помощью ключевого слова const. Например:

Class MyClass { const CONSTANT_NAME = value; }

Обратиться в последствии к классовой константе можно через имя класса и оператор::. Например, так:

MyClass::CONSTANT_NAME

На заметку: как и в случае со статическими полями и методами, вы можете обратиться к константе через ключевое слово self.

Давайте рассмотрим классовые константы на примере. Добавим в класс Member константы, в которых будут храниться значения их роли (участник, модератор или администратор). Применив константы вместо обычных численных значений, мы сделали код более читабельным. Вот скрипт:

Class Member { const MEMBER = 1; const MODERATOR = 2; const ADMINISTRATOR = 3; private $username; private $level; public function __construct($username, $level) { $this->username = $username; $this->level = $level; } public function getUsername() { return $this->username; } public function getLevel() { if ($this->level == self::MEMBER) return "a member"; if ($this->level == self::MODERATOR) return "a moderator"; if ($this->level == self::ADMINISTRATOR) return "an administrator"; return "unknown"; } } $aMember = new Member("fred", Member::MEMBER); $anotherMember = new Member("mary", Member::ADMINISTRATOR); echo $aMember->getUsername() . " is " . $aMember->getLevel() . "
"; // отобразит "fred is a member" echo $anotherMember->getUsername() . " is " . $anotherMember->getLevel() . "
"; // отобразит "mary is an administrator"

Мы создали три классовые константы: MEMBER, MODERATOR и ADMINISTRATOR, и задали им значения 1, 2 и 3 соответственно. Затем мы добавляем поле $level для хранения ролей и немного изменяем конструктор так, чтобы инициализировать еще и это поле. В классе также появился еще один метод - getLevel(), который возвращает определенное сообщение в зависимости от значения поля $level. Он сравнивает это значение с каждой из классовых констант и возвращает нужную строку.

Скрипт создает несколько объектов с разными ролями. Для задания объектам ролей используются именно классовые константы, а не простые численные значения. Затем идут вызовы методов getUsername() и getLevel() для каждого объекта, и результаты отображаются на странице.

Явное указание типов аргументов функций

В PHP можно не задавать типы данных, так что можно не переживать о том, какие аргументы вы передаете в методы. Например, вы можете спокойно передать в функцию strlen(), считающую длину строки, численное значение. PHP сперва переведет число в строку, а затем вернет ее длину:

Echo strlen(123); // отобразит"3"

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

Например

Посмотрите на этот код:

Class Member { private $username; public function __construct($username) { $this->username = $username; } public function getUsername() { return $this->username; } } class Topic { private $member; private $subject; public function __construct($member, $subject) { $this->member = $member; $this->subject = $subject; } public function getUsername() { return $this->member->getUsername(); } } $aMember = new Member("fred"); $aTopic = new Topic($aMember, "Hello everybody!"); echo $aTopic->getUsername(); // отобразит "fred"

Данный скрипт работает так:

• Мы создаем наш класс Member с полем $username, конструктором и методом getUsername();
• Также создаем класс Topic для управления статьями форума. У него два поля: $member и $subject. $member - это объект класса Member, это будет автор статьи. Поле $subject - это тема статьи.
• В классе Topic также содержится конструктор, который принимает объект класса Member и строку - тему статьи. Этими значениями он инициализирует поля класса. У него еще есть метод getUsername(), который возвращает имя участника форума. Это достигается через вызов метода getUsername() объекта Member.
• В завершении создаем объект класса Member со значением поля username “fred”. Затем создаем объект класса Topic, передав ему Фреда и тему статьи “Hello everybody!”. В конце вызываем метод getUsername() класса Topic и отображаем на странице имя пользователя (“fred”).

Это все очень хорошо, но...

Давайте сделаем лучше!

Добавим этот фрагмент кода в конце:

Class Widget { private $colour; public function __construct($colour) { $this->colour = $colour; } public function getColour() { return $this->colour; } } $aWidget = new Widget("blue"); $anotherTopic = new Topic($aWidget, "Oops!"); // отобразит "Fatal error: Call to undefined method Widget::getUsername()" echo $anotherTopic->getUsername();

Здесь мы создаем класс Widget с полем $colour, конструктором и методом getColour(), который возвращает цвет виджета.

Затем мы создадим объект данного класса, а за ним объект Topic с аргументом $aWidget, когда на самом деле нужно передавать автора статьи, т.е. объект класса Member.

Теперь попытаемся вызвать метод getUsername() класса Topic. Этот метод обращается к методу getUsername() класса Widget. И так как в этом классе нет такого метода, мы получаем ошибку:

Fatal error: Call to undefined method Widget::getUsername()

Проблема в том, что причина ошибки не так легко уяснима. Почему объект Topic ищет метод в классе Widget, а не Member? В сложной иерархии классов будет очень сложно найти выход из такого рода ситуации.

Даем подсказку

Было бы лучше ограничить конструктор класса Topic на прием аргументов так, чтобы он мог принимать в качестве первого параметра объекты только класса Member, тем самым предостеречься от фатальных ошибок.

Это как раз то, чем занимается явное указание типов. Чтобы явно указать тип параметра, вставьте имя класса перед названием аргумента в объявлении метода:

Function myMethod(ClassName $object) { // (действия) }

Давайте подкорректируем конструктор класса Topic так, чтобы он принимал только Member:

Class Topic { private $member; private $subject; public function __construct(Member $member, $subject) { $this->member = $member; $this->subject = $subject; } public function getUsername() { return $this->member->getUsername(); } }

Теперь снова попытаемся создать объект Topic, передав ему Widget:

$aWidget = new Widget("blue"); $anotherTopic = new Topic($aWidget, "Oops!");

На этот раз PHP отобразит конкретную ошибку:

Catchable fatal error: Argument 1 passed to Topic::__construct() must be an instance of Member, instance of Widget given, called in script.php on line 55 and defined in script.php on line 24

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

Инициализация и чтение значений полей класса при помощи __get() и __set()

Как вы уже знаете, классы обычно содержат поля:

Class MyClass { public $aProperty; public $anotherProperty; }

Если поля класса - public, вы можете получить к ним доступ с помощью оператора ->:

$myObject = new MyClass; $myObject->aProperty = "hello";

Тем не менее, PHP позволяет создавать “виртуальные” поля, которых на самом деле нет в классе, но к которым можно получить доступ через оператор ->. Они могут быть полезны в таких случаях:

• Когда у вас очень много полей, и вы хотите создать для них массив, чтобы не объявлять каждое поле отдельно;
• Когда вам нужно хранить поле за пределами объекта, например, в другом объекте, или даже в файле или базе данных;
• Когда вам нужно вычислять значения полей “на лету”, а не хранить их значения где-либо.

Чтобы создать такие “виртуальные” поля, нужно добавить в класс парочку волшебных методов:

• __get($propName) вызывается автоматически при попытке прочитать значение “невидимого” поля $propName;
• __set($propName,$propValue) вызывается автоматически при попытке задать “невидимому” полю $propName значение $propValue.

“Невидимый” в данном контексте значит, что на данном участке кода нельзя прямо получить доступ к данным полям. Например, если такого поля вообще нет в классе, или если оно существует, но оно частное, и за пределами класса нет доступа к такому полю.

Перейдем к практике. Изменим наш класс Member так, чтобы в дополнение полю $username были еще и другие случайные поля, которые будут храниться в массиве $data:

Class Member { private $username; private $data = array(); public function __get($property) { if ($property == "username") { return $this->username; } else { if (array_key_exists($property, $this->data)) { return $this->data[$property]; } else { return null; } } } public function __set($property, $value) { if ($property == "username") { $this->username = $value; } else { $this->data[$property] = $value; } } } $aMember = new Member(); $aMember->username = "fred"; $aMember->location = "San Francisco"; echo $aMember->username . "
"; // отобразит "fred" echo $aMember->location . "
"; // отобразит "San Francisco"

Вот, как это работает:

• В классе Member есть постоянное поле private $username и private массив $data для хранения случайных “виртуальных” полей;
• Метод __get() принимает единственный параметр $property - имя поля, значение которого нужно вернуть. Если $property = “username”, то метод вернет значение поля $username. В другом случае, метод проверит, встречается ли такой $property в ключах массива $data. Если найдется такой ключ, он вернет значение данного поля, в противном случае - null.
• Метод __set() принимает 2 параметра: $property - имя поля, которое нужно инициализировать, и $value - значение, которое нужно задать данному полю. Если $property = “username”, метод инициализирует поле $username значением из параметра $value. В противном случае, добавляет в массив $data ключ $property со значением $value.
• После создания класса Member, создаем объект этого класса и инициализируем его поле $username значением “fred”. Это вызывает метод __set(), который задаст значение $username объекту. Затем устанавливаем значение поля $location в “San Francisco”. Так как такого поля не существует в объекте, метод записывает его в массив $data.
• В конце, достаем значения $username и $location и выводим их на страницу. Метод __get() достает действительное значение $username из существующего поля $username, а значение $location - из массива $data.

Как видите, с помощью методов __get() и __set() мы создали класс, в котором могут быть как настоящие поля, так и любые “виртуальные”. Из фрагмента кода, где задается значение тому или иному полю, не обязательно знать, существует ли такое поле или нет в объекте. Через обычный оператор -> можно задать полю значение или прочитать его.

В примере также показано, как можно легко создать методы, называемые “геттерами” и “сеттерами”, для доступа к частным полям. Нам не нужно создавать отдельные методы getUsername() и setUsername() для получения доступа к частному полю $username. Вместо этого мы создали методы __get() и __set() для манипулирования данным полем. Это значит, что нам нужно всего 2 метода в общем, а не по 2 метода для каждого частного поля.

На заметку: Слово о инкапсуляции. Использование частных полей класса в комбинации с геттерами и сеттерами - это лучше, чем использование переменных public. Геттеры и сеттеры дополнительно могут обрабатывать данные, задаваемые полям объекта и получаемые из них, например, проверять, в правильном ли формате находится значение, или конвертировать его в нужный формат. Геттеры и сеттеры также скрывают детали того, как имплементируются поля класса, что упрощает процесс модификации внутренней части класса, так как не нужно переписывать код, который оперирует объектами данного класса. Например, вы вдруг захотели хранить значение поля в базе данных. Если у вас уже были геттеры и сеттеры, все, что вам нужно, - это переписать их. А вызывающий код останется таким же. Эта техника называется инкапсуляцией, и это одно из главных преимуществ ООП.

Перегрузка методов с помощью __call()

Геттеры и сеттеры используются для запрета на доступ к частным переменным. В этом же направлении используется метод __call() для запрета доступа к частным методам. Как только из кода вызывается метод класса, который либо не существует, либо он недоступен, автоматически вызывается метод __call(). Вот общий синтаксис метода:

Public function __call($methodName, $arguments) { // (действия) }

Когда производится попытка вызвать недоступный метод класса, PHP автоматически вызывает метод __call(), в который передает строку - имя вызываемого метода и список передаваемых параметров в массиве. Затем ваш метод __call() должен будет определенным способом обработать вызов и, в случае необходимости, вернуть значения.

Метод __call() полезен в ситуациях, когда вам нужно передать некую функциональность класса другому классу. Вот простой пример:

Class Member { private $username; public function __construct($username) { $this->username = $username; } public function getUsername() { return $this->username; } } class Topic { private $member; private $subject; public function __construct($member, $subject) { $this->member = $member; $this->subject = $subject; } public function getSubject() { return $this->subject; } public function __call($method, $arguments) { return $this->member->$method($arguments); } } $aMember = new Member("fred"); $aTopic = new Topic($aMember, "Hello everybody!"); echo $aTopic->getSubject() . "
"; // отобразит "Hello everybody!" echo $aTopic->getUsername() . "
"; // отобразит "fred"

Данный пример похож на тот, что приводился в разделе о явном указании типов. У нас есть класс Member с полем $username и класс Topic с полем - объектом класса Member (автор статьи) и полем $subject - темой статьи. Класс Topic содержит метод getSubject() для получения темы статьи, но в нем нет метода, который возвращал бы имя автора статьи. Вместо него в нем есть метод __call(), который вызывает несуществующий метод и передает аргументы методу класса Member.

Когда в коде вызывается метод $aTopic->getUsername(), PHP понимает, что такого метода в классе Topic не существует. Поэтому вызывается метод __call(), который в свою очередь, вызывает метод getUsername() класса Member. Этот метод возвращает имя автора методу __call(), а тот отправляет полученное значение вызывающему коду.

На заметку: в PHP есть и другие методы, касающиеся перегрузки, например, __isset(), __unset(), и __callStatic().

Заключение

В этом уроке вы углубили свои знания по ООП в PHP, рассмотрев более детально поля и методы. Вы изучили:

• Конструкторы и деструкторы, полезные для инициализации полей и очистки памяти после удаления объектов;
• Статические поля и методы, которые работают на уровне класса, а не на уровне объекта;
• Классовые константы, полезные для хранения фиксированных значений, необходимых на уровне класса;
• Явное указание типов, с помощью которого можно лимитировать типы аргументов, передаваемых в метод;
• Волшебные методы __get(), __set() и __call(), которые служат для получения доступа к частным полям и методам класса. Реализация этих методов позволяет вам создавать “виртуальные” поля и методы, которые не существуют в классе, но в то же время, могут быть вызваны.

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

Удачного программирования!

Объект класса - представитель класса, который имеет свое уникальное состояние и поведение.
Для объявления объекта необходимо использовать оператор new:

Объект = new Имя_класса;

PHP

$myObj = new newClass();

Свойства класса

Свойство – это переменные, хранимые в классе; перед именем свойства ставится один из следующих модификаторов (public , protected , private). Также есть ключевое слово var , но его время ушло (остался в 4-й версии PHP).

Описание свойств

PHP

class newClass { public $property1; protected $property2 = "value2"; private $property3; }

Доступ к свойствам класса

Доступ к свойствам класса за пределами класса реализуется так: объект->

PHP

$myObj = new newClass(); $myObj->property1;

Изменение значения свойств

PHP

$myObj->property2 = "Тут меняем значение";

Методы класса

Метод – это функция, определенная внутри класса. У функции по умолчанию стоит модификатор public (то есть его можно не писать перед функцией).

Описание методов

PHP

class newClass { function myMethod($var1,$var2){ // по умолчанию это // общедоступный метод (public) // операторы } }

Вызов метода

PHP

$myObj = new newClass(); $myObj->myMethod("v1","v2");

$this

Доступ к свойству класса внутри класса реализуется при помощи оператора($this):
$this-> имя_свойства; (знак доллара у свойства не ставится!)

Доступ к методу класса из другого метода класса также осуществляется с помощью ключевого слова $this .

PHP

class newClass { public $property1; function myMethod(){ echo($this->property1); // Вывод значения свойства } function callMethod(){ $this->myMethod(); // Вызов метода } }

Конструкторы и деструкторы

Конструктор класса – это специальный метод, который автоматически вызывается в момент создания объекта.
Круглый скобки за наименованием класса (при инициализации объекта) нужны для передачи параметров функции конструктору.

Деструктор – специальный метод, который автоматически вызывается при удалении объекта. P.s. Порядок удаления объектов не определен, но стоит отметить, что объекты удалятся по завершении кода (порядок удаления объектов определить нельзя), и вызовется метод __destruct . Объект можно удалить принудительно: unset(имя_объекта) .

PHP

class newClass { public $property; function __construct($var){ $this->property = $var; echo "Вызываем конструктор"; } function __destruct(){ echo "Вызываем деструктор"; } } $obj = new newClass("Значение"); //Вызываем конструктор unset($obj); //Вызываем деструктора (принудительно)

Псевдо-константы __METHOD__ и __CLASS__

Псевдо-константы __METHOD__ и __CLASS__ . Вместо __METHOD__ будет подставлено: имя_класса::имя_метода; __CLASS__ будет подставлено имя_класса.

PHP

class newClass { function myMethod(){ echo __METHOD__; } function getClassName(){ echo __CLASS__; } } $obj = new newClass(); $obj->myMethod();// newClass::myMethod $obj->getClassName();// newClass

Новые принципы работы с объектами

Объекты передаются по ссылке, а не по значению

PHP

class newClass { public $property; } $myObj = new newClass(); $myObj->property = 1; $myObj2 = $myObj; $myObj2->property = 2; print($myObj->property); // Выведет 2 print($myObj2->property); // Выведет 2

Клонирование объекта

При клонировании (clone) конструктор не вызывается. Существует специальный метод __clone , который вызывается при клонировании объекта.

Явное копирование объектов

PHP

class newClass { public $property; } $myObj = new newClass(); $myObj->property = 1; $myObj2 = clone $myObj; // создаем копию объекта, в 4-й версии php было так: $myObj2 = &$myObj; // в 5-й версии PHP & с объектами не работает $myObj2->property = 2; print($myObj->property); // Печатает 1 print($myObj2->property); // Печатает 2

Наследование(полиморфизм)

Один класс может наследовать другой класс. Для этого существует специальное ключевое слово - extends .

PHP

class Machine { public $numWheels = 4; function printWheels() { echo $this->numWheels; } } class Toyota extends Machine { public $country = "Japan"; function printCountry() { echo $this->country; } } $myMachine = new Toyota(); $myMachine->printWheels(); $myMachine->printCountry();

Перегрузка методов

Перегрузка методов – в классе, который наследует другой класс, можно описать такой же метод, который есть в родительском классе, причем вновь описанный метод перезапишет метод родительского класса. Пример:

PHP

class Machine { public $numWheels = 4; function printWheels() { echo $this->numWheels; } } class Toyota extends Machine { public $country = "Japan"; function printCountry() { echo $this->country; } function printWheels() { echo "Перегруженный метод printWheels() "; } } $myMachine = new Toyota(); $myMachine->printWheels();

Parent

parent::имя_метода, данная конструкция позволяет обратиться к родительскому методу.

PHP

class Machine { public $numWheels = 4; function printWheels() { echo $this->numWheels; } } class Toyota extends Machine { public $country = "Japan"; function printWheels() { echo "Перегруженный метод printWheels() "; parent:: printWheels(); } } $myMachine = new Toyota(); $myMachine->printWheels();

Модификаторы доступа: public , protected , private

Модификаторы доступа: как это работает?

PHP $obj = new newClass(); echo $obj->public; //ДА echo $obj->protected; //НЕТ! echo $obj->private; //НЕТ $obj->myMethod();	PHP class newClass { public $public = 1; protected $protected = 2; private $private = 3; function myMethod(){ echo $this->public; //ДА echo $this->protected; //ДА echo $this->private; //ДА } }
PHP $obj1 = new NewClass(); echo $obj1->public; //ДА echo $obj1->protected; //НЕТ! echo $obj1->private; //НЕТ $obj1->newMethod();	PHP class NewClass extends newClass { function newMethod(){ echo $this->protected; //ДА echo $this->private; //НЕТ $this->myMethod(); } }

Обработка исключений

У нас есть кусок кода, в котором может произойти какая-нибудь ошибка; данный кусок кода помещается в блок под названием try ; в том месте, где-может произойти ошибка, ставится ключевое слово throw ; для отлова произошедшей ошибки описывается блок catch (ловушка), туда приходит ошибка, с которой мы можем работать.

PHP

try { $a = 1; $b = 0; if($b == 0) throw new Exception("Деление на 0!"); echo $a/$b; } catch(Exception $e){ echo "Произошла ошибка - ", $e->getMessage(), // Выводит сообщение " в строке ", $e->getLine(), // Выводит номер строки " файла ", $e->getFile(); // Выводит имя файла }

Создание собственных исключений

PHP

сlass MathException extends Exception { function __construct($message) { parent::__construct($message); } } try { $a = 1; $b = 0; // MathException - имя класса для создания собственного исключения if ($b == 0) throw new MathException("Деление на 0!"); echo $a / $b; } catch (MathException $e) { echo "Произошла математическая ошибка ", $e->getMessage(), " в строке ", $e->getLine(), " файла ", $e->getFile(); }

Перебор свойств объекта

PHP

class Person { public $name; public $yearOfBorn; function __construct($name, $yearOfBorn){ $this->name = $name; $this->yearOfBorn = $yearOfBorn; } } $billGates = new Person(‘Bill Gates’,1955); foreach($billGates as $name=>$value){ print($name.’: ’.$value.’
’); }

Константы класса

Константы – это константы класса, то есть они не принадлежат ни одному объекту. За пределами кода к константе можно обратиться следующим образом: имя_класса::имя_константы. Если мы хотим обратиться к константе в пределах класса, то нужно использовать ключевое слово self: self::имя_константы.

PHP

class Person { const HANDS = 2; function printHands(){ print (self::HANDS);// NOT $this! Обращаемся к константе внутри класса } } print ("Количество рук: ".Person::HANDS); // Обращаемся к константе за пределами класса

Абстрактные методы и классы

Абстрактный класс в php - это так называемый базовый класс, не предназначенный для создания его экземпляров (объектов). Основной смысл и назначение абстрактных классов заключается в расширении возможностей его дочерних классов.

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

В абстрактном классе могут быть абстрактные методы (перед function стоит ключевое слово abstract). Абстрактный метод – это метод без реализации (отсутствуют фигурный скобки).

Абстрактный метод обязательно должен быть описан (перезагружен) в классе-наследнике. Преимущество в использовании абстрактных методов: для каждого класса-наследника можно описать свое уникальное поведение абстрактного метода.

PHP

abstract class Machine { // абстрактный класс public $petrol; function startEngine(){ print("Двигатель зав?лся!"); } abstract function stopEngine(); } class InjectorMachine extends Machine { public function stopEngine(){ print("Двигатель остановился!"); } } $myMegaMachine = new Machine();//Ошибка! $myMegaMachine = new InjectorMachine(); $myMegaMachine->startEngine(); $myMegaMachine->stopEngine();

Интерфейсы

Существует еще один тип абстрактного класса – интерфейс. Интерфейс – это абстрактный класс, который содержит только абстрактные методы. Перед таким классом вместо слова abstract пишется interface . От интерфейса наследование происходит не через ключевое слово extends , а через ключевое слово implements .

PHP

interface Hand { function useKeyboard(); function touchNose(); } interface Foot { function runFast(); function playFootball(); } class Person implements Hand { public function useKeyboard(){ echo "Use keyboard!"; } public function touchNose(){ echo "Touch nose!"; } public function runFast(){ echo "Run fast!"; } public function playFootball(){ echo "Play football!"; } } $vasyaPupkin = new Person(); $vasyaPupkin->touchNose();

Финальные методы и классы

Перед методом ставится ключевое слово final , этим мы запрещаем перезагружать (перезаписывать) данный метод. Класс также можно объявить финальным.

PHP

class Mathematics { final function countSum($a,$b){ print("Сумма: " . $a + $b); } } class Algebra extends Mathematics { // Возникнет ошибка public function countSum($a,$b){ $c = $a + $b; print("Сумма $a и $b: $c"); } }

PHP

final class Breakfast { // финальный класс function eatFood($food){ print("Скушали $food!"); } } // Возникнет ошибка class McBreakfast extends Breakfast { // Описание класса }

Статические свойства и методы класса

Статические методы и свойства класса (плюс константы класса) принадлежат классу, то есть они общие для всех объектов класса. К ним нельзя обратиться посредством ‛стрелки‛, а только через:: (внутри класса используется: self::$имя_свойства; за пределами класса: имя_класса::$имя_свойства). Статическое свойство, как и метод, объявляется через ключевое слово static . Как вы догадываетесь, внутри статического метода this использовать нельзя (такие методы не связаны с объектами).

PHP

class CookieLover { static $loversCount = 0; // это статическое свойство, и компилятор не // будет его удалять после завершения работы функции __construct function __construct(){ ++self::$loversCount; } static function welcome(){ echo "Добро пожаловать в клуб любителей булочек!"; //Никаких $this внутри статического метода! } } $vasyaPupkin = new CookieLover(); $frosyaBurlakova = new CookieLover(); print ("Текущее количество любителей булочек: ".CookieLover::$loversCount); print (CookieLover::welcome());

Ключевое слово instanceof

Иногда требуется узнать: является ли текущий объект наследником того или иного класса, или интерфейса. Для этого используется ключевое слово instanceof .

PHP

class Person {} $myBoss = new Person(); if($myBoss instanceOf Person) print("Мой Босс – человек!"); // вернет true, если класс Person есть в предках объекта $myBoss class Woman extends Person {} $englishQueen = new Woman(); if($englishQueen instanceOf Person) print("Английская королева – тоже человек!"); interface LotsOfMoney {} class ReachPeople implements LotsOfMoney {} $billGates = new ReachPeople(); if($billGates instanceOf LotsOfMoney) print("У Билла Гейтса много денег!");

Функция __autoload()

Если PHP натыкается на несуществующий класс, при инициализации объекта, то он ищет функцию __autoload , передавая в функцию __autoload имя неназванного класса. И PHP вызовет эту функцию перед выводом ошибки об отсутствии класса.

PHP

function __autoload($cl_name){ // $cl_name - имя не найденного класса print("Попытка создать объект класса ".$cl_name); } $obj = new undefinedClass();

Методы доступа к свойствам объекта

Метод __set() будет выполнен при записи данных в недоступные свойства (которых нет в классе).

Метод __get() будет выполнен при чтении данных из недоступных свойств (которых нет в классе).

PHP

class newClass { private $properties; function __get($name){ print("Чтение значения свойства $name"); return $this->properties[$name]; } function __set($name,$value){ // в нашем случае $name это property, $value равно 1 print("Задание нового свойства $name = $value"); $this->properties[$name] = $value; } } $obj = new newClass; $obj->property = 1; // Запись нового свойства $a = $obj->property; // Чтение значения свойства print $a; // 1

Перегрузка вызова несуществующих методов

Если мы обращаемся к методу которого нет , то PHP ищет метод __call (1-й параметр – это имя несуществующего метода, 2-й – массив аргументов).

PHP

class newClass { function __call($name, $params){ print("Попытка вызова метода $name со следующими параметрами: "); print_r($params); } } $obj = new newClass(); $obj->megaMethod(1,2,3,"четыре");

Метод __toString()

Метод __toString() позволяет классу решать самостоятельно, как он должен реагировать при преобразовании в строку. Например, что напечатает echo $obj; . Этот метод должен возвращать строку, иначе выдастся неисправимая ошибка E_RECOVERABLE_ERROR .

PHP

class newClass { function __toString(){ return "Вызван метод __toString()"; } } $obj = new newClass(); // Вызван метод __toString() echo $obj; Графика