Урок 11. Курс по ООП PHP. Интерфейсы и контроль типа


Содержание материала:

Список уроков по теме
«ООП»

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

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

Переменные в классе, называются «свойствами». Функция в классах называются «методом».

Слова public, private, protected определяют область видимості переменной или класса.

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

Класс, который содержит хотя бы один абстрактный метод, должен быть определен как абстрактный.

С помощью интерфейсов можно описать методы, которые должны бить реализованы в классе без необходимости описания их функционала.

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

В PHP 5 есть возможность использования контроля типов. При передаче параметром есть возможность проверить данные на такие типы: объекты (путем указания имени класса в прототипе функции), интерфейсы, массивы, колбеки с типом callable (начиная с PHP 5.4).

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

Начиная с версии 5.4.0 в PHP есть возможность использования инструментария для повторного использования кода. Он называется — трейт.

Интерфейсы в PHP

В этой статье мы продолжим заниматься возможностями по ООП, которые нам предоставляет PHP. И в этот раз разберём тему интерфейсов в PHP. Если кто-то изучал C++, то те знают, что там существует множественное наследование. То есть, когда один класс наследует сразу несколько других классов. На мой взгляд, это создаёт жуткую путаницу. Поэтому было принято решение: в PHP отказаться от множественного наследования. Однако, компенсировать это как-то было надо, и тогда придумали интерфейсы. Кстати, те, кто знает Java, поймут, о чём идёт речь, так как там тоже нет множественного наследования, но имеются интерфейсы. А о том, как использовать интерфейсы в PHP я расскажу в этой статье.

Интерфейс — это набор методов без реализации. То есть в интерфейс входят методы с именем и входными параметрами. Больше ничего нет. Любой класс, который реализует (обратите внимание, что не наследует, а реализует) данный интерфейс, обязан реализовать каждый метод. Чтобы стало ещё понятнее, хочется привести аналог из жизни. Каждый человек выполняет определённые функции. Например, учится, работает, убирает квартиру, готовит еду и занимается другими очевидными вещами. Можете считать, что интерфейс — это область занятий, например, учёба, работа, уборка квартиры, готовка еды. А методы интерфейса — это уже конкретная задача в данной области. Например, в уборке квартиры могут быть такие методы: мойка посуды, мойка пола, вынос мусора и другие. В готовке еды могут быть такие методы: готовка борща, готовка мяса, чистка картошки и прочее. Надеюсь, мысль Вы уловили.

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

Давайте разберём простой пример, создав следующий интерфейс (в файле «fileinterface.php«):

То есть данный интерфейс просто описывает работу с файлом. Соответственно, те объекты, которые должны читать из файла и записывать различные данные, обязаны реализовать интерфейс «FileInterface«.

Создадим ещё один интерфейс (в файле «client.php«):

Данный интерфейс реализует функцию клиента, то есть можно что-то купить (задаётся $id), а также что-то возвратить обратно (тоже задаётся по $id).

И, наконец, класс, который реализует эти интерфейсы, то есть класс у которого области задач две — быть клиентом и работать с файлом (файл «shop.php«):

writeToFile(«data.db», «Был куплен товар $id»);
>
public function repayment($id) <
$this->readFromFile(«data.db»);
//Тут, допустим, проверка того, была ли на самом деле покупка товара $id
$this->writeToFile(«data.db», «Был сделан возврат товара $id»);
>
>
?>

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

И, наконец, простой пример, который использует класс Shop:

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

Вот и всё, что хотелось сказать по интерфейсам в PHP.

Бесплатный курс «Объектно-ориентированное программирование»

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

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

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

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

  1. Среда разработки. В качестве неё возьмем Visual Studio Community с официального сайта. Эта версия программы бесплатна, поэтому просто качаем ее и устанавливаем к себе на ПК.
  2. Система контроля версий. Берём Git. Для облегчения работы с Git посмотрите курс «Git. Быстрый старт».

«Этот курс я считаю своим большим достижением. Материал с одной стороны весьма непрост для новичков, с другой стороны — является невероятно важным для любого программиста, — говорит преподаватель курса Евгений, — курс ориентирован на новичков, которые уже освоили «Основы программирования» и готовы идти дальше».

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

Основные понятия в объектно-ориентированном программировании – это объекты и классы.

Основные принципы – наследование, полиморфизм, инкапсуляция и абстракция.

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

В течение всего курса вы будете разрабатывать конкретный продукт – игру «Змейка». Для написания её вы будете использовать язык С#. Большой плюс состоит в том, что даже если вы изучаете другой язык программирования – ничего страшного, ведь принципы ООП для любого языка одинаковы.

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

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

Для того, чтобы писать качественные программы, вы должны понимать, как работает программа изнутри, т.е. что происходит внутри «железа» в тот момент, когда вы пишете код. Как используется оперативная память, каким образом что куда попадет и где хранится. Целый урок курса будет посвящен этой теме, весьма необходимой разработчику.

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

Почему именно «Змейка»?

На «Змейку» меня вдохновила моя жена. Мы вместе учились на факультете ВМиК МГУ, и данная программа была домашним заданием. Супруга напомнила мне, насколько это было круто и увлекательно, писать свою собственную игрушку. Тогда я написал программу кое-как, несмотря на то, что она работала. Только спустя годы работы программистом я понял, как можно написать ИДЕАЛЬНУЮ змейку, получив максимально читаемый, масштабируемый код. И насколько здорово эта программа отражает принципы ООП, если разрабатывать её правильно»

Куда двигаться дальше?

По окончании курса можно будет выбрать любое направление: изучать Java, Python, C++, C#, Ruby, Php — практически в любом языке вам придется столкнуться с ООП и использовать эти принципы при написании ЛЮБОЙ программы. Понимание базовых принципов ООП поможет вам с бОльшей легкостью освоить любой язык программирования.

Тем, кто хочет стать программистом, рекомендуем профессию «Веб-разработчик».

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

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

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

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

  1. Среда разработки. В качестве неё возьмем Visual Studio Community с официального сайта. Эта версия программы бесплатна, поэтому просто качаем ее и устанавливаем к себе на ПК.
  2. Система контроля версий. Берём Git. Для облегчения работы с Git посмотрите курс «Git. Быстрый старт».

«Этот курс я считаю своим большим достижением. Материал с одной стороны весьма непрост для новичков, с другой стороны — является невероятно важным для любого программиста, — говорит преподаватель курса Евгений, — курс ориентирован на новичков, которые уже освоили «Основы программирования» и готовы идти дальше».

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

Основные понятия в объектно-ориентированном программировании – это объекты и классы.

Основные принципы – наследование, полиморфизм, инкапсуляция и абстракция.

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

В течение всего курса вы будете разрабатывать конкретный продукт – игру «Змейка». Для написания её вы будете использовать язык С#. Большой плюс состоит в том, что даже если вы изучаете другой язык программирования – ничего страшного, ведь принципы ООП для любого языка одинаковы.

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

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

Для того, чтобы писать качественные программы, вы должны понимать, как работает программа изнутри, т.е. что происходит внутри «железа» в тот момент, когда вы пишете код. Как используется оперативная память, каким образом что куда попадет и где хранится. Целый урок курса будет посвящен этой теме, весьма необходимой разработчику.

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

Почему именно «Змейка»?

На «Змейку» меня вдохновила моя жена. Мы вместе учились на факультете ВМиК МГУ, и данная программа была домашним заданием. Супруга напомнила мне, насколько это было круто и увлекательно, писать свою собственную игрушку. Тогда я написал программу кое-как, несмотря на то, что она работала. Только спустя годы работы программистом я понял, как можно написать ИДЕАЛЬНУЮ змейку, получив максимально читаемый, масштабируемый код. И насколько здорово эта программа отражает принципы ООП, если разрабатывать её правильно»

Куда двигаться дальше?

По окончании курса можно будет выбрать любое направление: изучать Java, Python, C++, C#, Ruby, Php — практически в любом языке вам придется столкнуться с ООП и использовать эти принципы при написании ЛЮБОЙ программы. Понимание базовых принципов ООП поможет вам с бОльшей легкостью освоить любой язык программирования.

Тем, кто хочет стать программистом, рекомендуем профессию «Веб-разработчик».

Урок 11. Курс по ООП PHP. Интерфейсы и контроль типа

It seems like many contributors are missing the point of using an INTERFACE. An INTERFACE is not specifically provided for abstraction. That’s what a CLASS is used for. Most examples in this article of interfaces could be achieved just as easily using just classes alone.

An INTERFACE is provided so you can describe a set of functions and then hide the final implementation of those functions in an implementing class. This allows you to change the IMPLEMENTATION of those functions without changing how you use it.

For example: I have a database. I want to write a class that accesses the data in my database. I define an interface like this:

interface Database <
function listOrders();
function addOrder();
function removeOrder();
.
>

Then let’s say we start out using a MySQL database. So we write a class to access the MySQL database:

class MySqlDatabase implements Database <
function listOrders() <.
>
we write these methods as needed to get to the MySQL database tables. Then you can write your controller to use the interface as such:

$database = new MySqlDatabase();
foreach ($database->listOrders() as $order) <

Then let’s say we decide to migrate to an Oracle database. We could write another class to get to the Oracle database as such:

class OracleDatabase implements Database <
public function listOrders() <.
>

Then — to switch our application to use the Oracle database instead of the MySQL database we only have to change ONE LINE of code:

$database = new OracleDatabase();

all other lines of code, such as:

foreach ($database->listOrders() as $order) <

will remain unchanged. The point is — the INTERFACE describes the methods that we need to access our database. It does NOT describe in any way HOW we achieve that. That’s what the IMPLEMENTing class does. We can IMPLEMENT this interface as many times as we need in as many different ways as we need. We can then switch between implementations of the interface without impact to our code because the interface defines how we will use it regardless of how it actually works.

Just wrote some examples of duck-typing in PHP. Sharing here.

/**
* An example of duck typing in PHP
*/

interface CanFly <
public function fly ();
>

interface CanSwim <
public function swim ();
>

class Bird <
public function info () <
echo «I am a < $this ->name > \n» ;
echo «I am an bird\n» ;
>
>

/**
* some implementations of birds
*/
class Dove extends Bird implements CanFly <
var $name = «Dove» ;
public function fly () <
echo «I fly\n» ;
>
>

class Penguin extends Bird implements CanSwim <
var $name = «Penguin» ;
public function swim () <
echo «I swim\n» ;
>
>

class Duck extends Bird implements CanFly , CanSwim <
var $name = «Duck» ;
public function fly () <
echo «I fly\n» ;
>
public function swim () <
echo «I swim\n» ;
>
>

/**
* a simple function to describe a bird
*/
function describe ( $bird ) <
if ( $bird instanceof Bird ) <
$bird -> info ();
if ( $bird instanceof CanFly ) <
$bird -> fly ();
>
if ( $bird instanceof CanSwim ) <
$bird -> swim ();
>
> else <
die( «This is not a bird. I cannot describe it.» );
>
>

Топ-пост этого месяца:  Обзор HMTL5 элемента time

// describe these birds please
describe (new Penguin );
echo «—\n» ;

describe (new Dove );
echo «—\n» ;

describe (new Duck );

The class implementing the interface must use the exact same method signatures as are defined in the interface. Not doing so will result in a fatal error. — this documentation page.

But, if you use default values in arguments in methods, fatal error is not follow:

interface myInterface <
public function __construct ();
>

class concret implements myInterface <

public function __construct ( $arg = null )
<
print_r ( func_get_args ());
>
>

$obj = new concret ( 123 );
?>

Array ( [0] => 123 )

if you want to implement an interface and in addition to use inheritance, first it uses “extends” and then “implements” example:

class MyChildClass extends MyParentClass implements MyInterface
<
// definition
>
?>

When should you use interfaces? What are they good for?
Here are two examples.

1. Interfaces are an excellent way to implement reusability.
You can create a general interface for a number of situations
(such as a save to/load from disk interface.) You can then
implement the interface in a variety of different ways (e.g. for
formats such as tab delimited ASCII, XML and a database.)
You can write code that asks the object to «save itself to
disk» without having to worry what that means for the object
in question. One object might save itself to the database,
another to an XML and you can change this behavior over
time without having to rewrite the calling code.

This allows you to write reusable calling code that can work
for any number of different objects — you don’t need to know
what kind of object it is, as long as it obeys the common
interface.

2. Interfaces can also promote gradual evolution. On a
recent project I had some very complicated work to do and I
didn’t know how to implement it. I could think of a «basic»
implementation but I knew I would have to change it later.
So I created interfaces in each of these cases, and created
at least one «basic» implementation of the interface that
was «good enough for now» even though I knew it would have
to change later.

When I came back to make the changes, I was able to create
some new implementations of these interfaces that added the
extra features I needed. Some of my classes still used
the «basic» implementations, but others needed the
specialized ones. I was able to add the new features to the
objects themselves without rewriting the calling code in most
cases. It was easy to evolve my code in this way because
the changes were mostly isolated — they didn’t spread all
over the place like you might expect.

If it’s not already obvious, it’s worth noticing that the parameters in the interface’s method declaration do not have to have the same names as those in any of its implementations.

More significantly, default argument values may be supplied for interface method parameters, and they have to be if you want to use default argument values in the implemented classes:

interface isStuffable
<
public function getStuffed ( $ratio = 0.5 );
>

class Turkey implements isStuffable
<
public function getStuffed ( $stuffing = 1 )
<
// .
>
>
?>

Note that not only do the parameters have different names ($ratio and $stuffing), but their default values are free to be different as well. There doesn’t seem to be any purpose to the interface’s default argument value except as a dummy placeholder to show that there is a default (a class implementing isStuffable will not be able to implement methods with the signatures getStuffed(), getStuffed($a), or getStuffed($a,$b)).

On an incidental note, it is not necessary for the implementation of an interface method to use the same variable names for its parameters that were used in the interface declaration.

More significantly, your interface method declarations can include default argument values. If you do, you must specify their implementations with default arguments, too. Just like the parameter names, the default argument values do not need to be the same. In fact, there doesn’t seem to be any functionality to the one in the interface declaration at all beyond the fact that it is there.

interface isStuffed <
public function getStuff ( $something = 17 );
>

class oof implements isStuffed <
public function getStuff ( $a = 42 ) <
return $a ;
>
>

echo $oof -> getStuff ();
?>

Implementations that try to declare the method as getStuff(), getStuff($a), or getStuff($a,$b) will all trigger a fatal error.

You can also specify class constants in interfaces as well (similar to specifying ‘public static final’ fields in Java interfaces):

const SOME_CONSTANT = ‘I am an interface constant’ ;

public function doStuff ();

?>

Then you can access the constant by referring to the interface name, or an implementing class, (again similar to Java) e.g.:

class Baz implements FooBar
<

print Baz :: SOME_CONSTANT ;
print FooBar :: SOME_CONSTANT ;

?>

Both of the last print statements will output the same thing: the value of FooBar::SOME_CONSTANT

Implementation must be strict, subtypes are not allowed.

«The class implementing the interface must use the EXACT SAME METHOD SIGNATURES as are defined in the interface. Not doing so will result in a fatal error. «

interface I
<
function foo ( stdClass $arg );
>

class Test extends stdClass
<
>

class Implementation implements I
<
function foo ( Test $arg )
<
>
>
?>
Result:

Fatal error: Declaration of InterfaceImplementation::foo() must be compatible with I::foo(stdClass $arg) in test.php on line XY

While a subclass may implement an interface by extending an abstract class that implements the interface, I question whether it is good design to to do so. Here’s what I would suggest while taking the liberty of modifying the above weather/wet model:

interface water
<
public function makeItWet ();
>

/**
* abstract class implements water but defines makeItWet
* in the most general way to allow child class to
* provide specificity
**/
abstract class weather implements water
<
private $cloudy ;
public function makeItWet ()<>
abstract public function start ();
abstract public function getCloudy ();
abstract public function setCloudy ();
>

class rain extends weather <
private $cloudy ;
public function start () <
return «Here’s some weather. » ;
>

public function makeItWet () <
return ‘it is raining cats and dogs today.’ ;
>
public function getCloudy () <
return $this -> cloudy ;
>
public function setCloudy ( $bln = false ) <
$this -> cloudy = $bln ;
>
>

$a = new rain ();
echo $a -> start ();
$a -> setCloudy ( true );
if ( $a -> getCloudy ()) <
echo ‘It is a cloudy day and ‘ ;
>
echo $a -> makeItWet ();

PHP prevents interface a contant to be overridden by a class/interface that DIRECTLY inherits it. However, further inheritance allows it. That means that interface constants are not final as mentioned in a previous comment. Is this a bug or a feature?

interface a
<
const b = ‘Interface constant’ ;
>

// Prints: Interface constant
echo a :: b ;

class b implements a
<
>

// This works.
class c extends b
<
const b = ‘Class constant’ ;
>

Note that you can extend interfaces with other interfaces since under-the-hood they are just abstract classes:

interface Foo <
public function doFoo ();
>

interface Bar extends Foo <
public function doBar ();
>

class Zip implements Bar <
public function doFoo () <
echo «Foo» ;
>
public function doBar () <
echo «Bar» ;
>
>

$zip = new Zip ();
$zip -> doFoo ();
$zip -> doBar ();

?>

This is quite useful when you’re using interfaces for identity more than the rigidity it places upon an API. You can get the same result by implementing multiple interfaces.

An example of where I’ve used this in the past is with EventListener objects ala Java’s Swing UI. Some listeners are effectively the same thing but happen at different times therefore we can keep the same API but change the naming for clarity.

In response to harryjry and mehea concerning your Weather Model. The problem is that you don’t need all the things you think you need. In OOP, good class definitions get to the point rather quickly.

class Weather <
public $time , $temperature , $humidity ;

public function __construct ( $tm , $t , $h ) <
$this -> time = $tm ;
$this -> temperature = $t ;
$this -> humidity = $h ;
>

public function __toString () <
return «Time: $this -> time ,
Temperature: $this -> temperature °,
Humidity: $this -> humidity %» ;
>
>

$forecasts = array(
new Weather ( «1:00 pm» , 65 , 42 ),
new Weather ( «2:00 pm» , 66 , 40 ),
new Weather ( «3:00 pm» , 68 , 39 )
// add more weather reports as desired.
);
echo «Forecast for Chicago, IL:
» ;
foreach( $forecasts as $forecast ) echo ‘ — ‘ . $forecast ‘
‘ ;
?>
Forecast for Chicago, IL:
— Time: 1:00 pm, Temperature: 65°, Humidity: 42%
— Time: 2:00 pm, Temperature: 66°, Humidity: 40%
— Time: 3:00 pm, Temperature: 68°, Humidity: 39%

Note: MySQL can store data like this already, but if you included constants, more variables, and other functions in the Weather class, then maybe, just maybe it could be of use.

Solution for overriding interface constants
//we can override interface constants by using abstract class
//if Test Class implements inter1 than we can not override inter1 interface constants
example:

const interface1 = «I am from interface 1» ;

interface inter2 extends inter1 <

abstract class AbsClass implements inter2 <

class Test extends AbsClass implements inter3 , inter4 <

const interface1 = «I am from test class» ;


public function foo1 () <

public function foo2 () <

public function foo3 () <

public function foo4 () <

public function bar1 () <

public function bar2 () <

public function bar3 () <

public function bar4 () <

public function display () <
echo inter1 :: interface1 ;
echo PHP_EOL ;
echo Test :: interface1 ;
>

$Obj = new Test ();
$Obj -> display (); //I am from interface 1 \n I am from test class

The statement, that you have to implement _all_ methods of an interface has not to be taken that seriously, at least if you declare an abstract class and want to force the inheriting subclasses to implement the interface.
Just leave out all methods that should be implemented by the subclasses. But never write something like this:

abstract class FooBar implements Foo <

abstract function bar (); // just for making clear, that this
// method has to be implemented

?>

This will end up with the following error-message:

Fatal error: Can’t inherit abstract function Foo::bar() (previously declared abstract in FooBar) in path/to/file on line anylinenumber

Interfaces can define static methods, but note that this won’t make sense as you’ll be using the class name and not polymorphism.

. Unless you have PHP 5.3 which supports late static binding:

interface IDoSomething <
public static function doSomething ();
>

class One implements IDoSomething <
public static function doSomething () <
echo «One is doing something\n» ;
>
>

class Two extends One <
public static function doSomething () <
echo «Two is doing something\n» ;
>
>

function example ( IDoSomething $doer ) <
$doer :: doSomething (); // «unexpected ::» in PHP 5.2
>

example (new One ()); // One is doing something
example (new Two ()); // Two is doing something

?>

If you have PHP 5.2 you can still declare static methods in interfaces. While you won’t be able to call them via LSB, the «implements IDoSomething» can serve as a hint/reminder to other developers by saying «this class has a ::doSomething() method».
Besides, you’ll be upgrading to 5.3 soon, right? Right?

(Heh. I just realized: «I do something». Unintentional, I swear!)

I was wondering if implementing interfaces will take into account inheritance. That is, can inherited methods be used to follow an interface’s structure?

interface Auxiliary_Platform <
public function Weapon ();
public function Health ();
public function Shields ();
>

class T805 implements Auxiliary_Platform <
public function Weapon () <
var_dump ( __CLASS__ );
>
public function Health () <
var_dump ( __CLASS__ . «::» . __FUNCTION__ );
>
public function Shields () <
var_dump ( __CLASS__ . «->» . __FUNCTION__ );
>
>

class T806 extends T805 implements Auxiliary_Platform <
public function Weapon () <
var_dump ( __CLASS__ );
>
public function Shields () <
var_dump ( __CLASS__ . «->» . __FUNCTION__ );
>
>

$T805 = new T805 ();
$T805 -> Weapon ();
$T805 -> Health ();
$T805 -> Shields ();

$T806 = new T806 ();
$T806 -> Weapon ();
$T806 -> Health ();
$T806 -> Shields ();

/* Output:
string(4) «T805»
string(12) «T805::Health»
string(13) «T805->Shields»
string(4) «T806»
string(12) «T805::Health»
string(13) «T806->Shields»
*/

?>

Class T805 implements the interface Auxiliary_Platform. T806 does the same thing, but the method Health() is inherited from T805 (not the exact case, but you get the idea). PHP seems to be fine with this and everything still works fine. Do note that the rules for class inheritance doesn’t change in this scenario.

If the code were to be the same, but instead T805 (or T806) DOES NOT implement Auxiliary_Platform, then it’ll still work. Since T805 already follows the interface, everything that inherits T805 will also be valid. I would be careful about that. Personally, I don’t consider this a bug.

This seems to work in PHP5.2.9-2, PHP5.3 and PHP5.3.1 (my current versions).

We could also do the opposite:

class T805 <
public function Weapon () <
var_dump ( __CLASS__ );
>
>

class T806 extends T805 implements Auxiliary_Platform <
public function Health () <
var_dump ( __CLASS__ . «::» . __FUNCTION__ );
>
public function Shields () <
var_dump ( __CLASS__ . «->» . __FUNCTION__ );
>
>

$T805 = new T805 ();
$T805 -> Weapon ();

$T806 = new T806 ();
$T806 -> Weapon ();
$T806 -> Health ();
$T806 -> Shields ();

/* Output:
string(4) «T805»
string(4) «T805»
string(12) «T806::Health»
string(13) «T806->Shields»
*/

?>

This works as well, but the output is different. I’d be careful with this.

Объектно-ориентированное программирование для начинающих

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

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

Объектно-ориентированное программирование — это стиль кодирования, который позволяет разработчику группировать схожие задачи в классы. Таким образом код соответствует принципу DRY (don’t repeat yourself – не повторяй самого себя) и становится лёгким для сопровождения.

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

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

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

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

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

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

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

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

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

Структура класса

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

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

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

Можно протестировать весь процесс, скопировав весь код в файл test.php :

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

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

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

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

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

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

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

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

Модифицируйте скрипт в test.php, чтобы прочитать значение свойства, а не выводить информацию обо всем классе:

Обновите страницу в вашем браузере, чтобы увидеть результат работы скрипта:

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

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

Топ-пост этого месяца:  Новый алгоритм ранжирования постов ВКонтакте

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

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

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

Обновляем страницу в браузере и видим следующее:

Преимущества ООП проявляются при использовании множества объектов одного класса.

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

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

Магические методы в ООП

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

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

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

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

Примечание — константа __CLASS__ возвращает имя класса, в котором она вызывается; это одна из магических констант PHP.

Обновляем страницу в браузере и получаем результат:

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

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

Обновляем страницу в браузере и получаем результат:

При достижении конца файла PHP автоматически освобождает все ресурсы.

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

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

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

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

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

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

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

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

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

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

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

После загрузки скрипта в браузер получим результат:

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

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

Изменения приведут к следующему выводу при выполнении кода:

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

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

Выше приведённый код при выполнении выведет на экран сообщения из обеих конструкторов нового и родительского класса:

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

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

Примечание — Область видимости — это новое свойство, которое было введено в PHP 5. чтобы узнать о совместимости ООП с PHP 4, смотрите руководство по использованию PHP.

Свойства и методы public (Общие)

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

Методы и свойства protected (Защищённые)

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

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

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

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

При выполнении скрипта результат будет таким:

Методы и свойства private (Частные)

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

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

сохраняем скрипт, обновляем страницу в браузере и получаем следующее:

Методы и свойства Static (статические)

Методы и свойства, объявленные с директивой static могут быть доступны без инициации класса. Вы просто используете имя класса, оператор разрешения видимости и имя свойства или метода.

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

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

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

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

Комментирование с помощью DocBlock

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

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

Действительная мощность DocBlocks открывается при использовании тегов, которые начинаются с символа (@) за которым без пробелов следует имя тега и значение. Теги DocBlock позволяют разработчику определять автора файла, лицензию на использование класса, информацию о свойствах и методах, а также много другой полезной информации о коде.

Наиболее популярные теги:

@author: автор текущего элемента (который может быть классом, файлом, методом, или частью кода). В одном DocBlock могут быть указаны несколько авторов. Формат имени автора: Джони Doe .

@copyright: Тег указывает год и владельца копирайта на текущий элемент. Формат: 2010 Владелец копирайта.

@license: Ссылка на тип лицензии текущего элемента. Формат:
http://www.example.com/path/to/license.txt Название лицензии.

@var: Содержит тип и описание переменной или метода класса. Формат: тип элемент описание.

@param: Содержит тип и описание параметров функции или метода. Формат: тип $элемент описание элемента.

@return: Тип и описание возвращаемого значения для функции или метода. Формат: тип возвращаемое_значение описание.

Простой класс с комментариями в стиле DocBlocks может выглядеть так::

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

Сравнение объектно-ориентированного и процедурного программирования

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

Аргумент 1: простота применения

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

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

Процедурный подход

Ниже приводится процедурный подход для нашего примера:

«; echo «»; // Томми получил повышение и у него день рождения $person1 = changeJob($person1, ‘Главный двигатель коробочек’); $person1 = happyBirthday($person1); // У Джони только день рождения (повысят в другой раз) $person2 = happyBirthday($person2); // Выводим новый значения информации о людях echo «»; echo «»; ?>

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

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

Желательно, чтобы для разработчика оставалось как можно меньше мест для ошибок. Только действительно нужная информация для конкретной операции должна передаваться в функции.

Подход ООП

Вот подход ООП для решения нашего примера:

«; echo «»; // Даем Томми повышение и устанавливаем день рождения $person1->changeJob(«Главный двигатель коробочек»); $person1->happyBirthday(); // Джони будет праздновать только день рождения $person2->happyBirthday(); // Выводим окончательную информацию о людях echo «»; echo «»; ?>

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

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

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

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

Аргумент 2: лучшая организация


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

Предположим у вас есть приложение со 150 классами, которые получают имена динамически с помощью контрольного файла в корне вашего приложения. Все 150 классов используют унификацию имён в соответствии с форматом class.classname.inc.php и хранятся в папке inc в вашем приложении.

Контроллер может использовать PHP функцию __autoload() для динамического присоединения только тех классов, которые нужны, а не включать все 150 просто на всякий случай:

Использование для хранения каждого класса своего собственного файла делает код более мобильным и простым для многократного использования без дублирования.

Аргумент 3: легче обеспечивать поддержку

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

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

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

Резюме

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

Данный урок подготовлен для вас командой сайта ruseller.com
Источник урока: net.tutsplus.com/tutorials/php/object-oriented-php-for-beginners/
Перевел: Сергей Фастунов
Урок создан: 23 Июля 2010
Просмотров: 211271
Правила перепечатки

5 последних уроков рубрики «PHP»

Фильтрация данных с помощью zend-filter

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

Контекстное экранирование с помощью zend-escaper

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

Подключение Zend модулей к Expressive

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

Совет: отправка информации в Google Analytics через API

Предположим, что вам необходимо отправить какую-то информацию в Google Analytics из серверного скрипта. Как это сделать. Ответ в этой заметке.

Подборка PHP песочниц

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

ООП с примерами (часть 1)

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

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

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

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

Класс

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

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

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

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

С точки зрения структуры программы, класс является сложным типом данных.

В нашем случае, класс будет отображать сущность – автомобиль. Атрибутами класса будут являться двигатель, подвеска, кузов, четыре колеса и т.д. Методами класса будет «открыть дверь», «нажать на педаль газа», а также «закачать порцию бензина из бензобака в двигатель». Первые два метода доступны для выполнения другим классам (в частности, классу «Водитель»). Последний описывает взаимодействия внутри класса и не доступен пользователю.

В дальнейшем, несмотря на то, что слово «пользователь» ассоциируется с пасьянсом «Косынка» и «Microsoft Word», мы будем называть пользователями тех программистов, которые используют ваш класс, включая вас самих. Человека, который является автором класса, мы будем называть разработчиком.

Объект

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

Объект (экземпляр) – это отдельный представитель класса, имеющий конкретное состояние и поведение, полностью определяемое классом.

Говоря простым языком, объект имеет конкретные значения атрибутов и методы, работающие с этими значениями на основе правил, заданных в классе. В данном примере, если класс – это некоторый абстрактный автомобиль из «мира идей», то объект – это конкретный автомобиль, стоящий у вас под окнами.

Интерфейс

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

Интерфейс – это набор методов класса, доступных для использования другими классами.

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

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

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

Please verify you are a human

Access to this page has been denied because we believe you are using automation tools to browse the website.

This may happen as a result of the following:

  • Javascript is disabled or blocked by an extension (ad blockers for example)
  • Your browser does not support cookies

Please make sure that Javascript and cookies are enabled on your browser and that you are not blocking them from loading.

Топ-пост этого месяца:  Как вложить хлебные крошки yoast_breadcrumb в HTML тег

Reference ID: #a1771c40-0292-11ea-b739-d3b5bf626c33

Руководство по ООП на PHP

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Класс

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

Объект

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

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

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

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

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

Конструктор

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

Деструктор

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

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

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

Суперкласс

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

Подкласс

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

Полиморфизм

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

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

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

Абстракция

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

Перезагрузка

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Данная публикация представляет собой перевод статьи « PHP OOP Tutorial » , подготовленной дружной командой проекта Интернет-технологии.ру

Урок 11. Курс по ООП PHP. Интерфейсы и контроль типа

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

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

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

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

Все это и многое другое вы узнаете из уроков предлагаемого курса по ООП в PHP.

Урок 0. Курс по объектно-ориентированному программированию (ООП PHP). Введение

Урок 1. Курс по ООП PHP. Класс и объект

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

Урок 2. Курс по ООП PHP. Свойства объекта

От автора: продолжаем изучение объектно-ориентированного программирования (ООП) в PHP. Мы уже знаем, что такое класс и что такое объект в объектном программировании. И в этом уроке мы познакомимся с полями класса, которые чаще всего называют свойствами. Свойства – это ни что иное, как переменная, объявленная в классе. О работе со свойствами мы и поговорим в уроке.

Урок 2. Курс по ООП PHP. Свойства объекта

От автора: продолжаем изучение объектно-ориентированного программирования (ООП) в PHP. Мы уже знаем, что такое класс и что такое объект в объектном программировании. И в этом уроке мы познакомимся с полями класса, которые чаще всего называют свойствами. Свойства – это ни что иное, как переменная, объявленная в классе. О работе со свойствами мы и поговорим в уроке.

Урок 3. Курс по ООП PHP. Методы объекта

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

Урок 4. Курс по ООП PHP. Методы __construct и __destruct

От автора: продолжаем изучение объектно-ориентированного программирования (ООП) в PHP. В предыдущем уроке мы с вами познакомились с методами объектов, научились создавать и вызывать их. В этом уроке мы познакомимся с уже готовыми методами, которые предлагает нам PHP, — это методы __construct и __destruct. Данные методы относятся к категории магических, поскольку их не нужно вызывать, они сами вызываются при наступлении того или иного события.

Урок 5. Курс по ООП PHP. Домашнее задание. Класс для работы с файлом

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

Урок 6. Курс по ООП PHP. Константы класса. Статические свойства и методы

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

Урок 7. Курс по ООП PHP. Наследование. Часть 1

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

Урок 8. Курс по ООП PHP. Наследование. Часть 2

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

Урок 9. Курс по ООП PHP. Модификаторы доступа

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

Урок 10. Курс по ООП PHP. Абстрактные классы и интерфейсы

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

Урок 11. Курс по ООП PHP. Интерфейсы и контроль типа

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

Урок 12. Курс по ООП PHP. Автозагрузка и пространства имен

От автора: Продолжаем изучение объектно-ориентированного программирования (ООП) в PHP. В этом уроке мы рассмотрим такие полезные темы, как автозагрузка классов и пространства имен (namespace). Пока что мы учимся и классов у нас не так много, поэтому подключить каждый из них – не сложно. Однако, в реальных проектах у вас могут быть сотни классов, каждый из которых находится в своем файле. Соответственно, мы просто утонем во множестве инструкций require и include. Автоматизировать этот процесс поможет автозагрузка классов и пространства имен, с которыми мы и познакомимся в уроке.

Урок 13. Курс по ООП PHP. Composer и автозагрузка

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

Урок 14. Курс по ООП PHP. Трейты

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

Урок 15. Курс по ООП PHP. Позднее статическое связывание

От автора: продолжаем изучение объектно-ориентированного программирования (ООП) в PHP. В этом уроке мы рассмотрим одну из особенностей, которая появилась в PHP 5.3 – позднее статическое связывание. Что это такое и где может быть полезно – вы узнаете из предлагаемого урока.

Урок 16. Курс по ООП PHP. Магические методы

От автора: продолжаем изучение объектно-ориентированного программирования (ООП) в PHP. Как вы уже знаете, PHP предлагает ряд магических методов, с двумя из которых вы уже знакомы (__construct и __destruct). Данные методы вызываются при наступлении некоторых событий и без нашего участия. В этом уроке мы познакомимся с еще несколькими магическими методами, в частности с методами __set, __get и __toString.

Урок 17. Курс по ООП PHP. Шаблоны проектирования

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

[WebForMySelf] Курс по объектно-ориентированному программированию (ООП PHP)

Модератор

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

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

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

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

И, наконец, узнаете, как использовать при разработке веб-приложений шаблоны проектирования. Будете уметь работать только с одним объектом класса, используя шаблон Singleton. Сможете создавать объекты классов в процессе работы и реализовывать выбор стратегии для Вашего скрипта. А главное, научитесь создавать приложения по шаблону Модель-Вид-Контроллер (MVC).

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

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