PHP - ООП или процедурный подход
- 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 мой первый хабратопик, если понравится буду переводить книгу дальше, как по мне довольно интересная и содержательная
От автора: современное профессиональное программирование просто немыслимо, без объектно-ориентированного программирования, которое не гласно стало своеобразным стандартом высокоуровневых языков программирования и, конечно же, PHP не исключение. Но так сложилось, что переход от процедурного стиля программирования, к объектному, сопровождается некоторыми сложностями у новичков, поэтому сегодня мы с Вами рассмотрим основы ООП PHP.
Для начала, давайте рассмотрим основные преимущества объектно-ориентированного подхода, дабы понять, почему же он получил такое широкое распространение.
Код объектно-ориентированного подхода достаточно прост в понимании и чтении и отлично подходит для реализации масштабных и очень непростых проектов.
Приложения, написанные с использованием рассматриваемого подхода в программировании, легко модернизируются и расширяются.
Правильно спроектированные приложения, состоят из отдельных модулей, а значит, при необходимости могут быстро дорабатываться и обновляться, что на несколько порядков увеличивает скорость разработки.
Теперь, когда основные сильные стороны рассматриваемого стиля кодирования определены, можно переходить непосредственно к сути данного урока.
Итак, в основе объектно-ориентированного программирования в PHP, лежит принцип связывания данных и функций, манипулирующих ими в соответствующие объекты. Что несколько отличается от привычного процедурного подхода, где аналогичные элементы определены отдельно друг от друга. То есть объекты вмещают в себя некоторую информацию, которая сохранена в его свойствах (так называют переменные объектов) и определенный набор действий, которые описываются в его методах (по сути, обычные функции). При этом методы, как правило, в своей работе оперируют данными хранящимися в свойствах, что подразумевает как считывание, так и запись и изменение.
Соответственно, можно сказать, что основой методологии объектно-ориентированного программирования на PHP, является работа с объектами, или же использование их для манипуляции над данными.
При этом объект формируется из ранее определенного класса, причем последний, полностью описывает его структуру и выступает своеобразным шаблоном. Другими словами в классе описываются свойства и методы будущих создаваемых объектов. И это можно увидеть на следующем примере.
class Customer { public $name; protected $orders; public function __construct($name, $orders) { $this->name = $name; $this->orders = $orders; } public function getName() { return $this->name; } } $customer = new Customer("Ben", array("id" => 10)); echo $customer->getName();
class Customer { public $ name ; protected $ orders ; public function __construct ($ name , $ orders ) { $ this -> name = $ name ; $ this -> orders = $ orders ; public function getName () { return $ this -> name ; $ customer = new Customer ("Ben" , array ("id" = > 10 ) ) ; echo $ customer -> getName () ; |
При реализации экземпляра класса (то есть создание нового объекта, используя определенный интересующий класс), формируется новый объект, а так же определяются описанные в классе свойства. Кроме того запускается на исполнение специальный метод, под названием __construct(), если конечно он описан в структуре класса. Как Вы видите для создания объекта, используется ключевое слово new, за которым следует имя класса. В скобках при необходимости передаются аргументы для вышеуказанного метода, в котором, как правило, определяются некоторые начальные данные для будущего объекта.
В примере выше, помимо создания объекта, осуществляется вызов метода getName() и вывод на экран значения, возвращаемого им. Конечно, в результате работы скрипта мы увидим вывод имени пользователя — “Ben”, потому как, именно оно передается в качестве первого аргумента методу конструктору, где и записывается в свойство класса под именем name. Соответственно вышеуказанный метод возвращает в качестве результата своей работы значение данного свойства.
При этом ни кто Вам не запрещает сформировать еще один подобный объект из ранее описанного класса:
$customer2 = new Customer("Sem", array("id" => 15)); echo $customer2->getName();
$ customer2 = new Customer ("Sem" , array ("id" = > 15 ) ) ; echo $ customer2 -> getName () ; |
В этом случае на экране мы увидим имя уже совсем другого пользователя – “Sem”. Таким образом мы, по сути создали совсем другой объект из одного и того же шаблона – класса. При этом у данного объекта, совсем другие начальные данные, которые все так же формируются методом конструктором, а значит и его поведение, определяемое методами, так же будет другим.
Обратите внимание, что свойства класса и его методы, могут использоваться только с конкретным объектом — как раз это и видно на примере, и без него, они абсолютно бесполезны, в плане работы за пределами класса, потому как внутри класса, конечно же, они могут использоваться в коде его методов. Причем доступ к вышеуказанным элементам объекта, осуществляется через специальный набор знаков “->”(стрелочку) , перед которой необходимо указать интересующий объект,или же указатель объекта – ключевое слово $this. Указатель объекта $this, используется в коде методов, непосредственно внутри класса для обращения к его свойствам или же методам.
И опять же мы с Вами видим, что основа разработки ООП на PHP — это работа с объектами, причем прелесть заключается в том, что мы один раз описываем класс, а значит, формируем некий набор данных и необходимый функционал. А далее создаем объекты, каждый из которых в зависимости от начальных данных, по сути, будет абсолютно уникальным.
Из выше сказанного следует, класс – на основе которого будут созданы объекты, описывает данные и функционал определенной сущности будущего проекта, к примеру, работа с пользователями, страницами, меню, адресами и т.д. И конечно,если таких сущностей несколько, то и классов, нужно создавать несколько, а значит для каждого из них будет создан как минимум один объект. Хотя и не всегда, порой некоторые классы, создаются в качестве родителей для определенных дочерних классов, а значит выступают в роли хранения, некоторого общего функционала, что само собой подразумевает создание целой иерархии классов будущего проекта. Но это уже совсем другая тема, которая не вписывается в рамки текущей статьи.
Собственно, вот мы с Вами кратко и рассмотрели основы объектно-ориентированного программирования в PHP. Конечно, данный вид программирования требует большего внимания, нежели одна статья, если Вы хотите действительно хорошо разобраться в нем и использовать его в своих наработках. Более подробно данная тема рассмотрена в премиум курсе .
Всего Вам доброго у удачного кодирования!!!
Если вы найдете критические помарки по переводу, пожалуйста, оставляйте комментарии. Ваши замечания обязательно будут учтены. В любом случае надеюсь, вы найдете данную статью весьма полезной.
Существует множество различных, простых примеров, в которых приводится принцип работы ООП. Сегодня я решил показать вам, как работает ООП (Объектно-ориентированное, или объектное, программирование) в реальной жизни; особенно данный пример пригодится начинающим программистам. Создав класс под 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); ?>
На выходе:
Теперь просто вставим запись:
insert("mysqlcrud",array(3,"Name 4","[email protected]")); $res = $db->getResult(); print_r($res); ?>
Разработка веб-приложений с помощью объектно-ориентированного подхода на языке PHP поначалу может сбить с толку тех разработчиков, которые привыкли использовать процедурный подход, но на самом деле ничего сложного в ООП нет. В данном курсе мы рассмотрим теоретические аспекты ООП, а также научимся применять полученные знания на практике.
Курс состоит из 17 уроков, в которых мы шаг за шагом изучим основы ООП, которых должно быть достаточно для написания приложений в объектном стиле.
Изучив этот курс, Вы будете понимать, что такое объектно-ориентированное программирование, узнаете, что такое классы и объекты, а также поймете разницу между ними. Узнаете о свойствах, методах и константах класса.
После прохождения курсы Вы сможете использовать наследование классов для создания удобной и гибкой логики Вашего веб-приложения, создавать разветвленные иерархии классов. Будете уметь переопределять методы и тем самым расширять их функционал, создавать абстрактные классы. Из курса вы узнаете смысл использования интерфейсов и научитесь использовать их там, где это действительно может требоваться, а не использовать интерфейсы ради интерфейсов. Особое внимание в курсе отведено теме автозагрузки классов, что позволит исключить длинные списки подключаемых файлов. Здесь вы узнаете, как о функциях автозагрузки, так и научитесь использовать для этой цели пакетный менеджер Composer.
Все это и многое другое вы узнаете из уроков предлагаемого курса по ООП в PHP.
Все уроки курса:
Описание курса: В данном курсе мы рассмотрим теоретические аспекты ООП, а также научимся применять полученные знания на практике. Курс состоит из 17 уроков, в которых мы шаг за шагом изучим основы ООП, которых должно быть достаточно для написания приложений в объектном стиле.
Для многих программистов на 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:
";
}
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();
// Output a message at the end of the file
echo "End of file.
";
?>
При определенном деструкторе перезагрузка тестового файла приводит к следующему выводу:
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 для вывода объекта без использования магического метода:
";
}
public function __destruct()
{
echo "The class "", __CLASS__, "" was destroyed.
";
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "
";
?>
Это приводит к следующему результату:
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() :
";
}
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 . "
";
}
}
// Create a new object
$obj = new MyClass;
// Output the object as a string
echo $obj;
// Destroy the object
unset($obj);
// Output a message at the end of the file
echo "End of file.
";
?>
В этом случае попытка преобразовать объект в строку приведет к вызову метода 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 и попытайтесь получить к нему доступ непосредственно извне класса:
";
}
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 . "
";
}
public function newMethod()
{
echo "From a new method in " . __CLASS__ . ".
";
}
}
// Create a new object
$newobj = new MyOtherClass;
// Attempt to call a protected method
echo $newobj->getProperty();
?>
При попытке запустить этот сценарий появляется следующая ошибка:
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.
