Объекты (Object)

Объект является одним из базовых понятий объектно-ориентированного программирования.

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

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

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

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

class foo
{
function do_foo ()
{
echo "Doing foo." ;
}
}

$bar = new foo ;
$bar -> do_foo ();
?>

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

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

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

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

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

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

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

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

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

John

" ;
}

}

// Создаем объект класса Coor:
$ object = new Coor ;
?>

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

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

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

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

John

" ;
}

}


$ 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();
}

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

Иногда возникает необходимость выполнить инициализацию объекта - присвоить его свойствам первоначальные значения. Предположим, имя класса 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 не имеет деструкторов, поскольку ресурсы освобождаюся автоматически при завершении работы скриптов.

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

Если объект преобразуется в объект, он не изменяется. Если же в объект преобразуется значение любого иного типа, создается новый экземпляр встроенного класса stdClass . Если значение было пустым, новый экземпляр также будет пустым. При любом другом значении оно будет содержатся в переменной-члене scalar:

Форум портала PHP . SU

В этом уроке вы ознакомитесь с основами объектно-ориентированного программирования в PHP. Вы узнаете о принципах ООП вообще и научитесь писать простенькие скрипты на PHP.

Добро пожаловать в первый из серии уроков по ООП на PHP! Ознакомившись со всеми уроками данной серии, вы узнаете об основных принципах и концепциях ООП и научитесь быстро и легко создавать полезные приложения на PHP.

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

  • что такое ООП
  • как ООП поможет вам создавать лучшие PHP скрипты
  • некоторые основные понятия, такие как классы, объекты, методы, переменные класса
  • с чего начать написание PHP скрипта

Вы готовы погрузиться в мир объектов PHP? Тогда вперед!

Что такое объектно-ориентированное программирование?

Если вы когда-то создавали собственные функции в PHP и использовали их, то вы использовали такой стиль программирования, как процедурный. В процедурном программировании вы обычно создаете структуры данных - числа, строки, массивы и т.д. - для хранения каких-то данных, а затем обрабатываете эти структуры специальными функциями, которые манипулируют этими данными.

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

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

Зачем использовать ООП?

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

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

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

Некоторые основные понятия

Перед тем, как начать писать скрипты, необходимо хорошо разобраться с такими понятиями, как класс, объект, переменная класса и метод.

Классы

Класс - это каркас для объекта. Это кусок кода, который определяет:

  • Типы данных, которые будут содержать созданные объекты класса
  • Функции, которые будут содержать эти объекты.

Когда вы создаете приложение на ООП, вы обычно будете создавать несколько классов, которые будут представлять различные типы сущностей вашего приложения. Например, для создания форума вы можете создать классы Forum, Topic, Post и Member.

Объекты

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

Для сравнения с реальными сущностями:

  • Класс - это каркас для автомобиля: он определяет, как автомобиль будет выглядеть и действовать, но это все же абстрактная сущность
  • Объект - это настоящий автомобиль, созданный из каркаса: у него есть настоящие свойства (например, скорость) и поведение (например, ускорение или торможение).

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

Переменные класса

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

Методы

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

Как создать класс в PHP?

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

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

Class ClassName { // (определение класса) }

К примеру, если вы создаете класс Member для вашего форума, вы напишите так:

Class Member { // (определение класса) }

Это достаточно просто. Естественно, класс этот ничего не сделает, пока вы не добавите в него переменные и методы. Тем не менее, приведенный выше код создает валидный класс на PHP, который можно использовать.

Правило хорошего тона: каждый класс помещайте в отдельный файл с названием, совпадающим с именем класса. Например, поместите класс Member в файл Member.php и храните его в папке, допустим, classes.

Как создавать объекты в PHP?

Создать объект можно с помощью ключевого слова new:

New ClassName()

Этот код создаст объект класса ClassName. Вам впоследствии понадобится использовать этот объект, поэтому его нужно хранить в переменной. Например, создадим объект класса Member и сохраним его в переменной $member:

$member = new Member();

Мы также можем создать еще один объект того же класса:

$member2 = new Member();

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

Создаем переменные класса

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

  • Открытые переменные класса (public): доступны - т.е. их можно прочитать и/или изменять - в любом месте скрипта, независимо от того, где находится этот код - внутри класса или за его пределами
  • Частные переменные класса (private): доступны только методам класса. Лучше всего делать переменные класса именно частными, чтобы отделить объекты от остальной части кода.
  • Защищенные переменные класса (protected): доступны методам собственного класса, а также методам наследуемых классов (мы поговорим о наследовании позже).

Чтобы создать переменную класса, напишите ключевое слово public, private или protected, а затем введите имя переменной:

Class ClassName { public $propertyName; private $propertyName; protected $propertyName; }

Давайте добавим переменную класса public нашему классу Member для хранения имени пользователя:

Class Member { public $username = ""; }

Обратите внимание на то, что мы инициализировали нашу переменную класса, его значение - пустая строка, “”. Это значит, что при создании нового пользователя значение его имени по умолчанию будет равняться пустой строке. Так же, как и в случае с обычными переменными в PHP, переменные класса не обязательно инициализировать, но лучше все-таки не лениться. Если вы не инициализируете переменную класса, то по умолчанию ее значение равно null.

Доступ к переменным класса

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

$object->propertyName

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

username = "Fred"; echo $member->username; // Выведет "Fred" ?>

Запустите данный код, он выведет на экран строку “Fred”, значение переменной класса $member->username. Как видите, вы оперируете переменной объекта так же, как обычной переменной - вы можете задать ей значение и прочитать его.

Добавление методов в класс

Что скажете насчет создания методов? Как я ранее упоминал, методы - это обычные функции, являющиеся частью класса. Так что вы, возможно, не удивитесь тому, что и создаются они с помощью того же ключевого слова function. Единственное отличие от создания обычных функций заключается в том, что вы также можете добавить один из идентификаторов доступа (public, private, protected) в ее объявлении. В этом методы схожи с переменными класса:

Class ClassName { public function methodName() { // (код) } private function methodName() { // (код) } protected function methodName() { // (код) } }

На заметку: так же, как и в случае с переменными класса, методы public могут быть вызваны откуда угодно, методы private могут вызываться только в пределах класса, а методы protected - из самого класса и его наследника.

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

  • переменная класса private $loggedIn для идентификации пользователя, т.е. зашел он или нет,
  • метод login(), который будет осуществлять вход на форум, устанавливая значение переменной класса $loggedIn в true,
  • метод logout(), который будет осуществлять выход из форума, устанавливая значение переменной класса $loggedIn в false,
  • метод isLoggedIn(), который будет возвращать значение переменной класса $loggedIn.

Вот наш код:

loggedIn = true; } public function logout() { $this->loggedIn = false; } public function isLoggedIn() { return $this->loggedIn; } } ?>

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

Например, метод login() может получить доступ к переменной класса $loggedIn объекта через $this->loggedIn.

Кстати, наша переменная класса - частная (private), поэтому ее нельзя вызывать из любой части скрипта, а только из методов login(), logout() и isLoggedIn(). Это хороший подход, так как внутренняя часть объекта (например, то, как именно записывается, авторизовался ли пользователь или нет) находится отдельно от остального кода. По возможности старайтесь использовать именно переменные класса private, чтобы ваши объекты были автономными, мобильными и защищенными.

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

Использование методов

Чтобы вызвать метод объекта, воспользуйтесь оператором ->, с которым вы уже успели подружиться.

$object->methodName()

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

loggedIn = true; } public function logout() { $this->loggedIn = false; } public function isLoggedIn() { return $this->loggedIn; } } $member = new Member(); $member->username = "Fred"; echo $member->username . " is " . ($member->
"; $member->login(); echo $member->username . " is " . ($member->isLoggedIn() ? "logged in" : "logged out") . "
"; $member->logout(); echo $member->username . " is " . ($member->isLoggedIn() ? "logged in" : "logged out") . "
"; ?>

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

Fred is logged out Fred is logged in Fred is logged out

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

  1. После описания класса Member мы создали его объект и сохранили в переменной $member. Также мы дали переменной класса $username данного объекта значение “Fred”.
  2. Затем мы вызвали метод $member->isLoggedIn() для того, чтобы определить, залогинился ли пользователь или нет. Данный метод просто-напросто возвращает значение переменной класса $loggedIn. Так как значение по умолчанию этой переменной класса - false, значит результатом вызова $member->isLoggedIn() будет ложь, поэтому отобразится сообщение "Fred is logged out".
  3. Затем вызовем метод login(). Он установит в true значение переменной класса $loggedIn.
  4. Теперь, при вызове метода $member->isLoggedIn() вернется истина, и выведется сообщение "Fred is logged in".
  5. Вызовем метод logout(), который устанавливает в false значение свойства $loggedIn.
  6. В третий раз вызовем метод $member->isLoggedIn(). Сейчас он вернет false, потому что значение свойства $loggedIn опять установлено в ложь. Так, снова выведется сообщение "Fred is logged out".

На заметку: на случай, если вы в первые увидели такое: ?:, - это тернарный оператор. Это упрощенная версия блоков if … else. Узнать о такого рода операторах можно .

Выводы

В этом уроке вы познакомились с основами ООП в PHP. Вы узнали о таких вещах, как:

  • что такое ООП и почему его полезно применять
  • понятия классов, объектов, переменных класса и методов
  • как создавать классы и объекты
  • как создавать и использовать переменные классов
  • понятия идентификаторов доступа public, private, protected
  • как создавать и применять методы классов

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

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

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

Класс - это шаблон кода, который используется для создания объектов. Класс определяется с помощью ключевого слова 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 указать какое-либо другое значение по умолчанию, будет выдана ошибка.

У Вас в браузере заблокирован 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

Класс Table 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

Классы Table и HTMLTable 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