Php объекты

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

Понятия объекта и класса объектов рассматривались в учебнике JavaScript. Объекты в языке PHP создаются по классу. Каждый объект является экземпляром какого-то класса объектов. Класс создаётся с помощью выражения class, после которого пишется имя класса. Далее в фигурных скобках перечисляются свойства и методы. Эти свойства и методы будут у всех объектов класса. Когда класс создан, можно использовать выражение new для создания объекта этого класса. Пример:

 <?php header('Content-type: text/html; charset=utf-8');
class Users //создаём класс  {  public $name;  public $prof;  } $user = new Users; //создаём объект класса

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

Если Вы не используете ООП, то можно в это не вникать, пишите модификатор public.

Свойства

Для обращения к свойствам объекта нужно написать имя объекта, затем «->» и название свойства. Установим значения свойств созданного объекта:

$user->name = "Николай"; $user->prof = "Повар"; echo $user->name;

Любому объекту можно добавить свои свойства и методы. Добавим объекту user свойство mail.

$user->mail = 'nik@mail.ru';

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

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

Методы

При написании методов часто используется псевдо-переменная $this. Для любого объекта это указание на сам этот объект. Через неё объект может обращаться к своим свойствам. Например, для объекта myobj строка $this->num равнозначна строке $myobj->num. В методах конкретного объекта можно обойтись без переменной $this и просто написать имя объекта. А вот в методах класса она необходима. Она используется для того, чтобы каждый объект класса обращался именно к своим свойствам. Для примера, добавим метод классу Users. Создание класса будет выглядеть так:

class Users  {  public $name;  public $prof;  public function inform ()  {  echo 'Имя: '.$this->name.', профессия: '.$this->prof;  }  }

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

echo '<br>'; $user->inform();

basecourse.ru

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

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

В этой лекции мы рассмотрим объектную модель, предлагаемую языком PHP. Будут представлены понятия класса и объекта, способы их задания и использования, способы расширения классов, конструкторы классов, механизмы наследования и т.п. Кроме того, мы затронем некоторые нововведения, касающиеся объектной модели, появившиеся в PHP5.

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

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

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

В PHP класс определяется с помощью следующего синтаксиса:

class Имя_класса{
var $имя_свойства;
/*список свойств*/
function имя_метода( ){
/* определение метода */
}
/*список методов*/
}

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

Например, нам нужно создать класс, описывающий категорию статей. У каждой статьи имеются такие свойства, как название, автор и краткое содержание. Какие действия мы хотим совершать со статьями? Возможно, нам понадобится задавать значения перечисленным свойствами статьи, отображать статью в браузере. Тогда определение этого класса может выглядеть следующим образом:

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

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

Как известно, работая с PHP, можно периодически переключаться в режим HTML. В этом случае программа состоит из нескольких кусков (блоков) кода. Определение класса нельзя разносить по разным блокам php-кода и тем более по разным файлам. То есть если написать:

<?php
class Articles { // Начало описания класса
var $title;
?>
<?php
// продолжение описания класса
function show_article(){
// содержание метода
}
} // конец описания класса
?>

то программа не будет работать корректно.

Несколько замечаний по поводу имен классов. Имя класса должно удовлетворять правилам именования объектов в языке PHP, но есть ряд имен, которые зарезервированы разработчиками для своих целей. В первую очередь это имена, начинающиеся с символа подчеркивания «_». Для создания классов и функций нельзя использовать такие имена. Кроме того, зарезервировано имя stdClass, поскольку оно используется внутри движка PHP.

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

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

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

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

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

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

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

Объекты

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


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

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


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

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

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

extends

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Оператор ::

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

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

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

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

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

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

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

Оператор parent

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

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

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

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

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

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

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

Заключение

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

wm-help.net

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

В классах можно определять специальные переменные, которые называются свойствами. Свойство, которое называется также переменной-членом (member variable), содержит данные, которые могут меняться от одного объекта к другому. В случае объектов ShopProduct нам нужно иметь возможность менять, например, поля названия товара и его цены.

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

Область видимости (scope) определяет контекст функции или класса, в котором можно пользоваться данной переменной (или методом, о чем мы поговорим в следующей статье). Так переменная, определенная внутри тела функции, имеет локальную область видимости, а переменная, определенная за пределами функции — глобальную область видимости. Как правило, нельзя получить доступ к данным, находящимся в локализованных областях видимости по отношению к текущей области. Поэтому если вы определяете переменную внутри функции, то впоследствии не сможете получить к ней доступ извне этой функции. Объекты в этом смысле более «проницаемы», и к некоторым объектным переменным можно иногда получать доступ из другого контекста. К каким переменным можно получать доступ и из какого контекста, и определяют ключевые слова public, protected или private.

К этим ключевым словам и вопросу видимости мы вернемся в следующей статье. А сейчас давайте определим некоторые свойства с помощью ключевого слова public:

Код PHP

class ShopProduct   {  	public $title = "Стандартный товар";  	public $producerMainName = "Фамилия автора";  	public $producerFirstName = "Имя автора";  	public $price = 0;  }

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

Ключевые слова public, protected и private, определяющие область видимости свойств, появились в PHP 5. В версии PHP 4 приведенный выше пример работать не будет. В PHP 4 все свойства должны быть объявлены с помощью ключевого слова var, что, по сути, идентично использованию ключевого слова public. Исходя из принципа обратной совместимости, в PHP 5 допускается использование для свойств ключевого слова var вместо public.

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

Код PHP

class ShopProduct   {  	public $title = "Стандартный товар";  	public $producerMainName = "Фамилия автора";  	public $producerFirstName = "Имя автора";  	public $price = 0;  }    $product1 = new ShopProduct();  $product2 = new ShopProduct();    // Изменяем значение по умолчанию объекта $product1  $product1->title = 'Золотые сказки';  $product2->title = 'Собачье сердце';    // Вывести на экран значение свойства  echo $product2->title;

Объявляя и определяя свойство $title в классе ShopProduct, мы гарантируем, что при создании любого объекта типа ShopProduct это свойство будет присутствовать и его значение будет заранее определено. Это означает, что при таком предположении код, использующий данный класс, сможет работать с любыми объектами типа ShopProduct. Но поскольку мы можем легко переопределить это свойство, значение $title может меняться от одного объекта к другому.

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

Код PHP

$product1->newProperty = "Новое свойство";

Но нужно отметить, что этот способ присвоения свойств объектам считается дурным тоном в объектно-ориентированном программировании и почти никогда не используется. Но почему динамическое определение свойств — это дурной тон? Создавая класс, вы определяете тип. Вы сообщаете всем о том, что ваш класс (и любой объект, который является его экземпляром) содержит определенный набор полей и функций. Если в классе ShopProduct определяется свойство $title, то любой код, который работает с объектами типа ShopProduct, может исходить из предположения, что свойство $title определено. Но подобной гарантии относительно свойств, определенных динамически, не существует.

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

Код PHP

$product2 = new ShopProduct();    $product2->title = 'Собачье сердце';  $product2->producerMainName = "Булгаков";   $product2->producerFirstName = "Михаил";  $product2->price = 5.99;

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

Код PHP

echo "Автор: <b>{$product2->producerFirstName} "."{$product2->producerMainName}</b>";

В результате на выходе получим следующее:

Php объекты
Вывод значений нескольких свойств объекта

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

Код PHP

$product2->producerSecondName = "Булгаков"; 

С точки зрения интерпретатора PHP, этот код абсолютно корректен, поэтому никакого предупреждения об ошибке мы не получим. Но когда понадобится вывести имя автора, мы получим неожиданные результаты. Еще одна проблема — наши объекты, в целом, слишком «нестрогие». Мы не обязаны определять название книги, цену или имя автора. Клиентский код может быть уверен, что эти свойства существуют, но, вполне вероятно, очень часто их стандартные значения не будут вас устраивать. В идеале, следовало бы заставлять всякого, кто создает экземпляры объекта ShopProduct, определять осмысленные значения его свойств.

И наконец, мы должны потратить уйму сил, чтобы сделать то, что, вероятно, придется делать очень часто. Вывести полное имя автора — это довольно трудоемкий и нудный процесс. И было бы прекрасно, если бы объект делал это за нас. Все эти проблемы можно решить, если снабдить объект ShopProduct собственным набором функций, которые можно использовать для выполнения операций над данными внутри контекста объекта.

Методы

Так же как свойства позволяют объектам сохранять данные, методы позволяют объектам выполнять задачи. Методы (methods) — это специальные функции, которые объявляются внутри класса. Как и можно было ожидать, объявление метода напоминает объявление функции. За ключевым словом function следует имя метода, а за ним — необязательный список переменных-аргументов в круглых скобках. Тело метода заключается в фигурные скобки:

public function myMethod( $arg1, $arg2, ... argN )  {   	// ...  }

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

В большинстве случаев метод вызывают с помощью объектной переменной, за которой указываются символы ‘->’ и имя метода. При вызове метода нужно использовать круглые скобки, так же как при вызове функции (даже если методу не передаются никакие аргументы). Давайте добавим методы к определенному ранее классу ShopProduct:

Код PHP

class ShopProduct   {  	public $title = "Стандартный товар";  	public $producerMainName = "Фамилия автора";  	public $producerFirstName = "Имя автора";  	public $price = 0;  	  	function getProducer() {  		return "{$this->producerFirstName} {$this->producerMainName}";	  	}  }    $product2 = new ShopProduct();    $product2->title = 'Собачье сердце';  $product2->producerMainName = "Булгаков";   $product2->producerFirstName = "Михаил";  $product2->price = 5.99;    // Вызов метода  echo 'Автор: <b>'.$product2->getProducer().'</b>';

В результате на выходе получим результат аналогичный предыдущему.

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

При определении метода getProducer() мы воспользовались новой возможностью — псевдопеременной $this. Она представляет собой механизм, посредством которого класс может обратиться к экземпляру объекта. Если вы считаете, что это трудно для понимания, попробуйте заменить $this «текущим экземпляром объекта». Тогда оператор $this->producerFirstName превратится в свойство $producerFirstName текущего экземпляра объекта. Так, метод getProducer() объединяет и возвращает значения свойств $producerFirstName и $producerMainName, избавляя нас от неприятной работы всякий раз, когда нужно вывести полное имя автора.

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

Конструктор класса

Метод конструктора вызывается при создании объекта. Его можно использовать, чтобы все настроить, обеспечить определение необходимых свойств и выполнить всю необходимую предварительную работу. До PHP 5 имя метода конструктора совпадало с именем класса, к которому оно относилось. Так, класс ShopProduct мог использовать метод ShopProduct() в качестве своего конструктора. В PHP 5 вы должны назвать метод конструктора __construct(). Обратите внимание на то, что имя метода начинается с двух символов подчеркивания. Это правило наименования действует для многих других специальных методов в PHP-классах. Давайте определим конструктор для класса ShopProduct:

Код PHP

class ShopProduct   {  	public $title = "Стандартный товар";  	public $producerMainName = "Фамилия автора";  	public $producerFirstName = "Имя автора";  	public $price = 0;  	  	function __construct($title, $firstName, $mainName, $price) {  		$this->title = $title;  		$this->producerMainName = $mainName;  		$this->producerFirstName = $firstName;  		$this->price = $price;  	}  	  	function getProducer() {  		return "{$this->producerFirstName} {$this->producerMainName}";	  	}  }    // Удобная инициализация объектов, за счет использования конструктора  $product1 = new ShopProduct('Золотые сказки', 'Александр', 'Пушкин', 10.99);  $product2 = new ShopProduct('Собачье сердце', 'Михаил', 'Булгаков', 5.99);    // Вызов метода  echo 'Автор: <b>'.$product2->getProducer().'</b>';

И снова мы добавляем к классу функциональность, стараясь сэкономить время и силы программиста и избавить его от необходимости дублирования кода, работающего с этим классом. Метод __construct вызывается, когда создается объект с помощью оператора new. Значения всех перечисленных аргументов при создании объекта передаются конструктору. Так, в нашем примере мы передаем конструктору название произведения, имя и фамилию автора, а также цену. В методе конструктора используется псевдопеременная $this для присвоения значений соответствующим свойствам объекта.

В PHP 4 не распознается метод __construct в качестве конструктора. Если вы используете PHP 4, то для создания конструктора объявите метод, имя которого совпадает с именем содержащего его класса. Поэтому для класса с именем ShopProduct можно объявить конструктор с помощью метода под названием ShopProduct(). В PHP по-прежнему поддерживается эта схема именования конструктора. Но если вам не нужна совместимость со старыми версиями PHP то методы конструктора лучше называть __construct.

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

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

Аргументы и типы

Типы определяют, каким способом можно оперировать данными в сценариях. Например, строковый тип используется для отображения символьных данных и для выполнения операций над такими данными с помощью строковых функций. Целые числа используются в математических выражениях, булевы числа — в логических выражениях и т.д. Эти категории называются элементарными типами данных. Класс также определяет тип имени себя, но на более высоком уровне. Поэтому объект ShopProduct относится к элементарному типу object, а также к типу класса ShopProduct. Более подробно о типах читайте в статье «Типы данных».

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

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

Код PHP

class ShopProductWriter  {  	public function write($shop) {  		$str = "{$shop->title}: <em>{$shop->getProducer()}</em> ({$shop->price})";  		echo $str;  	}  }

Мы можем протестировать этот класс следующим образом:

Код PHP

$product2 = new ShopProduct('Собачье сердце', 'Михаил', 'Булгаков', 5.99);    $writer = new ShopProductWriter();  $writer->write($product2);

Тогда на выходе получим следующее:

Php объекты
Вызов метода вспомогательного объекта

Возможно, вас заинтересует, почему мы не добавили метод write() непосредственно в класс ShopProduct. Ответом на поставленный вопрос будет следующее: все дело в ответственности. Класс ShopProduct ответственен за хранение данных о товаре, а класс ShopProductWriter — за вывод этих данных. Позже вы начнете понимать, в чем польза такого разделения ответственности.

Класс ShopProductWriter содержит единственный метод — write(). Методу write() передается объект типа ShopProduct. В нем используются свойства и методы последнего для построения и вывода результирующей строки описания товара. Мы используем имя переменной-аргумента, $shop, как напоминание программисту о том, что методу $write() нужно передать объект типа ShopProduct. Но это требование не является обязательным. Это значит, что я могу передать некорректный объект или элементарный тип методу $write() и ничего об этом не узнать до момента обращения к аргументу $shop. К тому времени в нашем коде уже могут быть выполнены какие-либо действия так, как если бы мы передали методу настоящий объект типа ShopProduct.

Для решения описанной проблемы в PHP 5 появилась новая возможность — уточнение типов данных класса. Чтобы добавить уточнение типа к аргументу метода, просто поместите перед ним имя класса. Поэтому метод write() можно изменить следующим образом:

Код PHP

class ShopProductWriter  {  	public function write(ShopProduct $shop) {  		...  	}  }

Теперь методу write() можно передавать аргумент $shop, содержащий только объект типа ShopProduct. Передача любого другого типа приведет к неустранимой ошибке «Catchable fatal error».

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

Хотя автоматическая проверка типов — это превосходный способ предотвращения ошибок, важно понимать, что уточнения проверяются во время выполнения программы. Это означает, что уточнение класса сообщит об ошибке только тогда, когда нежелательный объект будет передан методу. И если вызов метода write() находится где-то глубоко в условном операторе, который запускается только на Новый год, то, если вы тщательно не проверили код, вам придется работать все праздники.

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

Код PHP

function setArray( array $storearray ) {   	...  }

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

Код PHP

  function setWriter( ObjectWriter $obj_writer = null )   {  	...  }

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

PHP и объекты
Наследование классов

addphp.ru

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

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

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

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

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

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

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

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

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

Php объекты

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

Классы

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

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

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

Объекты

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

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

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

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

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

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

Методы

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

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

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

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

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

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

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

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

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

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

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

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

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

Php объекты

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

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

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

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

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

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

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

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

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

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

Php объекты

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

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

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

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

Вот наш код:

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

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

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

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

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

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

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

Мы добавили некоторые методы в наш класс, теперь давайте попробуем их применить для чего-то:

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

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

  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
  • как создавать и применять методы классов

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

До новых встреч!

ruseller.com


You May Also Like

About the Author: admind

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Этот сайт использует Akismet для борьбы со спамом. Узнайте как обрабатываются ваши данные комментариев.

Adblock
detector