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

Объектно-ориентированное программирование (ООП)

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

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

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

Целесообразность ООП предполагается в следующих случаях:

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

Указанные выше задача и свойства достигаются с помощью основных принципов ООП.

Основные принципы ООП:

1) абстракция;

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

Является основой объектно-ориентированного программирования и позволяет работать с объектами, не вдаваясь в особенности их реализации.

Указанное выше контекстное понимание предмета в общем случае формализуется в виде класса.

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

Замечание: абстрагирование не является атрибутом исключительно ООП, да и вообще программирования.

[свернуть]

2) инкапсуляция;

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

Пример свойств и методов

Возьмем человека как объект.

Рост, вес, возраст — свойства (или данные).

Ходить, спать, сидеть — методы (или поведение).

[свернуть]

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

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

[свернуть]

3) наследование;

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

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

Новый класс — потомком, наследником, дочерним или производным классом.

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

JavaScript вместо наследования использует прототипирование: если искомого свойства или вызванного метода в самом объекте нет, то запрос передаётся объекту-прототипу (свойство prototype всех объектов JavaScript).

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

Поведение всех объектов класса можно поменять, заменив один из методов прототипа (например, добавив метода .toBASE64 для класса String).

[свернуть]

4) полиморфизм.

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

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

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

[свернуть]

JavaScript вместо наследования использует прототипирование: если искомого свойства или вызванного метода в самом объекте нет, то запрос передаётся объекту-прототипу (свойство prototype всех объектов JavaScript).

Понятие "класс" в ООП

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

Класс является моделью информационной сущности с внутренним и внешним интерфейсами для оперирования своим содержимым (значениями полей).

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

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

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

Понятие "объект" в ООП

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

Объект — это появляющийся при создании экземпляра класса набор свойств и их значений в памяти, на которые можно сослаться с помощью идентификатора:

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

JavaScript спроектирован на основе простой концепции, в основе которой лежат простые объекты. В дополнение к встроенным в браузер объектам, вы можете определить свои собственные объекты.

Свойства объекта в JavaScript

В JavaScript объект имеет свойства, ассоциированные с ним. Свойство объекта:

можно понимать как переменную, закрепленную за объектом;
определяют характеристики объекта.

Получение доступа к свойству объекта:

objectName.propertyName
// или
objectName["propertyName"]

objectName.propertyName

// или

objectName["propertyName"]

Примеры:

var myCar = new Object(); // создание объекта с помощью конструктора
myCar.make = "Ford";
myCar.model = "Mustang";
myCar.year = 1969;

// или
myCar["make"] = "Ford";
myCar["model"] = "Mustang";
myCar["year"] = 1969;

var myCar = new Object(); // создание объекта с помощью конструктора

myCar.make = "Ford";

myCar.model = "Mustang";

myCar.year = 1969;

// или

myCar["make"] = "Ford";

myCar["model"] = "Mustang";

myCar["year"] = 1969;

Неопределенные свойства объекта являются undefined (а не null).

Как и все переменные JavaScript, имя объекта (которое тоже может быть переменной) и имя свойства являются чувствительными к регистру.

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

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

Примеры

Отсюда

var myObj = new Object(),
str = "myString",
rand = Math.random(),
obj = new Object();

myObj.type = "Dot syntax";
myObj["date created"] = "String with space";
myObj[str] = "String value";
myObj[rand] = "Random Number";
myObj[obj] = "Object";
myObj[""] = "Even an empty string";

console.log(myObj);

var myObj = new Object(),

str = "myString",

rand = Math.random(),

obj = new Object();

myObj.type = "Dot syntax";

myObj["date created"] = "String with space";

myObj[str] = "String value";

myObj[rand] = "Random Number";

myObj[obj] = "Object";

myObj[""] = "Even an empty string";

console.log(myObj);

Обратите внимание, что все ключи с квадратными скобками преобразуются в тип String, поскольку объекты в JavaScript могут иметь в качестве ключа только тип String. Например, в приведенном выше коде, когда ключ obj добавляется в myObj, JavaScript вызывает метод obj.toString () и использует эту результирующую строку в качестве нового ключа.

[свернуть]

Создание объекта в JavaScript

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

пустой объект:
- с помощью фигурных скобок {…} с необязательным списком свойств (литеральная нотация);
- методом Object.create(null);
с помощью функции-"конструктора" объекта (через new Object(nameKlass), где nameKlass - функция-конструктор);
клонировать существующий объект и расширить его:
- делегированием через прототипы (объект ссылается или делегирует другому объекту):
  1. с помощью метода Object.create(nameKlass) (создание объекта из прототипа nameKlass);
  2. с использованием constructor;
- конкатенацией объектов (объект формируется путем добавления новых свойств к объекту из других существующих объектов).

let nameObject = {}; // синтаксис "литерал объекта" или "литеральная нотация"

let nameObject = new Object() // синтаксис "конструктор объекта", например:

function Car(make, model, year) {  // функция-конструктор
  this.make = make;
  this.model = model;
  this.year = year;
}
var mycar = new Car("Eagle", "Talon TSi", 1993); // Car {make: "Eagle", model: "Talon TSi", year: 1993}

let nameObject = {}; // синтаксис "литерал объекта" или "литеральная нотация"

let nameObject = new Object() // синтаксис "конструктор объекта", например:

function Car(make, model, year) { // функция-конструктор

this.make = make;

this.model = model;

this.year = year;

}

var mycar = new Car("Eagle", "Talon TSi", 1993); // Car {make: "Eagle", model: "Talon TSi", year: 1993}

Особенности создания объектов различными способами

Особенности создания пустого объекта:

myObj = {
  name: "Alex",
  surname: undefined,
  "user-adress": {
    country: "Russia",
    sity: "Moscow",
  },
}

let oldObj = {}; // __proto__: Object
let newObj = new Object(); // __proto__: Object
let objCreate = Object.create(null); // No properties

myObj = {

name: "Alex",

surname: undefined,

"user-adress": {

country: "Russia",

sity: "Moscow",

}

let oldObj = {}; // __proto__: Object

let newObj = new Object(); // __proto__: Object

let objCreate = Object.create(null); // No properties

Создание объектов различными способами с передачей объекта в качестве аргумента:

let oldObj = { myObj: {} }; // {myObj: {…}} (создается свойство myObj со значением в виде объекта myObj)

let newObj = new Object(oldObj); // копирование по ссылке!
console.log(newObj === oldObj); // true (!!!) (oldObj скопирован по ссылке)
// при изменении свойств newObj будут изменены свойства объекта oldObj

let objCreate = Object.create(oldObj); // __proto__: Object (myObj) (создается объект с прототипом myObj)
console.log(objCreate === oldObj); // false (oldObj - прототипное наследование)

let oldObj = { myObj: {} }; // {myObj: {…}} (создается свойство myObj со значением в виде объекта myObj)

let newObj = new Object(oldObj); // копирование по ссылке!

console.log(newObj === oldObj); // true (!!!) (oldObj скопирован по ссылке)

// при изменении свойств newObj будут изменены свойства объекта oldObj

let objCreate = Object.create(oldObj); // __proto__: Object (myObj) (создается объект с прототипом myObj)

console.log(objCreate === oldObj); // false (oldObj - прототипное наследование)

[свернуть]

C помощью метода Object.create(nameKlass) (создание объекта из прототипа)

Метод Object.create() создаёт новый объект с указанными объектом прототипа и свойствами.

Object.create(proto[, propertiesObject])

1	Object.create(proto[, propertiesObject])

Параметры:

proto - объект, который станет прототипом вновь созданного объекта;
propertiesObject - (необязательный параметр) объект, чьи собственные перечисляемые свойства (то есть такие, которые определены на самом объекте, а не унаследованы по цепочке прототипов) указывают дескрипторы свойств, добавляемых в новый объект.

Метод Object.create() возвращает новый объект (не копию по ссылке) с заданным прототипом и свойствами.

const user = {
    firstName: "Alex",
    age: "40",
  }; 
  
const newUser = Object.create(user);
const oldUser = Object.create(user, { car: { value: "Nissan" } });
let value = Object.getPrototypeOf(oldUser);

console.log(newUser.firstName); // Alex
console.log(oldUser.car); // Nissan
console.log(value); // {firstName: "Alex", age: "40"}

const user = {

firstName: "Alex",

age: "40",

};

const newUser = Object.create(user);

const oldUser = Object.create(user, { car: { value: "Nissan" } });

let value = Object.getPrototypeOf(oldUser);

console.log(newUser.firstName); // Alex

console.log(oldUser.car); // Nissan

console.log(value); // {firstName: "Alex", age: "40"}

[свернуть]

Обычно используют вариант с фигурными скобками {...}. Такое объявление называют литералом объекта (литеральной нотацией).

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

Таким образом, при использовании литерального синтаксиса {...} мы сразу можем:

сразу поместить в объект несколько свойств в виде пар «ключ: значение»;
создать пустой объект и добавить в него свойства позже.

Примеры

// Добавление свойств в объект при его создании

const user = {
  firstName: "Alex",
  lastName: "NAV",
  Age: "40",
  isAdmin: true,
  email: "email@email.ru",
  "user-adress": {         // в кавычках, т.к. имя невалидное (через дефис)
    country: "Russia",
    sity: "Moscow"
  },
  skills: ["html", "css", "JS"]
};

// Добавление свойств в объект при его создании

const user = {

firstName: "Alex",

lastName: "NAV",

Age: "40",

isAdmin: true,

email: "email@email.ru",

"user-adress": { // в кавычках, т.к. имя невалидное (через дефис)

country: "Russia",

sity: "Moscow"

skills: ["html", "css", "JS"]

};

// Создание пустого объекта и добавление в него свойств позже

let obj = {};
obj.name = "messi";
obj.year = 2018;
obj.speak = function() {
  return "My Name is " + this.name + "and this is year " + this.year;
};

// Создание пустого объекта и добавление в него свойств позже

let obj = {};

obj.name = "messi";

obj.year = 2018;

obj.speak = function() {

return "My Name is " + this.name + "and this is year " + this.year;

};

[свернуть]

Объект, объявленный через const, может быть изменён. Объявление const защищает от изменений только само именование объекта (в примере выше - nameObject), но не его свойства.

const user = {
  firstName: "Alex",
  lastName: "NAV",
  "user-adress": {   
    country: "Russia",
    sity: "Moscow"
  },
};

// Изменение значений свойств в объекте, объявленном через const, допускается
user.firstName = "Olga"; // {firstName: "Olga", lastName: "NAV", Age: "40", …}
user["user-adress"].country = "USA";

const user = {

firstName: "Alex",

lastName: "NAV",

"user-adress": {

country: "Russia",

sity: "Moscow"

};

// Изменение значений свойств в объекте, объявленном через const, допускается

user.firstName = "Olga"; // {firstName: "Olga", lastName: "NAV", Age: "40", …}

user["user-adress"].country = "USA";

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

Например:

function makeUser(name, age) {
 return {
  name: name,
  age: age
 };
}

let user = makeUser("John", 30);
alert(user.name); // John

function makeUser(name, age) {

return {

name: name,

age: age

};

}

let user = makeUser("John", 30);

alert(user.name); // John

В примере выше название свойств name и age совпадают с названиями переменных, которые мы подставляем в качестве значений этих свойств. Вместо name:name мы можем написать просто name:

function makeUser(name, age) {
 return {
  name, // то же самое, что и name: name
  age // то же самое, что и age: age
 };
}

function makeUser(name, age) {

return {

name, // то же самое, что и name: name

age // то же самое, что и age: age

};

}

Замечание: Зарезервированные слова разрешено использовать как имена свойств (в отличие от имён переменных, которые не могут совпадать с зарезервированными словами, такими как «for», «let», «return» и т.д.)

let obj = {
 for: 1,
 let: 2,
 return: 3
};

alert( obj.for + obj.let + obj.return ); // 6

let obj = {

for: 1,

let: 2,

return: 3

};

alert( obj.for + obj.let + obj.return ); // 6

Объектно-ориентированное программирование (ООП)

Основные принципы ООП:

Понятие "класс" в ООП

Понятие "объект" в ООП

Свойства объекта в JavaScript

Получение доступа к свойству объекта:

Создание объекта в JavaScript

Особенности создания пустого объекта:

Создание объектов различными способами с передачей объекта в качестве аргумента:

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