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

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

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

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

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

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

Объектно-ориентированное программирование основано на:

• Инкапсуляции;
• Полиморфизме;
• Наследовании.

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

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

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

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

Полиморфизм

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

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

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

Инкапсуляция – это просто перенос некоторых данных в объект. Термин «инкапсуляция» часто используется взаимозаменяемо с «скрытием информации». В Википедии есть хорошая статья.

_user == null) { $this->_user = new User(); } return $this->_user; } } class User { private $_name; public function __construct() { $this->_name = "Joseph Crawford Jr."; } public function GetName() { return $this->_name; } } $app = new App(); echo $app->User()->GetName(); ?>

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

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

Например

Class OuterClass { private var $innerobject; function increment() { return $this->innerobject->increment(); } }

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

encapsulation: Инкапсуляция представляет собой концепцию обертывания или связывания связанных элементов данных и методов в одном модуле, известном как инкапсуляция.

вот правильный пример инкапсуляции

name = $n; $this -> age = $a; } public function setAge($ag) { $this -> ag = $ag; } public function display() { echo "welcome " . $this -> name . "
"; return $this -> age - $this -> ag; } } $person = new person("Pankaj", 25); $person -> setAge(10); echo "You are " . $person -> display() . " years old"; ?>

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

• могут быть переданы с одной ссылкой, например, increment (myDate), а не с увеличением (год, месяц, день)
• имеет набор применимых операций, хранящихся в одном программном модуле (класс, модуль, файл и т. д.),
• не позволяет клиенту видеть или манипулировать своими подкомпонентами ЗА ИСКЛЮЧЕНИЕМ, вызывая соответствующие операции

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

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

Доступ и настройка параметров класса

(Хороший способ)

gender; } public function setGender($gender) { if ("male" !== $gender and "female" !== $gender) { throw new \Exception("Set male or female for gender"); } $this->gender = $gender; } }

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

$user = new User(); $user->setGender("male"); // An exception will throw and you can not set "Y" to user gender $user->setGender("Y");

(Плохой способ)

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

gender = "male"; // No exception will throw and you can set "Y" to user gender however // eventually you will face some logical issue in your system that is // very hard to detect $user->gender = "Y";

Методы класса доступа

(Хороший способ)

doThis(...); ... $this->doThat(...); ... $this->doThisExtra(...); } private function doThis(...some Parameters...) { ... } private function doThat(...some Parameters...) { ... } private function doThisExtra(...some Parameters...) { ... } }

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

(Плохой способ)

Class User { public function doSomethingComplex() { // do everything here ... ... ... ... } }

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

Инкапсуляция – это процесс удаления данных объекта из внешнего мира и доступ к нему ограничивается членами класса.

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

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

0) $mark = 10; else $mark = 0; } } } ?>

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

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

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

Давайте рассмотрим пример реальной жизни для инкапсуляции.

Class MyClass{ private $name; public function showName($newName){ $this->name = $newName; return $this->name; } } //instantiate object $obj = new MyClass(); echo $obj->showName("tisuchi");

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

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

видимость вашей собственности и метода.

Хотя, если у вас есть желание понять инкапсуляцию, я ссылаюсь на свой специальный учебник, основанный на инкапсуляции.

Надеюсь, это сделает вашу концепцию более ясной. Повеселись!

В основном, это то, как мы определяем видимость наших свойств и методов. Когда вы создаете классы, вы должны спросить себя, какие свойства и методы можно получить за пределами класса. Допустим, у нас есть свойство foo. Если класс расширяет ваш класс, разрешено ли ему манипулировать и получать доступ к foo? Что делать, если кто-то создает экземпляры вашего класса? Разрешено ли им манипулировать и получать доступ к foo?

Инкапсуляция – это то, как вы хотели, чтобы ваши объекты / методы или свойства / переменные были видны в вашем приложении. например, :

Class ecap { public $name; private $id; protected $tax; }

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

в классе добавьте следующий метод:

Class ecap { public function userId(){ return $this->id; } }

и мы можем получить к нему доступ, как:

$obj = new ecap(); echo $obj->userId();

PHP, ООП, Инкапсуляция, Наследование, Полиморфизм

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

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

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

Иными словами при работе с грамотно спроектированным классом мы можем пользоваться только его методами, не вникая в то, как они устроены и как они работают с полями класса. Речь идет о ситуации, когда мы работаем с классом, разработанным другими программистами. Мы же просто пользуемся уже реализованным функционалом.

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

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

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

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

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

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

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

Это значит, что в классах Квадрат и Треугольник нам не придется повторно задавать поля цвета и площади. Достаточно указать, что упомянутые классы наследуются от класса Фигура.

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

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

Чтобы реализовать эту ситуацию в PHP, нам потребуется определить два класса: класс для обычной статьи-заметки и класс для новостной статьи. При этом пусть новостная статья расширяет возможности обычной статьи, т. е. наследуется от нее. Для наследования классов в PHP используется ключевое слово extends .

Class { ... // содержимое класса } class { ... // содержимое класса }

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

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

Иногда у нас может появиться необходимость переопределить один из методов родительского класса. Давайте еще раз приведем реализацию класса Article :

Class Article { ... // поля класса // Функция для вывода статьи function view() { echo "

$this->title

$this->content

"; } }

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

Class NewsArticle extends Article { $datetime; // дата публикации новости // Функция для вывода статьи function view() { echo "

$this->title

". strftime("%d.%m.%y", $this->datetime). " Новость

$this->content

"; } }

В приведенном коде используется функция strftime() , которая позволяет выводить даты в удобном виде. Для лучшего понимания кода ознакомьтесь со спецификацией этой функции в справочнике. Для нас же сейчас важно, чтобы вы обратили внимание на то, что класс NewsArticle , как и Article , определяет метод view() . Соответственно, все объекты этого класса будут использовать метод view() , объявленный в классе NewsArticle , а не в Article .

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

Полиморфизм

Полиморфизм - взаимозаменяемость объектов с одинаковым интерфейсом.

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

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

Class A { function Test() { echo "Это класс A
"; } function Call() { $this->Test(); } } class B extends A { function Test() { echo "Это класс B
"; } } $a = new A(); $b = new B(); $a->Call(); // выводит: "Это класс A" $b->Test(); // выводит: "Это класс B" $b->

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

$a->Call(); // выводит: "Это класс A"

В этой строке происходит вызов метода Call() у объекта класса А . Как и определено в функции Call() класса A , происходит вызов метода Test() . Отрабатывает метод Test() у объекта класса A , и на экран выводится текст "Это класс А ".

$b->Test(); // выводит: "Это класс B"

В данной строке происходит вызов метода Test() у объекта класса B . Метод Test() класса B выводит на экран текст "Это класс В ".

$b->Call(); // выводит: "Это класс B"

Наконец, в последней строке происходит вызов класса Call() у объекта класса В . Но в реализации класса B мы не увидим такого метода, а это значит, что он наследуется от класса A , т. к. класс B - это потомок класса A . Что же мы видим в реализации метода Call() класса A ? Следующий код:

$this->Test();

Метод Call() вызывает метод Test() того объекта, в котором находится. Это значит, что отработает метод Test() объекта класса B . Именно этим объясняется результат, выведенный на экране.

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

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

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

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

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

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

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

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

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

Инкапсуляция неразрывно связана с понятием интерфейса класса. По сути, всё то, что не входит в интерфейс, инкапсулируется в классе.

Абстракция

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

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

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

Полиморфизм

Любое обучение вождению не имело бы смысла, если бы человек, научившийся водить, скажем, ВАЗ 2106 не мог потом водить ВАЗ 2110 или BMW X3. С другой стороны, трудно представить человека, который смог бы нормально управлять автомобилем, в котором педаль газа находится левее педали тормоза, а вместо руля – джойстик.

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

Полиморфизм – это свойство системы использовать объекты с одинаковым интерфейсом без информации о типе и внутренней структуре объекта.

Например, если вы читаете данные из файла, то, очевидно, в классе, реализующем файловый поток, будет присутствовать метод похожий на следующий: byte readBytes(int n);
Предположим теперь, что вам необходимо считывать те же данные из сокета. В классе, реализующем сокет, также будет присутствовать метод readBytes . Достаточно заменить в вашей системе объект одного класса на объект другого класса, и результат будет достигнут.

При этом логика системы может быть реализована независимо от того, будут ли данные прочитаны из файла или получены по сети. Таким образом, мы абстрагируемся от конкретной специализации получения данных и работаем на уровне интерфейса. Единственное требование при этом – чтобы каждый используемый объект имел метод readBytes .

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

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

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

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

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

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

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

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

Если говорить научным языком, то Инкапсуляция - это сокрытие реализации того или иного класса. Собственно я сейчас не сказал ничего нового, и, порой так где это уже написано, на этом всё и заканчивается.

Какое сокрытие? Сокрытие чего? Что такое сокрытие? Ни чё не понятно!

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

Отличным примером Инкапсуляции является большинство модулей и библиотек. Например PHPExcel.

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

Ну это если прям по умному сказать.

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

Но тут же нам с вами нужно познакомиться с спецификаторами классов.

Такими как public, protected, private

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

Например:

class cl {
private $a = 1;
public function b() {
return $this->a;
}
}

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

protected доступен только внутри текущего класса и его наследников!

private по логике ясно. Доступно только в текущем классе.

Не смотря на то, что private юзается онли ин вис класс доступ к нему можно получить, но не желательно!

class cl {
private $a = 1;
public function get() {
return $this->a;
}
}
$class = new cl;
echo $class->get();

На экране появится "1" не смотря на то, что $a это private. Так же мы можем поменять её значение.

class cl {
private $a = 1;
public function get() {
return $this->a;
}
public function set($x) {
$this->a = $x;
}
}
$class = new cl;
$class->set(2);
echo $class->get();

После выпонения увидим "2".

Кстати, если просто написать function asd(){***} не указывая спецификаторы

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

Ставь ОГОНЬ. Подписывайся на