JavaScript Базовый. Занятие 04.

Темы лекции: ООП в JavaScript.
Тренер: Игорь Шкулипа, к.т.н.
JavaScript. Базовый курс
Занятие 4

http://www.slideshare.net/IgorShkulipa 2
ООП – это парадигма программирования, основанная на
представлении предметной области в виде взаимосвязанных абстрактных
объектов и их реализаций.
В ООП вводится понятие Класса – пользовательского типа
данных, объединяющего данные и методы их обработки.
Объектом называется экземпляр класса.
Объектно-ориентированное программирование

Члены-данные (поля) (data members) хранят всю необходимую
информацию об объекте, формируют его состояние, характеристики и
т.п.
Изменение состояния объекта или его характеристик связано с
изменением данных, которые в нем содержатся.
Метод объекта (methods) – программный код, выполненный в
виде функции, реагирующий на передачу объекту определенного
сообщения.
Вызов метода объекта может приводить к изменению его
состояния (значение членов-данных), а может и не приводить
Класс может содержать один или более методов, позволяющих
осуществлять манипуляцию данными объекта
Поля и методы класса

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

• Абстракция данных
• Инкапсуляция
• Наследование
• Полиморфизм
Принципы ООП

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

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

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

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

Доступ к данным и методам класса извне может быть ограничен
Рекомендуется запрещать доступ к данным класса в обход его
методов
Для разделения прав доступа к полям класса используются
модификаторы доступа
public
private
protected
Доступ к данным и методам класса

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

private-данные и методы класса определяют его реализацию
Доступ к ним разрешен только из методов данного класса
Рекомендуется все данные класса делать закрытыми, их
обработку осуществлять внутри методов.
Закрытые методы класса обычно используются публичными
методами, решая внутренние задачи класса.
Закрытые (private) поля и методы класса

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

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

• Нет классов, но можно их эмулировать.
• Есть наследование на прототипах - делегирующее прототипное
наследование
• Все можно менять во время работы
• Цепочку наследования можно менять
• Прототипы можно менять
• В классах так сделать нельзя
• Можно изменить прототипы базовых "классов“
• Любой объект имеет ссылку на прототип
• Делегирование
• Мы можем пользоваться функциями прототипа не имея
собственных
• Цепочка прототипов
• Каждый прототип - это тот же объект
• Который также может иметь прототип
• У прототипа прототипа также может быть прототип
Особенности ООП в JavaScript

Объекты JavaScript представляют собой наборы свойств и
методов. Можно сказать, что свойства объектов - это данные,
связанные с объектом, а методы - функции для обработки данных
объекта.
В общем случае, объект – это неупорядоченная коллекция пар
ключ-значение.
var o = {
firstName : ”Василий”,
lastName : ”Пупкин”,
age : 30,
};
Object

Пустой объект:
var o = new Object(); // то же, что и {}
Пустой массив:
var a = new Array(); // то же, что и []
Дата/время:
var d = new Date(); // текущее время
Создание объектов с помощью new

var o = {
name:"Ivan",
surname:"Ivanov"
};
alert(o.name);
o.surname = "Petrov";
alert(o.surname);
Доступ к свойствам

var o = {
name:"Ivan",
surname:"Ivanov"
};
alert(o["name"]);
o["surname"] = "Petrov";
alert(o["surname"]);
Объекты как ассоциативные массивы

var o = {
name:"Ivan",
surname:"Ivanov"
};
for (var prop in o){
alert(prop);
alert(o[prop]);
}
Объекты как ассоциативные массивы

var o = {
name:"Ivan",
surname:"Ivanov"
};
o.middle = "Ivanovich";
o.gender = "Male";
alert(o[prop]);
}
Добавление свойств

var o = {
name:"Ivan",
surname:"Ivanov"
};
o.gender = "Male";
delete o.gender;
delete o["middle"];
delete o["someprop1"];
delete o.someprop2;
alert(o[prop]);
}
Удаление свойств

this возвращает ссылку на объект, являющийся текущим
контекстом вызова. Это позволяет обращаться к свойствам "текущего"
объекта: this.property.
Текущий объект не является жестко фиксированным и зависит от
контекста вызова функции. Он является, своего рода, скрытым
параметром.
this

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

var o = {
name:"Ivan",
surname:"Ivanov"
};
var oproto = {
gender:"Male"
};
o.__proto__ = oproto;
alert(o[prop]);
}
__proto__

var oproto = {
gender:"Male"
};
var o = Object.create (oproto, {
name:{
value:"Ivan",
writable:true,
configurable:true,
enumerable:true
},
surname:{
value:"Ivanov",
writable:true,
configurable:true,
enumerable:true
}
})
alert(o[prop]);
}
Object.create()

Object.create(prototype, descriptors)
Дескрипторы свойств, присутствующие в объектах, бывают двух основных
типов: дескрипторы данных и дескрипторы доступа.
Дескриптор данных — это свойство, имеющее значение, которое может быть (а
может и не быть) записываемым.
Дескриптор доступа — это свойство, описываемое парой функций — геттером
и сеттером. Дескриптор может быть только чем-то одним из этих двух типов; он не
может быть одновременно обоими.
И дескриптор данных, и дескриптор доступа являются объектами. Они
обладают следующими обязательными ключами:
• configurable - равен true только в том случае, если тип этого дескриптора
свойства может быть изменён и если свойство может быть удалено из
содержащего его объекта. Значение по умолчанию установлено в false.
• enumerable - равен true только в том случае, если это свойство можно увидеть
через перечисление свойств содержащего его объекта. Значение по
умолчанию установлено в false.
Object.create()

Дескриптор данных также может содержать следующие дополнительные ключи:
• value - значение, ассоциированное со свойством. Может быть любым
допустимым значением JavaScript (числом, объектом, функцией и т.д.).
Значение по умолчанию установлено в undefined.
• writable - равен true только в том случае, если значение, ассоциированное
со свойством, может быть изменено с помощью оператора присваивания.
Значение по умолчанию установлено в false.
Дескриптор доступа также может содержать следующие дополнительные ключи:
• get - функция, используемая как геттер свойства, либо undefined, если
свойство не имеет геттера. Возвращаемое значение функции будет
использоваться как значение свойства. Значение по умолчанию установлено
в undefined.
• set - функция, используемая как сеттер свойства, либо undefined, если
свойство не имеет сеттера. Функция принимает единственным аргументом
новое значение, присваиваемое свойству. Значение по умолчанию
установлено в undefined.
Object.create()

...
Object.defineProperty(o,
"middle", {
enumerable: true,
configurable: true,
writable: true,
value: "Ivanovich"
});
alert(o[prop]);
}
Object.defineProperty

...
if (o.hasOwnProperty(prop))
alert(o[prop]);
}
obj.hasOwnProperty(prop)

Все объекты базовый набор методов, например метод toString,
которые находится, не в самом объекте, а в его прототипе obj.__proto__.
Объект Object.prototype — вершина иерархии, единственный, у
которого __proto__ равно null.
Поэтому говорят, что «все объекты наследуют от Object», а если
более точно, то от Object.prototype.
Object.prototype

Любая функция, кроме некоторых встроенных, может создать объект.
Для этого ее нужно вызвать через директиву new.
Такие функции еще называются конструкторами.
function FullName (name, surname, middle) {
this.name = name;
this.surname = surname;
this.middle = middle;
return this; // не обязательно
}
var fullName= new FullName (“Ivan“, “Ivanov”, “Ivanovich”);
Создание объектов с помощью функций

this.name = name;
this.alertme = function (){
alert(this.name);
}
return this; // не обязательно
}
var o1= new
FullName("Ivan", "Ivanov", "Ivanovich");
var o2= new
FullName("Petr", "Petrov", "Petrovich");
o1.alertme();
o2.alertme();
Конструкторы

this.name = name;
alert(this.name);
}
return {
name: "Sidor",
surname: "Sidorov",
middle: "Sidorovich",
alertme: function () {
alert(this.name);
}
};
}
var o1= new
var o2= new
o1.alertme();
o2.alertme();
Конструкторы

Чтобы новым объектам автоматически ставить прототип,
конструктору ставится свойство prototype.
При создании объекта через new, в его прототип __proto__
записывается ссылка из prototype функции-конструктора.
Как правило, свойство prototype используется для
предоставления базового набора функциональных возможностей классу
объектов. Новые экземпляры объекта "наследуют" поведение прототипа,
присвоенного этому объекту.
F.prototype

Результат

В prototype по умолчанию всегда находится свойство
constructor, указывающее на функцию-конструктор. Но, если мы
рассчитываем использовать это свойство, то при замене prototype через
Object.create нужно его явно сохранить.
obj.prototype = Object.create(null);
obj.prototype.constructor = Object;
JavaScript никак не использует свойство constructor. То есть,
оно создаётся автоматически, а что с ним происходит дальше — это уже
наша забота. В стандарте прописано только его создание.
В частности, при перезаписи obj.prototype = { } свойства
constructor больше не будет.
Свойство constructor

alert(surnname.constructor); // ???
alert(surnname.__proto__.constructor); // ???
alert(initials.constructor); // ???
alert(initials.__proto__.constructor); // ???
alert(surnname.hasOwnProperty("name")); // ???
alert(surnname.hasOwnProperty("surname")); // ???
alert(surnname.hasOwnProperty("toString")); // ???
alert(Object.prototype.isPrototypeOf(surnname)); // ???
Пример

alert(surnname.constructor);
alert(surnname.__proto__.constructor);
alert(initials.constructor);
alert(initials.__proto__.constructor);
alert(surnname.hasOwnProperty("name"));
alert(surnname.hasOwnProperty("surname"));
alert(surnname.hasOwnProperty("toString"));
alert(Object.prototype.isPrototypeOf(surnname));
Пример

Все, что добавляется в this является public
this.name = name;
alert(this.name);
}
return this;
}
var o1= new
var o2= new
o1.alertme();
o2.alertme();
public

Все, что объявляется внутри конструктора, включая его параметры, является
private
var fullName=name + " " + middle + " " + surname;
this.name = name;
alert(fullName);
}
return this;
}
var o1= new
var o2= new
o1.alertme();
o2.alertme();
private

protected - это, по сути, public, отмеченный «_» в начале
идентификатора. И мы «договариваемся» эти свойства не трогать.
var fullName=name + " " + middle + " " + surname;
this.name = name;
this._fullName = fullName;
alert(this._fullName);
}
return this;
}
var o1= new
var o2= Object.create(new
FullName("Petr", "Petrov", "Petrovich"));
o1.alertme();
alert(o2._fullName);
protected

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

JSON (JavaScript Object Notation) — текстовый формат обмена данными,
основанный на JavaScript.
JSON строится на двух структурах:
• Коллекция пар ключ/значение. В разных языках, эта концепция
реализована как объект, запись, структура, словарь, хэш, именованный
список или ассоциативный массив.
• Упорядоченный список значений. В большинстве языков это реализовано
как массив, вектор, список или последовательность.
В JSON используются их следующие формы:
• Объект — это неупорядоченное множество пар имя/значение,
заключённое в фигурные скобки { }. Между именем и значением стоит
символ ": ", а пары имя/значение разделяются запятыми.
• Массив (одномерный) — это множество значений, имеющих порядковые
номера (индексы). Массив заключается в квадратные скобки [ ]. Значения
отделяются запятыми.
• Значение может быть строкой в двойных кавычках, числом, значением
true или false, объектом, массивом, или значением null. Эти структуры
могут быть вложены друг в друга.
• Строка — это упорядоченное множество из нуля или более символов
юникода, заключенное в двойные кавычки, с использованием escape-
последовательностей начинающихся с обратной косой черты (backslash).
Символы представляются простой строкой.
• Имя — это строка.
JSON

Пример 1.
var fio= {surname:‘Пупкин',name:‘Василий',middle:‘Борисович'};
Пример 2. Wikipedia.
{
"firstName": "Иван",
"lastName": "Иванов",
"address": {
"streetAddress": "Московское ш., 101, кв.101",
"city": "Ленинград",
"postalCode": 101101
},
"phoneNumbers": [
"812 123-1234",
"916 123-4567"
]
}
Примеры JSON

var initialsString= JSON.stringify(initials);
var surnnameString= JSON.stringify(surnname);
alert(initialsString);
alert(surnnameString);
var ini= JSON.parse(initialsString);
var sur= JSON.parse(surnnameString);
alert(ini.name);
alert(sur.name);
Сериализация

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

• Выполняется код внутри блока try.
• Если в нём возникнет ошибка, то выполнение try прерывается, и
управление прыгает в начало блока catch.
try {
alert("Start try");
a;
alert("End of try");
} catch (error) {
alert("Error catched!");
}
Конструкция try-catch. С ошибкой

try {
alert("Start try");
var a;
} catch (error) {
alert("Error catched!");
}
Конструкция try-catch. Без ошибок

У блока catch есть аргумент, в примере выше он обозначен error.
Это — объект ошибки или, как ещё говорят, объект исключения (exception
object).
Он содержит информацию о том, что произошло, и может быть
разным, в зависимости от ошибки.
Как правило, error — объект встроенного типа Error и производных от
него.
Есть несколько свойств, которые присутствуют в объекте ошибки:
• name - тип ошибки. Например, при обращении к несуществующей
переменной равен "ReferenceError".
• message - текстовое сообщение о деталях ошибки.
• stack - везде, кроме IE<9, есть также свойство stack,
указывающее, где в точности произошла ошибка.
Объект ошибки

try {
alert("Start try");
a;
} catch (error) {
alert(error);
}

try {
alert("Start try");
var a = 1;
var b = a();
} catch (error) {
alert(error);
}

try {
alert("Start try");
var a = 1;
var b = a();
} catch (error) {
alert(error);
} finally {
alert("Finally");
}
Блок finally позволяет избежать дублирования
кода в try-catch.
Секция finally

Блок finally срабатывает при любом выходе из try-catch, в том числе и
return. Это гарантирует освобождение ресурсов в любом случае.
function f() {
try {
alert("Start try");
return 1;
} catch (error) {
alert(error);
} finally {
alert("Finally");
}
}
f();
finally и return

throw <объект ошибки>
Инициирует ошибку, которую можно
поймать в catch. Объектом ошибки
может быть что угодно, например
число.
try {
alert("Start try");
throw 1;
} catch (error) {
alert(error);
} finally {
alert("Finally");
}
Генерация ошибок

В случае вложенных вызовов — не важно, где было исключение,
оно будет поймано ближайшим внешним try-catch.
function f() {
while (true) {
throw 1;
}
}
try {
alert("Start try");
f();
} catch (error) {
alert(error);
} finally {
alert("Finally");
}
Всплывание ошибок

try {
try {
alert("Start try");
f();
alert("End try");
} catch (error) {
if (error instanceof String)
alert(error);
else throw error;
} finally {
alert("Finally");
}
} catch (err) {
alert(err + " external try");
}
Вложенные блоки try..catch

SOLID – это акроним названий пяти основных принципов
проектирования классов, сформулированных Робертом Мартином:
• Single responsibility (принцип одной ответственности),
• Open for extension and closed for modification (принцип
открытости/закрытости, или открытость для расширения и
закрытость для модификации),
• Liskov substitution (принцип подстановки Лисков),
• Interface segregation (принцип разделения интерфейса),
• Dependency inversion (принцип инверсии зависимостей).
SOLID. Принципы проектирования

Принцип единственной ответственности (Single Responsibility
Principle) часто определяют так: у объекта должна быть только одна
причина для изменения; чем больше файл или класс, тем труднее
достичь этой цели.
Этот принцип говорит о том, что по-хорошему каждый класс
должен решать только одну задачу. Это совсем не значит, что в классе
должен быть всего один метод. Это означает, что методы класса должны
быть связаны одной общей целью.
Single Responsibility

Single Responsibility
Плохой пример Неплохой пример
function Persone(name, surname, middle) {
this.name=name;
this.surname=surname;
this.middle=middle;
return this;
}
Persone.prototype.LoadFromDatabase =
function () {}
Persone.prototype.SaveToDatabase =
function () {}
Persone.prototype.PrintToPrinter =
function () {}
function Persone(name, surname, middle) {
this.name=name;
this.surname=surname;
this.middle=middle;
return this;
}
function PersoneDatabase() {
return this;
}
PersoneDatabase.prototype.LoadFromDatabase =
function () { return new Persone(...);}
PersoneDatabase.prototype.SaveToDatabase =
function (p) { }
function PersonePrinter() {
return this;
}
PersonePrinter.prototype.PrintToPrinter =
function (p) { }

Объекты проектирования (классы, функции, модули и т.д.)
должны быть открыты для расширения, но закрыты для модификации.
Этот принцип говорит о том, что классы нужно проектировать
так, чтобы впоследствии иметь возможность изменять поведение класса,
не изменяя его код.
Open for Extension and Closed for Modification

Open for Extension and Closed for Modification
function PersonePrinter () {
}
function (p) { }
}
function (p) { }
PersonePrinter.prototype.PrintToPrinterShortForm =
function (p) { }
PersonePrinter.prototype.PrintToPrinterDetailedForm =
function (p) { }
}
function (persone, printForm) { }
var PrintForm = { formats : [] }
function PrintFormGeneral () { }
PrintFormGeneral.prototype = PrintForm;
function PrintFormShort () { }
PrintFormShort.prototype = PrintForm;
function PrintFormDetailed () { }
PrintFormDetailed.prototype = PrintForm;

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

Liskov Substitution
}
function (persone, printForm) {
//...
if (printForm instanceof PrintFormGeneral)
{ }
//...
if (printForm instanceof PrintFormShort)
{ }
}
}
function (persone, printForm) {
//...
printForm.formatReport(persone);
//...
}

Interface Segregation
function Employee () {
this.UseComputer = function () { };
this.Develop = function () { };
this.Test = function () { };
}
function SoftDeveloper (){
Employee.call(this);
this.Develop = function() { }
this.Test = function() {/* How ? */ }
return this;
}
function SoftTester (){
this.Develop = function() { /* How ? */ }
this.Test = function() { }
return this;
}
function Employee () {
this.UseComputer = function () { };
}
function SoftDeveloper (){
this.Develop = function() { }
return this;
}
function SoftTester (){
this.Test = function() { }
return this;
}

• Модули верхних уровней не должны зависеть от модулей
нижних уровней.
• Оба типа модулей должны зависеть от абстракций.
• Абстракции не должны зависеть от реализаций.
• Реализации должны зависеть от абстракций.
Dependency Inversion

Dependency Inversion
function SoftDeveloper () {
this.Develop = function () { }
}
function Manager () {
var softDeveloper = new SoftDeveloper();
this.Manage = function() {
softDeveloper.Develop();
}
}
function SoftDeveloper () {
this.Develop = function () { }
}
function Manager (softDeveloper) {
var sd = softDeveloper;
this.Manage = function() {
sd.Develop();
}
}

Паттерн описывает задачу, которая снова и снова возникает в работе, а так
же принцип ее решения, причем таким образом, что это решение можно потом
использовать много раз, ничего не изобретая заново.
В общем случае паттерн состоит из четырех основных элементов:
• Имя. Присваивание паттернам имен позволяет проектировать на более высоком
уровне абстракции. С помощью имен паттернов можно вести общение с коллегами.
Назначение паттернам имен упрощает общение в профессиональной среде.
• Задача - это описание того, когда следует применять паттерн. Необходимо
сформулировать задачу и ее контекст. Может описываться конкретная проблема
проектирования, например способ представления алгоритмов в виде объектов. Так
же задача может включать перечень условий, при выполнении которых имеет
смысл применять данный паттерн.
• Решение представляет собой описание элементов дизайна, отношений между
ними, функций каждого элемента. Конкретный дизайн или реализация не имеются
ввиду, поскольку паттерн – это шаблон, применимый в самых разных ситуациях.
• Результаты - это следствия применения паттерна и разного рода компромиссы.
Хотя при описании проектных решений о последствиях часто не упоминают, знать
о них необходимо, чтобы можно было выбрать между различными вариантами и
оценить преимущества и недостатки данного паттерна.
Паттерны (шаблоны проектирования)

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

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

• Singleton (Одиночка) - контролирует создание единственного
экземпляра некоторого класса и предоставляет доступ к нему.
• Factory Method (Фабричный метод) - В его классическом варианте
вводится полиморфный класс Factory, в котором определяется
интерфейс фабричного метода, а ответственность за создание
объектов конкретных классов переносится на производные от Factory
классы, в которых этот метод переопределяется.
• Abstract Factory (Абстрактная фабрика) - использует несколько
фабричных методов и предназначен для создания целого семейства
или группы взаимосвязанных объектов.
• Builder (Строитель) - определяет процесс поэтапного конструирования
сложного объекта, в результате которого могут получаться разные
представления этого объекта.
• Prototype (Прототип) - создает новые объекты с помощью прототипов.
Прототип - некоторый объект, умеющий создавать по запросу копию
самого себя.
• Object Pool (Пул объектов) - используется в случае, когда создание
объекта требует больших затрат или может быть создано только
ограниченное количество объектов некоторого класса.
Порождающие паттерны

• Adapter представляет собой программную обертку над уже
существующими классами и предназначен для преобразования их
интерфейсов к виду, пригодному для последующего использования в
новом программном проекте.
• Bridge отделяет абстракцию от реализации так, что то и другое
можно изменять независимо.
• Composite группирует схожие объекты в древовидные структуры.
Рассматривает единообразно простые и сложные объекты.
• Decorator используется для расширения функциональности объектов.
Являясь гибкой альтернативой порождению классов, паттерн
Decorator динамически добавляет объекту новые обязанности.
• Facade предоставляет высокоуровневый унифицированный
интерфейс к набору интерфейсов некоторой подсистемы, что
облегчает ее использование.
• Flyweight использует разделение для эффективной поддержки
множества объектов.
• Proxy замещает другой объект для контроля доступа к нему.
Структурные шаблоны проектирования

• Паттерн Chain of Responsibility позволяет обработать запрос
нескольким объектам-получателям. Получатели связываются в
цепочку, и запрос передается по цепочке, пока не будет обработан
каким-то объектом. Паттерн Chain of Responsibility позволяет также
избежать жесткой зависимости между отправителем запроса и его
получателями.
• Паттерн Command преобразовывает запрос на выполнение действия в
отдельный объект-команду. Это придает системе гибкость: позволяет
осуществлять динамическую замену команд, использовать сложные
составные команды, осуществлять отмену операций.
• Паттерн Iterator предоставляет механизм обхода элементов составных
объектов (коллекций) не раскрывая их внутреннего представления.
• Паттерн Interpreter предназначен для решения повторяющихся
задач, которые можно описать некоторым языком. Для этого паттерн
Interpreter описывает решаемую задачу в виде предложений этого
языка, а затем интерпретирует их.
• Паттерн Mediator инкапсулирует взаимодействие совокупности
объектов в отдельный объект-посредник. Уменьшает степень
связанности взаимодействующих объектов - им не нужно хранить
ссылки друг на друга.
Шаблоны поведения

• Паттерн Memento получает и сохраняет за пределами объекта его
внутреннее состояние так, чтобы позже можно было восстановить объект в
таком же состоянии.
• Паттерн Observer определяет зависимость "один-ко-многим" между
объектами так, что при изменении состояния одного объекта все
зависящие от него объекты уведомляются и обновляются автоматически.
• Паттерн State позволяет объекту изменять свое поведение в зависимости
от внутреннего состояния. Создается впечатление, что объект изменил
свой класс. Паттерн State является объектно-ориентированной
реализацией конечного автомата.
• Если поведение системы настраивается согласно одному из некоторого
множества алгоритму, то применение паттерна Strategy переносит
семейство алгоритмов в отдельную иерархию классов, что позволяет
заменять один алгоритм другим в ходе выполнения программы. Кроме
того, такую систему проще расширять и поддерживать.
• Паттерн Template Method определяет основу алгоритма и позволяет
подклассам изменить некоторые шаги этого алгоритма без изменения его
общей структуры.
• Паттерн Visitor определяет операцию, выполняемую на каждом элементе
из некоторой структуры без изменения классов этих объектов.
Шаблоны поведения

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

JavaScript Базовый. Занятие 04.

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to JavaScript Базовый. Занятие 04.

Similar to JavaScript Базовый. Занятие 04. (20)

More from Igor Shkulipa

More from Igor Shkulipa (20)

JavaScript Базовый. Занятие 04.