Объектно ориентированное программирование php на примерах. Использование конструкторов и деструкторов. Как создать класс в PHP

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

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

Объектно-ориентированное программирование - это стиль кодирования, который позволяет разработчикам группировать схожие задачи в классы . Это помогает сохранить код в соответствии с принципом «не повторяйся» (DRY) и простым в обслуживании.

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

Одним из основных преимуществ программирования по принципу DRY является то, что если в вашей программе изменяется часть информации, обычно требуется только одно изменение для обновления кода. Одним из самых больших кошмаров для разработчиков является поддержание кода, в котором данные объявляются снова и снова, а это означает, что любые изменения в программе становятся похожими на бесконечную игру Where"s Waldo ?

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

Понимание объекты и классы

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

Узнаем различия между объектами и классами

Фотографии от Instant Jefferson и John Wardell

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

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

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

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

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

Структурирование классов

Синтаксис для создания класса довольно прост: объявить класс с помощью ключевого слова class , за которым следует имя класса и набор фигурных скобок ({}):

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

$obj = new MyClass;

Чтобы увидеть содержимое класса, используйте var_dump ():

Var_dump($obj);

Попробуйте выполнить этот процесс, разместив весь предыдущий код в новом файле test.php в [локальной] папке для тестирования:

Загрузите страницу в браузере по адресу http: //localhost/test.php , и на экране должно появиться следующее:

Object(MyClass)#1 (0) { }

В своей простейшей форме вы только что завершили свой первый ООП-скрипт.

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

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

Чтобы добавить свойство в MyClass , добавьте следующий код в свой скрипт:

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

Echo $obj->prop1;

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

prop1; // Output the property ?>

I"m a class property!

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

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

Например, чтобы создать методы, которые будут устанавливать и получать значение свойства класса $prop1 , добавьте в свой код следующее:

prop1 = $newval; } public function getProperty() { return $this->prop1 . "
"; } } $obj = new MyClass; echo $obj->prop1; ?>

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

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

prop1 = $newval; } public function getProperty() { return $this->prop1 . "
"; } } $obj = new MyClass; echo $obj->getProperty(); // Get the property value $obj->setProperty("I"m a new property value!"); // Set a new one echo $obj->getProperty(); // Read it out again to show the change ?>

Перезагрузите браузер, и вы увидите следующее:

I"m a class property! I"m a new property value!

"Сила ООП становится очевидной при использовании нескольких экземпляров
одного класса."

prop1 = $newval; } public function getProperty() { return $this->prop1 . "
"; } } // Create two objects $obj = new MyClass; $obj2 = new MyClass; // Get the value of $prop1 from both objects echo $obj->getProperty(); echo $obj2->getProperty(); // Set new values for both objects $obj->setProperty("I"m a new property value!"); $obj2->setProperty("I belong to the second instance!"); // Output both objects" $prop1 value echo $obj->getProperty(); echo $obj2->getProperty(); ?>

Когда вы загружаете результаты в свой браузер, они отобразят следующее:

I"m a class property! I"m a class property! I"m a new property value! I belong to the second instance!

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

Волшебные методы в ООП

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

Использование конструкторов и деструкторов

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

В целях иллюстрации концепции конструкторов добавьте конструктор в MyClass , который будет выводить сообщение всякий раз, когда создается новый экземпляр класса:

"; } public function setProperty($newval) { $this->prop1 = $newval; } public function getProperty() { return $this->prop1 . "
"; } } // Create a new object $obj = new MyClass; // Get the value of $prop1 echo $obj->
"; ?>

Примечание . __CLASS__ возвращает имя класса, в котором оно вызывается; Это то, что известно как волшебная константа . Существует несколько доступных магических констант, о которых вы можете прочитать в руководстве по PHP.

The class "MyClass" was initiated! I"m a class property! End of file.

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

Вывести сообщение, когда объект уничтожен, определяя магический метод
__destruct() в MyClass:

При определенном деструкторе перезагрузка тестового файла приводит к следующему выводу:

The class "MyClass" was initiated! I"m a class property! End of file. The class "MyClass" was destroyed.

«Когда достигнут конец файла, PHP автоматически освобождает все ресурсы».

Чтобы явно вызвать деструктор, вы можете уничтожить объект, используя
функцию unset() :

"; } public function __destruct() { echo "The class "", __CLASS__, "" was destroyed.
"; } public function setProperty($newval) { $this->prop1 = $newval; } public function getProperty() { return $this->prop1 . "
"; } } // Create a new object $obj = new MyClass; // Get the value of $prop1 echo $obj->getProperty(); // Destroy the object unset($obj); // Output a message at the end of the file echo "End of file.
"; ?>

Теперь при загрузке в вашем браузере результат будет выглядеть следующим образом:

The class "MyClass" was initiated! I"m a class property! The class "MyClass" was destroyed. End of file.

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

Чтобы избежать ошибки, если скрипт пытается вывести MyClass в виде строки, используется другой магический метод, называемый __toString() .

Без __toString() попытка вывода объекта в виде строки приводит к фатальной ошибке . Попытка использовать echo для вывода объекта без использования магического метода:

Это приводит к следующему результату:

The class "MyClass" was initiated! Catchable fatal error: Object of class MyClass could not be converted to string in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 40

Чтобы избежать этой ошибки, добавим метод __toString() :

В этом случае попытка преобразовать объект в строку приведет к вызову метода getProperty(). Загрузите тестовый скрипт в свой браузер, чтобы увидеть результат:

The class "MyClass" was initiated! Using the toString method: I"m a class property! The class "MyClass" was destroyed. End of file.

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

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

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

"; } public function __destruct() { echo "The class "", __CLASS__, "" was destroyed.
"; } public function __toString() { echo "Using the toString method: "; return $this->getProperty(); } public function setProperty($newval) { $this->prop1 = $newval; } public function getProperty() { return $this->prop1 . "
"; } } class MyOtherClass extends MyClass { public function newMethod() { echo "From a new method in " . __CLASS__ . ".
"; } } // Create a new object $newobj = new MyOtherClass; // Output the object as a string echo $newobj->newMethod(); // Use a method from the parent class echo $newobj->getProperty(); ?>

После перезагрузки тестового файла в вашем браузере выводится следующее:

The class "MyClass" was initiated! From a new method in MyOtherClass. I"m a class property! The class "MyClass" was destroyed.

Перезапись унаследованных свойств и методов

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

"; } public function __destruct() { echo "The class "", __CLASS__, "" was destroyed.
"; } public function __toString() { echo "Using the toString method: "; return $this->getProperty(); } public function setProperty($newval) { $this->prop1 = $newval; } public function getProperty() { return $this->prop1 . "
"; } } class MyOtherClass extends MyClass { public function __construct() { echo "A new constructor in " . __CLASS__ . ".

"; } } // Create a new object $newobj = new MyOtherClass; // Output the object as a string echo $newobj->newMethod(); // Use a method from the parent class echo $newobj->getProperty(); ?>

Это изменяет вывод в браузере на:

A new constructor in MyOtherClass. From a new method in MyOtherClass. I"m a class property! The class "MyClass" was destroyed.

Сохранение оригинальной функциональности метода при перезаписи методов

Чтобы добавить новые функции к унаследованному методу, сохранив исходный метод нетронутым, используйте ключевое слово parent с оператором разрешения области видимости (::):

"; } public function __destruct() { echo "The class "", __CLASS__, "" was destroyed.
"; } public function __toString() { echo "Using the toString method: "; return $this->getProperty(); } public function setProperty($newval) { $this->prop1 = $newval; } public function getProperty() { return $this->prop1 . "
"; } } class MyOtherClass extends MyClass { public function __construct() { parent::__construct(); // Call the parent class"s constructor echo "A new constructor in " . __CLASS__ . ".
"; } public function newMethod() { echo "From a new method in " . __CLASS__ . ".
"; } } // Create a new object $newobj = new MyOtherClass; // Output the object as a string echo $newobj->newMethod(); // Use a method from the parent class echo $newobj->getProperty(); ?>

Это выведет результат как родительского конструктора, так и конструктора нового класса:

The class "MyClass" was initiated! A new constructor in MyOtherClass. From a new method in MyOtherClass. I"m a class property! The class "MyClass" was destroyed.

Указание видимости свойств и методов

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

«Для дополнительного контроля над объектами методам и свойствам указывается их видимость."

Примечание . Видимость - новая функция в PHP, начиная с версии 5. Информацию о совместимости ООП с PHP 4 смотрите на странице руководства PHP.

Публичные свойства и методы

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

Защищенные свойства и методы

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

Объявите метод getProperty() как защищенный в MyClass и попытайтесь получить к нему доступ непосредственно извне класса:

При попытке запустить этот сценарий появляется следующая ошибка:

The class "MyClass" was initiated! A new constructor in MyOtherClass. Fatal error: Call to protected method MyClass::getProperty() from context "" in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 55

Теперь создайте новый метод в MyOtherClass для вызова метода getProperty() :

"; } public function __destruct() { echo "The class "", __CLASS__, "" was destroyed.
"; } public function __toString() { echo "Using the toString method: "; return $this->getProperty(); } public function setProperty($newval) { $this->prop1 = $newval; } protected function getProperty() { return $this->prop1 . "
"; } } class MyOtherClass extends MyClass { public function __construct() { parent::__construct(); echo "A new constructor in " . __CLASS__ . ".
"; } public function newMethod() { echo "From a new method in " . __CLASS__ . ".
"; } public function callProtected() { return $this->getProperty(); } } // Create a new object $newobj = new MyOtherClass; // Call the protected method from within a public method echo $newobj->callProtected(); ?>

Это приведет к желаемому результату:

The class "MyClass" was initiated! A new constructor in MyOtherClass. I"m a class property! The class "MyClass" was destroyed.

Приватные свойства и методы

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

Чтобы продемонстрировать это, объявите getProperty() как private в MyClass и попытайтесь вызвать callProtected() из
MyOtherClass:

"; } public function __destruct() { echo "The class "", __CLASS__, "" was destroyed.
"; } public function __toString() { echo "Using the toString method: "; return $this->getProperty(); } public function setProperty($newval) { $this->prop1 = $newval; } private function getProperty() { return $this->prop1 . "

"; } public function newMethod() { echo "From a new method in " . __CLASS__ . ".
"; } public function callProtected() { return $this->getProperty(); } } // Create a new object $newobj = new MyOtherClass; // Use a method from the parent class echo $newobj->callProtected(); ?>

Перезагрузите браузер, и появится следующая ошибка:

The class "MyClass" was initiated! A new constructor in MyOtherClass. Fatal error: Call to private method MyClass::getProperty() from context "MyOtherClass" in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 49

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

Доступ к методу или свойству, объявленному static , возможен без создания экземпляра класса; Вы просто указываете имя класса, оператор разрешения области и имя свойства или метода.

«Одним из основных преимуществ использования статических свойств является то, что они сохраняют свои значения в течение всего срока действия скрипта».

Чтобы продемонстрировать это, добавьте статическое свойство $count и статический метод с именем plusOne() в MyClass . Затем установите цикл do ... while для вывода приращенного значения $count , пока значение меньше 10:

"; } public function __destruct() { echo "The class "", __CLASS__, "" was destroyed.
"; } public function __toString() { echo "Using the toString method: "; return $this->getProperty(); } public function setProperty($newval) { $this->prop1 = $newval; } private function getProperty() { return $this->prop1 . "
"; } public static function plusOne() { return "The count is " . ++self::$count . ".
"; } } class MyOtherClass extends MyClass { public function __construct() { parent::__construct(); echo "A new constructor in " . __CLASS__ . ".
"; } public function newMethod() { echo "From a new method in " . __CLASS__ . ".
"; } public function callProtected() { return $this->getProperty(); } } do { // Call plusOne without instantiating MyClass echo MyClass::plusOne(); } while (MyClass::$count < 10); ?>

Примечание . При доступе к статическим свойствам знак доллара
($) идет после оператора разрешения области видимости .

Когда вы загружаете этот скрипт в своем браузере, выдается следующее:

The count is 1. The count is 2. The count is 3. The count is 4. The count is 5. The count is 6. The count is 7. The count is 8. The count is 9. The count is 10.

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

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

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

Самой трудной для понимания концепцией являются основы ООП , так как они отличаются от обычного программирования на PHP. Но как только вы поймете основные принципы, сама модель станет для вас простой и понятной.

Что такое ООП на PHP?

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

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

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

Простое определение объектно-ориентированного программирования:

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

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

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

Важные термины руководства по ООП на PHP:

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

Класс

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

Объект

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

Переменная-член

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

Функция-член

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

Конструктор

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

Деструктор

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

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

В PHP 5 ООП наследование – это процесс, при котором класс (подкласс ) получает все атрибуты и функции другого класса (суперкласса).

Суперкласс

Также известен как базовый или родительский класс — наследуется одним или несколькими подклассами.

Подкласс

Дочерний или производный класс, подкласс наследуется от суперкласса.

Полиморфизм

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

Инкапсуляция

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

Абстракция

Абстракция означает, что детали реализации функций или классов не видны.

, который означает, что функции, имеющие одинаковые имена, но разное количество аргументов, выполняются по-разному.

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

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

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

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

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

Преимущества ООП на PHP:

Улучшение архитектуры и более чистый код

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

Повторное использование

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

Простота в обслуживании и обновлении

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

Инкапсуляция

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

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

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

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

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

Зачем нужно ООП?

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

Иллюстрация из книги «Чистый код» — Роберт Мартин

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

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

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

Основные понятия

ООП – это методология (способ, подход) программирования согласно которой программный продукт представляется в виде взаимодействующих объектов. Я не согласен с тем, что ООП всегда подразумевает использование классов – js, например объектно-ориентированный язык, но в нём нет классов. Однако в применении к php ООП всегда подразумевает использование классов.

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

Три кита ООП

ООП основано на трёх принципах, которые часто называют тремя китами ООП, это:

инкапсуляция
полиморфизм
наследование

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

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

Наследование – это процесс приобретения одним типом объектов (классом) некоторых свойств другого типа объектов.

Очень часто бывает, что описание одного типа объектов то есть класс, полностью попадает под описание другого типа объектов. Например, класс, описывающий админа, может описать и пользователя, за исключением того, что у пользователя нет прав доступа. В этом случае имеет смысл сделать класс, описывающий админов, потомком класса, описывающего пользователей. При этом в классе, который описывает админов, не придётся описывать данные и поведение, которые уже описаны в классе «пользователь», нам необходимо только описать данные, которые будут отвечать за предоставления прав доступа. В этом случае класс «пользователь» будет предком класса «админ», который может иметь своего потомка, а тот своего и т.д. Цепочка наследования может быть сколь угодно длинной. Кроме того у одного предка может быть несколько потомков, каждый из которых полностью приобретёт свойства своего предка и добавит в них что-то своё, иначе наследование бессмысленно.

Полиморфизм – это использование одного и того же имени метода для решения нескольких похожих задач.

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

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

16 апреля 2008 в 12:15

PHP - ООП или процедурный подход

PHP один из самых популярных скриптовых языков программирования. Почти 60% веб серверов используют PHP.Миллионы веб-сайтов и веб-приложений разрабатываются на PHP каждый месяц.

PHP изначально разрабатывался как простая замена языку Perl, и уже спустя пару лет он стал чрезвычайно мощным и популярным. Язык PHP, сам по себе очень похож на ANSI C.
Одна из причин почему PHP стал таким популярным это его короткий период обучения.

Изучение PHP абсолютно не тяжёлое занятие, особенно если вы хорошо знакомы с синтаксисом Java или C.

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

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

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

PHP позволяет нам писать приложения 2мя разными способами, первый - процедурный, а второй объектно ориентированный. Если вы до сих пор не поняли разницу между этими двумя подходами, давайте посмотрим на эти куски кода - один и тот же пример написанный разными подходами.

Процедурный:

$user_input = $_POST[‘field‘];
$filtered_content = filter($user_input); //user input filtering
mysql_connect(«dbhost»,«dbuser»,«dbpassword»); //database
mysql_select_db(«dbname»);
$sql = «some query»;
$result = mysql_query($sql);
while ($data = mysql_fetch_assoc())
{
process ($data);
}
process_user_input($filtered_content);

А вот тот же кусок кода с использованием ООП:

$input_filter = new filter();
$input_filter->filter_user_input(); //filter the user inputs
$db = new dal(«mysql»); //data access layer
$db->connect($dbconfig);//we wre using mysql
$result = $db->execute($sql);
ReportGenerator::makereport($result); //process data
$model = new Postmodel($filter->get_filtered_content());
$model->insert();

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

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

Исходя из изложенного выше, можно вынести преимущества использования ООП:

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

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

* Повторное использование : Объект это логический объект у которого есть комплект свойств и методов и он может взаимодействовать с другими объектами.. Объект может быть абсолютно независимым или может зависеть от других объектов. Объект обычно создают для решения специфических поставленных проблем. Следовательно когда другие разработчики сталкиваются с похожими проблемами, они могут подключить ваш класс к своему проекту и использовать его не боясь что он нарушит процесс их разработки. Это позволяет избежать DRY, что расшифровывается как Don’t Repeat Yourself (не повторяйся). В процедурном или модульном программировании, повторное использование возможно только в совокупности.

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

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

* Поддержка : объектно-ориентированный код легче поддерживать так как
он следует весьма жёстким соглашениям написания кода и пишется в самопоясняющейся форме.
К примеру, когда разработчик дополняет, перерабатывает код, или отлаживает его, он может легко найти внутреннюю структуру кода и поддерживать код время от времени. Более того, когда в вашем окружении работает команда разработчиков ООП может быть лучшим решением так как вы можете распределять ваш код между членами команды, после разбития его на маленькие части. Эти маленькие части могут быть разработаны как отдельные объекты, следовательно разработчики могут работать практически независимо друг от друга. В конечном итоге объеденить все части в одно приложение не составит большого труда.

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

P.S мой первый хабратопик, если понравится буду переводить книгу дальше, как по мне довольно интересная и содержательная

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

Существует множество различных, простых примеров, в которых приводится принцип работы ООП. Сегодня я решил показать вам, как работает ООП (Объектно-ориентированное, или объектное, программирование) в реальной жизни; особенно данный пример пригодится начинающим программистам. Создав класс под MYSQL CRUD (CRUD -англ. create read update delete - «Создание чтение обновление удаление»), вы сможете легко создавать, читать, обновлять и удалять записи в любых ваших проектах, независимо от того, как спроектирована база данных.

Как только вы поймете, что нам требуется, вы легко создадите скелет для нашего класса. Для начала нам надо включить в класс основные функции для работы с MySQL. Потребуются следующие функции.

Select
Insert
Delete
Update
Connect
Disconnect

Ниже приведено определение нашего класса. Отметьте, что все методы, которые я создал, используют ключевое слово public .

Class Database { public function connect() { } public function disconnect() { } public function select() { } public function insert() { } public function delete() { } public function update() { } }

Функция connect()

Эта функция будет довольно простой, но прежде чем писать функцию, нам потребуется определить несколько переменных. Переменные должны быть доступны только в пределах класса, поэтому перед каждой переменной стоит ключевое слово private (закрытый). Все переменные (хост, имя пользователя, пароль, имя база данных) используются для соединения с базой данных MySQL. После этого мы сможем создать простой MySQL запрос к базе данных. Конечно, как программисты, мы должны ожидать от пользователей все что угодно, и исходя из этого, нам необходимо принять определенные меры предосторожности. Мы можем проверить: если пользователь уже подключен к базе данных, то, соответственно, ему не нужно повторно подключаться к БД. В противном случае, мы можем использовать учетные данные пользователя для подключения.

Private db_host = ‘’; private db_user = ‘’; private db_pass = ‘’; private db_name = ‘’; /* * Соединяемся с бд, разрешено только одно соединение */ public function connect() { if(!$this->con) { $myconn = @mysql_connect($this->db_host,$this->db_user,$this->db_pass); if($myconn) { $seldb = @mysql_select_db($this->db_name,$myconn); if($seldb) { $this->con = true; return true; } else { return false; } } else { return false; } } else { return true; } }

Как видите выше, мы используем базовые функции MySQL и делаем небольшую проверку на ошибки, чтобы все шло по плану. Если пользователь подключился к БД, мы возвращаем true , в ином случае возвращаем false. В качестве дополнительного бонуса устанавливаем переменную (con) в true, если соединение установлено.

Общедоступная (public) функция disconnect()

Функция проверяет переменную соединения на существование. Если соединение установлено (con есть), то закрываем соединение с БД MySQL и возвращаем true . Иначе делать ничего не нужно.

Public function disconnect() { if($this->con) { if(@mysql_close()) { $this->con = false; return true; } else { return false; } } }

Общедоступная (public) функция select()

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

Private $result = array(); /* * Проверяем наличие таблицы при выполнении запроса * */ private function tableExists($table) { $tablesInDb = @mysql_query("SHOW TABLES FROM ".$this->db_name." LIKE "".$table."""); if($tablesInDb) { if(mysql_num_rows($tablesInDb)==1) { return true; } else { return false; } } }

Эта функция просто проверяет наличие нужной таблицы в БД. Если таблица существует, вернет true , иначе вернет false .

/* * Выборка информации из бд * Требуется: table (наименование таблицы) * Опционально: rows (требуемые колонки, разделитель запятая) * where (колонка = значение, передаем строкой) * order (сортировка, передаем строкой) */ public function select($table, $rows = "*", $where = null, $order = null) { $q = "SELECT ".$rows." FROM ".$table; if($where != null) $q .= " WHERE ".$where; if($order != null) $q .= " ORDER BY ".$order; if($this->tableExists($table)) { $query = @mysql_query($q); if($query) { $this->numResults = mysql_num_rows($query); for($i = 0; $i numResults; $i++) { $r = mysql_fetch_array($query); $key = array_keys($r); for($x = 0; $x 1) $this->result[$i][$key[$x]] = $r[$key[$x]]; else if(mysql_num_rows($query) result = null; else $this->result[$key[$x]] = $r[$key[$x]]; } } } return true; } else { return false; } } else return false; }

На первый взгляд выглядит устрашающе, но при этом здесь мы делаем целую кучу важных вещей. Функция принимает четыре аргумента, один из которых обязательный. Функция вернет результат при наличии единственного аргумента - имени таблицы. Однако вы можете расширить количество аргументов и добавить новые аргументы, которые вы сможете использовать при работе с БД; ведь корректное исполнение функции зависит от одного аргумента – имени таблицы. Код в пределах функции служит для компиляции всех аргументов в select запрос. Как только запрос будет составлен, понадобится проверка на наличие в БД нужной таблицы – для этого используется функция tableExists . Если таблица найдена, то функция будет продолжена и запрос будет отправлен. Иначе все застопорится.

В следующей секции приведен действительно магический код. Суть в следующем: собрать данные запрошенные из таблицы. Затем присваиваем наш результат переменной. Чтобы упростить результат для конечного пользователя вместо числовых ключей будем использовать имена столбцов. В случае если количество строк таблицы больше единицы, на выходе вы получите двумерный массив, в котором первый ключ - это число (инкремент), второй ключ - это название колонки. Если в таблице всего одна строка, будет возвращен одномерный массив, название ключей которого соответствует именам столбцов таблицы. Если строк в таблице не найдено, переменной result будет присвоено значение null . Как я сказал ранее, все выглядит немного запутанным, но стоит вам разбить код на отдельные секции все станет гораздо проще и понятнее.

Общедоступная (public) функция insert()

Эта функция немного проще, чем предыдущие. Она просто позволяет вставить информацию в БД. Таким образом, помимо имени таблицы нам потребуются дополнительные аргументы. Нам потребуется переменная, которая будет содержать соответствующие для вставки в таблицу значения. Затем мы просто отделим каждое значение запятой. Также мы проверяем при помощи функции tableExists наличие нужной таблицы и составляем insert запрос, манипулируя аргументами, переданными в функцию insert() . Затем отправляем наш запрос по нужному адресу.

/* * Вставляем значения в таблицу * Требуемые: table (наименование таблицы) * values (вставляемые значения, передается массив значений, например, * array(3,"Name 4","[email protected]");) * Опционально: * rows (название столбцов, куда вставляем значения, передается строкой, * например, "title,meta,date" * */ public function insert($table,$values,$rows = null) { if($this->tableExists($table)) { $insert = "INSERT INTO ".$table; if($rows != null) { $insert .= " (".$rows.")"; } for($i = 0; $i < count($values); $i++) { if(is_string($values[$i])) $values[$i] = """.$values[$i]."""; } $values = implode(",",$values); $insert .= " VALUES (".$values.")"; $ins = @mysql_query($insert); if($ins) { return true; } else { return false; } } }

Как видите эта функция довольно простая, по сравнению с составлением запросов select к БД. На самом деле функция delete будет еще проще.

Общедоступная (public) функция delete()

Эта функция просто удаляет таблицу или строки из нашей БД. Таким образом, нам надо передать в функцию имя таблицы и опциональный аргумент определяющий условие where . В условии следующим за ключевым словом WHERE следует уточнение: удалить строку, строки или всю таблицу. Если условие where опущено, то будут удалены все строки. Затем составляется запрос delete и следует выполнение запроса.

/* * Удаяем таблицу или записи удовлетворяющие условию * Требуемые: таблица (наименование таблицы) * Опционально: где (условие ), передаем строкой, например, "id=4" */ public function delete($table,$where = null) { if($this->tableExists($table)) { if($where == null) { $delete = "DELETE ".$table; } else { $delete = "DELETE FROM ".$table." WHERE ".$where; } $del = @mysql_query($delete); if($del) { return true; } else { return false; } } else { return false; } }

Наконец перейдем к нашей последней основной функции. Эта функция служит для обновления строки в БД новой информацией. Данная функция на первый взгляд сложна для понимания, однако, это не совсем так. Мы будем использовать все те же принципы, что и раньше. Например, аргументы будут использоваться для составления запроса update . Также мы проверим наличие таблицы при помощи метода tableExists . Если таблица существует, обновим надлежащую строку. Самая сложная часть, конечно, та, где мы занимаемся составлением запроса update . Поскольку оператор update имеет правило за раз обновлять все строки, нам необходимо учесть это и правильно отрегулировать этот момент. Итак, я решил условие where передавать как простой массив. Первый аргумент в этом массиве - имя столбца, следующий аргумент значений столбца. Таким образом, каждый четный номер (включай 0) соответствует имени колонки, а каждый нечетный номер содержит нечетное значение. Соответствующий код приведен ниже:

For($i = 0; $i

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

Public function update($table,$rows,$where,$condition) { if($this->tableExists($table)) { // Parse the where values // even values (including 0) contain the where rows // odd values contain the clauses for the row for($i = 0; $i

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

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

Итак, мы создали наш класс, но как его использовать? Тут все просто. Давайте начнем с создания простой БД, в которой протестируем наш класс. Я создал базу данных test и составил простой mysql оператор. Вы можете поместить его в любую БД.

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

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

connect(); $db->select("mysqlcrud"); $res = $db->getResult(); print_r($res); ?>

Если все сделано корректно, вы увидите следующие:

Аналогичным образом мы можем запустить запрос на обновление и вывести результаты.

update("mysqlcrud",array("name"=>"Changed!"),array("id",1),"="); $db->update("mysqlcrud",array("name"=>"Changed2!"),array("id",2),"="); $res = $db->getResult(); print_r($res); ?>

На выходе: