Объектно-ориентированное программирование до сих пор
является относительно новой технологией в мире веб-разработок,
и по существу, некоторые концепции в значительной степени неправильно
понимаются многими квалифицированными веб-разработчиками. Наилучшим
образом это может проиллюстрировать недавняя шумиха, поднятая
в Javascript object literal.
От меня, как старшего веб-разработчика в Rentokil Initial, требуется
быть ведущим программистом в команде. Это также означает, что я должен
удостовериться в том, что технология понимается и безошибочно
используется. Помня об этом, недавно я заметил, что многие из членов
группы разработчиков явно не понимают базовых понятий ООП. По этой
причине, я подготовил это небольшое учебное пособие по данному вопросу —
за ним последуют более детальное рассмотрение работы на Javascript
и PHP.
Что такое объектно-ориентированное программирование?
Объектно-ориентированное программирование может быть описано как
парадигма программирования; методология программирования, перенимаемая
программистом. Ещё одним примером парадигмы программирования будет
процедурное (или иногда называемое императивным) программирование.
Процедурное программирование включает просмотр компьютерной программы
в виде последовательного списка вычислительных этапов (или процедур),
подлежащих выполнению. В процедурном программировании, список процедур
может в дальнейшем быть разбит на подпрограммы и функции (не путать
с математическими функциями, используемые в функциональном
программировании).
Это больше традиционный подход к программированию и он принят многими
высокоуровневыми языками, например, BASIC. Также стоит заметить, что
большинство базирующихся на Интернет-технологиях языков, таких как PHP,
ASP и Javascript, могут быть написаны с использованием этого подхода —
кстати, когда я только начинал как веб-разработчик, я использовал ASP
скрипт, PHP и Javascript именно таким образом, пребывая в блаженном
счастливом неведении о скрытом потенциале ООП.
В ООП, программа рассматривается как содержащая набор отдельных
модулей, или объектов, которые влияют друг на друга. Каждый из этих
объектов может рассматриваться как по своей сути независимая программа,
с определенной ролью или ответственностью.
ООП обеспечивает большую гибкость и более легкое сопровождение через
большие системы и иногда может значительно облегчить постижение и анализ
сложных процессов.
Здесь следует заметить, что большинство языков ООП (такие как C++ или
Java) хранят состояние (state), в то время как языки процедурного
программирования часто не имеют состояние.
Противник состояния
В компьютерной науке, «состояние» — это определенный набор команд,
которые будут выполняться в ответ на вводимые компьютером данные.
Информационная система или протокол, зависящий от состояния, считается
хранящим состояние. Тот, который от него не зависит, считается
не имеющим состояния.
ООП PHP не имеет состояния, потому что каждый скрипт должен
вызываться при обновлении страницы, в то время как Javascript хранит
состояние, поскольку он может использовать приемники событий —
специфические входные данные (чудеса XMLHttpRequest) таким образом,
отрицая необходимость обновлений.
Уф. Все это было действительно сложно, не так ли? Ладно, идем дальше…
Объекты и классы
Термин «объект», дающий название ООП, относится к понятийному
объекту, который означает единицу в нашей программе или системе. Это
может быть что угодно, начиная от экранной формы или компьютерного
файла, и заканчивая объектом реального мира, например, машина.
Это представление состоит из атрибутов — характеристики нашего
объекта; и методов — набор функций и вычислений, которые или выполняются
для изменения самого объекта, или содержаться в каком-либо внешнем
воздействии.
Термин «класс» означает определение (или классификацию — класс)
нашего объекта. Например, если бы нам нужно было написать класс под
названием «автомобиль», можно было создать любое количество экземпляров
этого класса — например, «Porsche», «Ferrari» и «Jaguar». Каждый из этих
экземпляров является объектом. Это иллюстрирует, что практически класс
это множество объектов, все из которых имеют общие атрибуты.
Удержание «в семействе»
Одним из наибольших преимуществ для использования объектов является
инкапсуляция. По существу, это означает, что данные в пределах объекта
доступны/поддаются изменению только через методы объекта, общеизвестные
как интерфейс объекта.
Это являющееся следствием ограничение дает объектно-ориентированному
программисту свободу описания атрибутов, переменных и методов,
не волнуясь о конфликтах с ними в других объектах.
Инкапсуляция также означает, что до тех пор, пока мы не внесем
изменение в интерфейс, мы можем изменять то, как действует объект
(увеличить производительность, добавить выполняемые функции) без влияния
на остальную часть системы.
А теперь давайте посмотрим, как объекты и классы соотносятся друг
с другом.
Примечание: С этого момента, понятия станут немного сложнее.
Пожалуйста, помните, что сейчас я пишу введение — я собираюсь подробнее
возвратиться к этим понятиям снова (с примерами), пока применяя
их к Javascript и PHP в следующих учебных пособиях.
Характеристики класса
В процессе записи класса существует ряд характеристик, которые стоит принять во внимание.
Конструктор
Конструктор — это особая операция, которая запускается при процессе
создания экземпляра объекта заданного класса, при создании объекта.
Их часто различают по имени, такому же, как и имя самого класса. Его
главная задача состоит в том, чтобы настроить атрибуты класса
и установить правило, устанавливающее взаимосвязи свойств объекта
класса — в основном, убедиться, что атрибуты класса соответствуют
интерфейсу класса. Он не может иметь тип возвращаемого значения.
Правильно написанный конструктор никогда не будет включать в себя
функциональные средства, которые могут дать сбой, таким образом, объект
становится недействительным.
Деструктор
Деструктор класса — это противоположный конструктору метод, который
запускается при уничтожении объекта. Его функция состоит в том, чтобы
очищать и освобождать ресурсы, которые использовались объектом во время
исполнения и разъединить их от других объектов или ресурсов. Результатом
будет недействительность любых ссылок в процессе.
Отношения
Существует ряд отношений, которые могут быть использованы тогда,
когда необходимо взаимодействие между объектами. Они описаны далее.
Наследование
Наследование дает возможность классу (подклассу) наследовать все
атрибуты и методы родительского класса, в сущности, расширяя его.
Наилучшим образом его можно описать как взаимосвязь «is a» (это есть).
К примеру, если бы у нас был класс «fruit» (фрукты), мы могли бы его
расширить посредством определения классов «apple» (яблоко), «orange»
(апельсин) и «banana» (банан). Каждый из этих подклассов может быть
описан следующим образом:
- apple «is a» fruit
- orange «is a» fruit
- banana «is a» fruit
Поскольку каждый из наших подклассов расширяет класс «fruit»,
он имеет все атрибуты и методы класса «fruit» плюс любые присущие ему
особые свойства.
Вот более ориентированный на веб-разработку пример, который использует элементы формы и представленный в псевдокоде:
class formElement
{
Attributes:
id
name
class
}
class input extends formElement
{
Attributes:
value
type
}
class textarea extends formElement
{
Attributes:
cols
rows
}
В этом примере 2 класса «input» и «textarea» наследуют «formElement».
Это означает, что они наследуют следующие атрибуты formElement:
input is a formElement
input
{
Attributes:
id
name
class
value
type
}
textarea is a formElement
textarea
{
Attributes:
id
name
class
cols
rows
}
Однако, будучи (супер) классом, formElement остается точно таким же:
formElement
{
Attributes:
id
name
class
}
Как вы можете себе представить, эта взаимосвязь может быть
чрезвычайно полезной. Некоторые языки даже позволяют множественное
наследование, где класс может иметь больше, чем один родительский
(супер) класс. К сожалению, это не тот случай ни для Javascript, ни для
PHP, тем не менее, возможно достичь того же эффекта, используя другие
типы отношений.
Композиция — ассоциация и аггрегация.
Композиция — это немного другой вид отношений, здесь можно сказать,
что класс «составлен» из других классов. Например, стена «состоит»
из кирпичей и молекула «состоит» из атомов. Ни один их данных примеров
не может быть описан как наследование, т.к. утверждение «стена это
кирпич» просто не является истиной. Композицию можно описать отношениями
«has a» (имеет) и «uses a» (использует); стена «has a» кирпич или стена
«uses a» кирпич.
Давайте посмотрим на отношение «has a» в псевдокоде. Давайте сначала определим несколько простых классов:
class brick
{
}
class wall
{
Attributes:
brick1
brick2
brick3
brick4
Methods:
// Constructor
wall()
{
this.brick1 = new brick();
this.brick2 = new brick();
this.brick3 = new brick();
this.brick4 = new brick();
}
}
Вы можете увидеть, что «стена» содержит сумму атрибутов кирпичей.
Мы хотим, чтобы каждый из этих атрибутов был объектом «brick». Чтобы
сделать это, мы просто подвергаем их обработке внутри конструктора
класса «wall». Каждый из этих классов кирпичей будет функционировать как
обычный класс, но также как и атрибут класса «wall». Это известно как
ассоциация.
Теперь давайте рассмотрим отношение «uses a»:
class person
{
}
class car
{
Attributes:
driver
Methods:
// Constructor
car(driver)
{
this.driver = driver;
}
}
В этом примере мы можем увидеть, что класс «person» подвергся
обработке в объекте «me». Потом этот объект перешел в реализацию класса
«car». Это значит, что объект «myMotor» (наша реализация класса «car»)
использует объект «me». Это отношение известно как аггрегация.
Исправление: Спасибо Нейту Логану за то, что заметил небольшую ошибку в последнем примере и сообщил мне по e-mail.
Основное различие между этими двумя отношениями простое; в ассоциации
образующие классы разрушаются, когда разрушается родительский класс;
однако, в агрегации это не так. В конечном счете, это означает, что
когда агрегация принимается как отношение, образующие классы и объекты
могут быть повторно использованы в других классах и объектах внутри
системы.
Полиморфизм
Язык объектно-ориентированного программирования должен поддерживать
полиморфизм; это означает, что разные классы могут иметь разные
поведения для одного и того же атрибута или метода. Наилучшим образом
это может проиллюстрировать пример:
class formElement
{
Attributes:
id
name
class
Methods:
getHtml()
{
// returns generic form element HTML
}
}
class textarea extends formElement
{
Attributes:
cols
rows
Methods:
getHtml()
{
// returns textarea form element HTML
}
}
Как можно увидеть из примера, метод «getHtml» имеется в обоих
классах, но класс «textarea» это подкласс класса «formElement».
Результатом этого является перегруженный метод «getHtml». Перегрузка —
это хороший пример полиморфизма в действии — объектно-ориентированный
язык должен поддерживать полиморфизм для того, чтобы знать, какой
из методов «getHtml» к какому объекту обращается.
Полиморфизм, по большому счету, описывает факт, что данная функция
может иметь разные спецификации в зависимости от объекта, которым она
вызывается.
Зачем использовать объектно-ориентированное программирование?
Объектная ориентация помогает сохранять простоту программ путем
разбивки на исполняемые куски программы. Эти куски могут быть
многократно использованы в других программах, так, в результате, экономя
время. По сути, перенимание объектно-ориентированного подхода может
стать фундаментом для действительно успешного командного режима работы;
посредством внедрения модульности объектно-ориентированная среда
предоставляет усовершенствованное повторное использование кода
и удобство сопровождения.
Но вы не просто возьмите на заметку мои слова; попробуйте сделать это
сами! Чтобы больше помочь вам в осуществлении этого, я собираюсь
продолжить этот вводный курс учебным пособием по его применению
в Javascript и PHP.
В завершение хочу сказать, что надеюсь на то, что из этого обзора вы почерпнули что-то новое для себя.
