Классы и объекты в 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 (англ. экземпляр), проверяет соответствие левого аргумента типу объекта в правом аргументе.

Объект класса - представитель класса, который имеет свое уникальное состояние и поведение.
Для объявления объекта необходимо использовать оператор 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;

Переменные, которые являются членами класса, называются "свойства". Также их называют, используя другие термины, такие как "атрибуты" или "поля", но в рамках этой документации, мы будем называть их свойствами. Они определяются с помощью ключевых слов public , protected или private , следуя правилам правильного объявления переменных. Это объявление может содержать инициализацию, но эта инициализация должна быть постоянным значением, то есть значение должно быть вычислено во время компиляции и не должны зависеть от информации, полученной во время выполнения для их вычисления.

Псевдопеременная $this доступна внутри любого метода класса, когда этот метод вызывается из контекста объекта. $this - это ссылка на вызываемый объект (обычно это объект, к которому принадлежит метод, но возможно и другого объекта, если метод вызван статически из контекста второго объекта).

Пример #1 Определение свойств

class SimpleClass
{
public $var1 = "hello " . "world" ;
public $var2 = <<hello world
EOD;
// правильное определение свойства с PHP 5.6.0:
public $var3 = 1 + 2 ;
// неправильное определение свойств:
public $var4 = self :: myStaticMethod ();
public $var5 = $myVar ;

// правильное определение свойств:
public $var6 = myConstant ;
public $var7 = array(true , false );

// правильное определение свойства с PHP 5.3.0:
public $var8 = <<<"EOD"
hello world
EOD;
}
?>

Замечание :

Начиная с PHP 5.3.0 и nowdocs могут быть использованы в любом статическом контексте данных, включая определение свойств.

Пример #2 Пример использования nowdoc для инициализации свойств

class foo {
// С PHP 5.3.0
public $bar = <<<"EOT"
bar
EOT;
public $baz = <<baz
EOT;
}
?>

Замечание :

Поддержка Nowdoc и Heredoc была добавлена в PHP 5.3.0.

7 years ago

In case this saves anyone any time, I spent ages working out why the following didn"t work:

class MyClass
{
private $foo = FALSE;

{
$this->$foo = TRUE;

Echo($this->$foo);
}
}

$bar = new MyClass();

giving "Fatal error: Cannot access empty property in ...test_class.php on line 8"

The subtle change of removing the $ before accesses of $foo fixes this:

class MyClass
{
private $foo = FALSE;

Public function __construct()
{
$this->foo = TRUE;

Echo($this->foo);
}
}

$bar = new MyClass();

I guess because it"s treating $foo like a variable in the first example, so trying to call $this->FALSE (or something along those lines) which makes no sense. It"s obvious once you"ve realised, but there aren"t any examples of accessing on this page that show that.

4 years ago

You can access property names with dashes in them (for example, because you converted an XML file to an object) in the following way:

$ref = new StdClass ();
$ref ->{ "ref-type" } = "Journal Article" ;
var_dump ($ref );
?>

8 years ago

$this can be cast to array. But when doing so, it prefixes the property names/new array keys with certain data depending on the property classification. Public property names are not changed. Protected properties are prefixed with a space-padded "*". Private properties are prefixed with the space-padded class name...

Class test
{
public $var1 = 1 ;
protected $var2 = 2 ;
private $var3 = 3 ;
static $var4 = 4 ;

Public function toArray ()
{
return (array) $this ;
}
}

$t = new test ;
print_r ($t -> toArray ());

/* outputs:

Array
=> 1
[ * var2] => 2
[ test var3] => 3
)

*/
?>
This is documented behavior when converting any object to an array (see PHP manual page). All properties regardless of visibility will be shown when casting an object to array (with exceptions of a few built-in objects).

To get an array with all property names unaltered, use the "get_object_vars($this)" function in any method within class scope to retrieve an array of all properties regardless of external visibility, or "get_object_vars($object)" outside class scope to retrieve an array of only public properties (see: PHP manual page).

9 years ago

Do not confuse php"s version of properties with properties in other languages (C++ for example). In php, properties are the same as attributes, simple variables without functionality. They should be called attributes, not properties.

Properties have implicit accessor and mutator functionality. I"ve created an abstract class that allows implicit property functionality.

Abstract class PropertyObject
{
public function __get ($name )
{
if (method_exists ($this , ($method = "get_" . $name )))
{
return $this -> $method ();
}
else return;
}

Public function __isset ($name )
{
if (method_exists ($this , ($method = "isset_" . $name )))
{
return $this -> $method ();
}
else return;
}

Public function __set ($name , $value )
{
if (method_exists ($this , ($method = "set_" . $name )))
{
$this -> $method ($value );
}
}

Public function __unset ($name )
{
if (method_exists ($this , ($method = "unset_" . $name )))
{
$this -> $method ();
}
}
}

?>

after extending this class, you can create accessors and mutators that will be called automagically, using php"s magic methods, when the corresponding property is accessed.

5 years ago

Updated method objectThis() to transtypage class array properties or array to stdClass.

Hope it help you.

public function objectThis($array = null) {
if (!$array) {
foreach ($this as $property_name => $property_values) {
if (is_array($property_values) && !empty($property_values)) {
$this->{$property_name} = $this->objectThis($property_values);
} else if (is_array($property_values) && empty($property_values)) {
$this->{$property_name} = new stdClass();
}
}
} else {
$object = new stdClass();
foreach ($array as $index => $values) {
if (is_array($values) && empty($values)) {
$object->{$index} = new stdClass();
} else if (is_array($values)) {
$object->{$index} = $this->objectThis($values);
} else {
$object->{$index} = $values;
}
}
return $object;
}
}

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

Определение класса

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

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

Создание объекта

Так как класс - это шаблон для создания объектов, следовательно, объект - это данные, которые создаются и структурируются в соответствии с шаблоном, определенным в классе. Объект также называют экземпляром класса, тип которого определяется классом. Для создания нового экземпляра класса нам понадобится оператор new . Он используется совместно с именем класса следующим образом:

После оператора new указывается имя класса на основе которого будет создан объект. Оператор new создает экземпляр класса и возвращает ссылку на вновь созданный объект. Эта ссылка сохраняется в переменной соответствующего типа. В результате выполнения этого кода будет создано два объект типа first . Хотя функционально они идентичны (т.е. пусты) $obj1 и $obj2 - это два разных объекта одного типа, созданных с помощью одного класса.

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

Давайте сделаем эти объекты немного интереснее, изменив класс first , добавив в него специальные поля данных, называемые свойства.

Определение свойств

В классе можно определить переменные. Переменные, которые определены в классе называются свойствами (или полями данных). Они определяются с одним из ключевых слов protected, public или private , характеризующих управление доступом. Эти ключевые слова мы рассмотрим подробно в следующей главе. А сейчас давайте определим некоторые свойства с помощью ключевого слова public:

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

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

К свойствам объекта можно обращаться с помощь символов " -> ", указав объект и имя свойства. Поскольку свойства объектов были определены как public , мы можем считывать их значения, а также присваивать им новые значения, заменяя тем самым начальные значения, определенные в классе:

str; // присваиваем свойству объекта новое значение $obj->str = "новая строка"; echo "
$obj->str"; ?>

На самом деле в PHP необязательно объявлять все свойства в классе. Свойства можно добавлять к объекту динамически:

newprop = "новое свойство"; echo $obj->newprop; ?>

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

Работа с методами

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

str; } } $obj = new first(); // вызов метода объекта $obj->getstr(); ?>

Мы добавили метод getstr() к классу first . Обратите внимание на то, что при определении метода мы не использовали ключевое слово, определяющее область видимости. Это означает, что метод getstr() относится к типу public и его можно вызвать за пределами класса.

В определении метода мы воспользовались специальной псевдопеременной $this . Она используется для обращения к методам или свойствам внутри класса и имеет следующий синтаксис:

$this->имя переменной или метода

Class first { public $str = "some text"; // при определении метода в классе, переменная $this не имеет никакого значения function getstr() { echo $this->str; } } // создаем объект $obj = new first(); // созданный нами объект имеет свойство и метод // теперь в методе объекта переменная $this имеет // ссылку на текущий объект, а именно на $obj // т.е. если в методе заменить $this текущим экземпляром объекта $this->str; // это будет выглядеть как простое // обращение к свойству текущего объекта $obj->str;

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

Специальный метод - конструктор

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

num1 = $num1; $this->num2 = $num2; } // метод, который складывает два числа function summa() { return $this->num1 + $this->num2; } } // создаем объект и передаем два аргумента $obj = new first(15, 35); // вызываем метод и сразу выводим результат его работы echo $obj->summa(); ?>

Метод __construct вызывается, когда создается объект с помощью оператора new . Указанные в скобках аргументы передаются конструктору. В методе конструктора используется псевдопеременная $this для присвоения значений соответствующим свойствам создаваемого объекта.

Примечание: если конструктор не имеет параметров и при создании новых экземпляров класса не передаются никакие аргументы, круглые скобки () после имени класса можно опустить: $obj = new first;

Указание типа аргумента в методах

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

getobj(new cat()); // здесь будет ошибка: передали в качестве аргумента экземпляр типа wrong $kitty->getobj(new wrong()); ?>

Теперь в качестве аргумента методу getobj() можно передавать только экземпляры типа cat . Поскольку метод getobj() содержит уточнение типа класса, передача ему объекта типа wrong приведет к ошибке.

Указание типа нельзя использовать для определения параметров элементарных типов, таких как строки, числа и т.д. Для этой цели в теле метода следует использовать функции проверки типов, например is_string() . Также есть возможность определить, что передаваемый аргумент является массивом:

my_arr = $some_arr; } } ?>

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

Function getobj(cat $getCat = null) { $this->someVar = $getCat; }

Если вместо NULL указать какое-либо другое значение по умолчанию, будет выдана ошибка.