Мы продолжаем рассказ об объектно-ориентированном программировании: зачем оно нужно и в чём его сила. Это скорее теория, чем необходимая ежедневная практика, но такие вещи приводят в порядок картину мира.
? Если вы пишете простые программы для себя, все эти вещи вам не нужны. Но если хотите стать профессионалом — добро пожаловать. Разговор будет сложным, но полезным.
Вспоминаем основные понятия
- Есть программа — это последовательность заданий, которые мы даём компьютеру.
- Сами задания простые, но из простых заданий можно сделать более сложные. Если такое более сложное задание как-то назвать, можно сказать, что это функция — мини-программа внутри программы.
- В функцию можно упаковать любые последовательности действий, которые вам часто нужны в программе: например, сохранить файл особым образом, вывести что-то на особый экран или отправить электронное письмо на особый адрес.
- Внутри одних функций можно вызывать другие. Так можно делать всё более и более сложные функции. Например, есть функция «сохранить пользователя в базу данных». Её можно вызвать изнутри функции «Зарегистрировать пользователя». А уже эту функцию можно вызвать изнутри функции «Обработать логин и пароль».
- Проблема: когда много функций вызываются друг из друга, они переплетаются и создают много зависимостей. Если изменить работу одной из функций, могут посыпаться все связанные.
- Решение: стандартизировать подходы к работе функций. В том числе для этого придумали объектно-ориентированное программирование. Там главное — не функция, а объект. Объект — это набор функций и данных. Объект можно стандартизировать с помощью понятия «класс».
- И вот мы здесь.
На примере зверей
Вспомним уроки биологии: царство животных, виды и подвиды. Там есть класс «млекопитающие». У этого класса есть свойство, которое отличает его от всех других: все млекопитающие вскармливают детей молоком.
Все подклассы, которые входят в класс млекопитающих, тоже вскармливают детёнышей молоком. В ООП это называется наследованием: всё, что относится к базовому классу, применимо и к подклассам.
Среди млекопитающих есть семейства волчьих, кошачьих и так далее. Это тоже классы. У этих классов есть свои методы, например, как они охотятся. У них есть свои свойства, например, характер и цвет шерсти. У них есть свои интерфейсы — как они общаются между собой и с внешним миром.
Каждый представитель семейства волчьих, например волк, — это конкретный объект на основе своего класса. Если мы знаем, как в этом классе реализован метод «Загнать добычу», то у конкретного волка этот метод будет работать точно так же.
Суть объектов в том, что нам не нужно каждый раз изучать или создавать его поведение или свойства — мы уже сделали это один раз в классе, а потом просто создаём объекты на его основе. И если нам понадобится изменить способ охоты на добычу у всех волков, нам достаточно сделать это только в одном месте — в описании класса. И дальше наступает магия: все объекты начинают вести себя по-новому, хотя мы их не трогали вообще, мы просто изменили их базовый класс.
Исходные данные
Допустим, мы пишем интернет-магазин с системой скидок. Нам нужно работать с пользователями — постоянными покупателями. Пользователь у нас будет объектом: у него есть имя, возраст и адрес доставки по умолчанию. Мы заведём класс, который поможет инициировать нового покупателя.
Python будет нашим объектным языком в этом примере. Зададим через него класс.
Важное замечание: первым параметром в конструкторе идёт служебное слово self. Оно нужно для того, чтобы класс мог работать со своими значениями. Это чисто служебное слово.
language: Python 3
class User:
"""Класс для всех покупателей"""
# Заводим переменную, которая будет считать число покупателей
user_count = 0
# Это — конструктор, который отвечает за создание новых покупателей
def __init__(self, name, age, adress):
# В нём мы говорим: возьми те параметры, которые пришли в скобках, и первый пусть будет именем, второй — возрастом, а третий положим в свойство «Адрес»
self.name = name
self.age = age
self.adress = adress
# Увеличиваем количество покупателей на единицу
user.user_count += 1
Скопировать код
Здесь сказано: «Вот класс для покупателя. У него есть три свойства: имя, возраст и адрес». Теперь мы можем заводить новых покупателей одной строкой:
# Заводим покупателей
user1 = User('Вася',23,'Чебоксары)
user2 = User('Маша',19,'Белгород')
JavaScript у нас будет примером процедурного языка, поэтому мы в нём не будем создавать классы, а используем просто переменные и функции. Создадим тех же двух пользователей:
language: JavaScript
// Создаём первого покупателя
user1 = ['Вася',23,'Чебоксары'];
// Создаём второго покупателя
user2 = ['Маша',19,'Белгород'];
Скопировать код
Глядя на код, кажется, что без классов проще: код получается короче и понятнее. Так и есть, но лишь для самых простых вещей. Как только мы начнём делать действительно сложную программу, без классов часто вообще не обойтись.
Важное объяснение про классы в JavaScript.
Мы знаем, что в JS тоже есть классы и с ними даже можно работать. Но для обучения и понимания принципов ООП классы в JS не очень подходят: в них всё сложно с private-переменными и видимостью; технически классы — это функции, да и с методом определения там не всё так просто. Поэтому мы выбрали Python как классический пример объектного подхода: строгие классы и все возможности ООП. В этой статье мы намеренно упрощаем использование JavaScript, чтобы показать, как работает чистый процедурный подход. Программисты, не ругайтесь на нас за это.
Усложняем задачу
Мы хотим, чтобы у нашего клиента появились бонусные баллы. Для этого нужно вписать в класс ещё одно свойство. Тогда при создании новых объектов-покупателей у них тоже будут бонусные баллы. То есть мы пойдём не в каждого покупателя и не будем каждому прописывать баллы, а сделаем это в классе.
И окончательно усложним: допустим, у нас четыре уровня программы лояльности: 0, 1, 2 и 3. И за каждые 10 000 бонусных баллов мы повышаем покупателю уровень на единицу, пока не достигнем максимального. Мы хотим, чтобы у покупателей появился метод add_bonus(), который добавляет бонусные баллы и при необходимости повышает уровень программы лояльности. И чтобы всё это работало одинаково на всех десяти покупателях.
В ООП-подходе нам понадобится:
- класс для покупателей, в нём пять свойств — имя, возраст, адрес доставки, число бонусных баллов и уровень бонусной программы;
- в классе метод add_bonus(), который повышает уровни лояльности и следит за тем, чтобы он у всех был не выше трёх;
- когда всё будет готово, мы инициируем покупателей, а потом начисляем им какое-то количество баллов.
В процедурном подходе мы просто будем создавать нужные переменные, функции, которые обрабатывают всякие события, а потом вызывать их в нужное время. Звучит проще, но это только на первый взгляд.
Класс для покупателей
Python. Вот как будет выглядеть класс с объектно-ориентированным подходом. Пока что без методов, только данные:
language: Python 3
class user:
"""Класс для всех покупателей"""
# Заводим переменную, которая будет считать число покупателей
user_count = 0
# Конструктор, который отвечает за создание новых объектов
def __init__(self, name, age, adress, bonus, loyalty):
# Записываем в новый объект имя покупателя…
self.name = name
# его возраст…
self.age = age
# адрес доставки…
self.adress = adress
# количество бонусных баллов на старте…
self.bonus = bonus
# и уровень программы лояльности
self.loyalty = loyalty
# Увеличим порядковый номер покупателя на единицу
user.user_count += 1
Скопировать код
JavaScript. Так как мы договорились не использовать здесь классы, то создавать тоже пока нечего. На всякий случай напомним, как мы будем создавать переменные с покупателями, это пригодится нам на следующем шаге:
// Создаём первого покупателя
user1 = ['Вася',23,'Чебоксары'];
// Создаём второго покупателя
user2 = ['Маша',19,'Белгород'];
Начисляем бонусные баллы — метод add_bonus()
Задача этого кода — сделать так, чтобы определённый покупатель получил нужное количество бонусных баллов и использовать это в программе лояльности. Работает она так: за каждые 10 000 баллов даётся новый уровень, но максимальный уровень — 3, выше него получить ничего нельзя, даже если баллы позволяют.
Логика будет такая: берём бонусные баллы и прибавляем к тем, что уже есть у покупателя. Затем делим баллы на 10 000, берём целую часть от деления и делаем это уровнем программы лояльности. При этом проверяем, чтобы она не была больше трёх. Если уровень получается больше трёх — делаем принудительно тройку.
language: Python 3
# Определяем метод начисления бонусных баллов
def add_bonus(self, bonus_count):
# На вход нам поступило количество бонусных баллов — поместим их в свойство bonus
self.bonus += bonus_count
# Посчитаем новый уровень программы лояльности и поместим его в свойство loyalty
self.loyalty = self.bonus // 10000
# Если у нас получился уровень выше чем 3, то
if self.loyalty > 3:
# принудительно делаем его равным 3
self.loyalty = 3
# Выводим сообщение о том, что у такого-то покупателя теперь вот такой бонусный уровень
print('Бонусный уровень покупателя {}: {}' .format(self.name, self.loyalty))
Скопировать код
Посмотрите на последнюю строчку, где мы выводим сообщение. Мы сначала подготовили всю строку, а там, где должны быть имя и уровень программы лояльности, стоят фигурные скобки. Это значит, что мы должны назвать те переменные, которые туда по очереди подставятся — именно в той последовательности, в которой мы их зададим. Это делается командой .format, которую мы пишем сразу после нашей строки.
Плюс такого подхода в том, что это универсальный метод для каждого объекта, который создаётся на основе этого класса. Нам не нужно писать код для каждого покупателя — он работает для всех.
JavaScript. В процедурном программировании каждая переменная — это отдельная сущность, которая может требовать индивидуального подхода. Поэтому мы будем писать обработчик бонусных баллов для каждой переменной user1, user2 и так далее:
language: JavaScript
function user1_add_bonus(bonus_count) {
user1[3] += bonus_count;
user1[4] = Math.floor(user1[3]/10000);
if (user1[4] > 3) {
user1[4] = 3;
}
console.log('Бонусный уровень покупателя ', user1[0], ' : ', user1[4])
}
function user2_add_bonus(bonus_count) {
user2[3] += bonus_count;
user2[4] = Math.floor(user2[3]/10000);
if (user2[4] > 3) {
user2[4] = 3;
}
console.log('Бонусный уровень покупателя ', user2[0], ' : ', user2[4])
}
Скопировать код
Сразу стало много кода — а это мы обработали всего двух покупателей. Представьте, что будет, когда покупателей станет хотя бы 10.
Финал: работаем с покупателями
Теперь смоделируем такую ситуацию: у нас появляется 5 покупателей, и некоторым из них мы начисляем бонусные баллы.
Python.
language: Python 3
class user:
"""Класс для всех покупателей"""
# Заводим переменную, которая будет считать число покупателей
user_count = 0
# Конструктор, который отвечает за создание новых объектов
def __init__(self, name, age, adress, bonus, loyalty):
# Записываем в новый объект имя покупателя…
self.name = name
# его возраст…
self.age = age
# адрес доставки…
self.adress = adress
# количество бонусных баллов на старте…
self.bonus = bonus
# и уровень программы лояльности
self.loyalty = loyalty
# Увеличим порядковый номер покупателя на единицу
user.user_count += 1
# Определяем метод начисления бонусных баллов
def add_bonus(self, bonus_count):
# На вход нам поступило количество бонусных баллов — поместим их в свойство bonus
self.bonus += bonus_count
# Посчитаем новый уровень программы лояльности и поместим его в свойство loyalty
self.loyalty = self.bonus // 10000
# Если у нас получился уровень выше чем 3, то
if self.loyalty > 3:
# принудительно делаем его равным 3
self.loyalty = 3
# Выводим сообщение о том, что у такого-то покупателя теперь вот такой бонусный уровень
print('Бонусный уровень покупателя {}: {}' .format(self.name, self.loyalty))
# Создаём первого покупателя
user1 = user('Вася',23,'Чебоксары',0,0)
# Добавляем ему 15000 бонусов
user1.add_bonus(15000)
# Создаём второго покупателя
user2 = user('Маша',19,'Белгород',3000,0)
# Добавляем ей 5000 бонусов
user2.add_bonus(5000)
# Создаём третьего покупателя
user3 = user('Максим',31,'Москва',0,1)
# Создаём четвёртого покупателя
user4 = user('Аня',45,'Казань',5000,2)
# Создаём пятого покупателя
user5 = user('Наташа',32,'Брянск',8000,1)
# Добавляем ей 10000 бонусов
user5.add_bonus(10000)
Скопировать код
JavaScript. Сделаем то же самое на JS, не забывая прописать свой обработчик для каждой переменной:
language: JavaScript
function user1_add_bonus(bonus_count) {
user1[3] += bonus_count;
user1[4] = Math.floor(user1[3]/10000);
if (user1[4] > 3) {
user1[4] = 3;
}
console.log('Бонусный уровень покупателя ', user1[0], ' : ', user1[4])
}
function user2_add_bonus(bonus_count) {
user2[3] += bonus_count;
user2[4] = Math.floor(user2[3]/10000);
if (user2[4] > 3) {
user2[4] = 3;
}
console.log('Бонусный уровень покупателя ', user2[0], ' : ', user2[4])
}
function user3_add_bonus(bonus_count) {
user3[3] += bonus_count;
user3[4] = Math.floor(user3[3]/10000);
if (user3[4] > 3) {
user3[4] = 3;
}
console.log('Бонусный уровень покупателя ', user3[0], ' : ', user3[4])
}
function user4_add_bonus(bonus_count) {
user4[3] += bonus_count;
user4[4] = Math.floor(user4[3]/10000);
if (user4[4] > 3) {
user4[4] = 3;
}
console.log('Бонусный уровень покупателя ', user4[0], ' : ', user4[4])
}
function user5_add_bonus(bonus_count) {
user5[3] += bonus_count;
user5[4] = Math.floor(user5[3]/10000);
if (user5[4] > 3) {
user5[4] = 3;
}
console.log('Бонусный уровень покупателя ', user5[0], ' : ', user5[4])
}
// Создаём первого покупателя
user1 = ['Вася',23,'Чебоксары',0,0];
// Добавляем ему 15000 бонусов
user1_add_bonus(15000);
// Создаём второго покупателя
user2 = ['Маша',19,'Белгород',3000,0];
// Добавляем ей 5000 бонусов
user2_add_bonus(5000);
// Создаём третьего покупателя
user3 = ['Максим',31,'Москва',0,1]
// Создаём четвёртого покупателя
user4 = ['Аня',45,'Казань',5000,2];
// Создаём пятого покупателя
user5 = ['Наташа',32,'Брянск',8000,1];
// Добавляем ей 10000 бонусов
user5_add_bonus(10000);
Скопировать код
Код делает то же самое, при этом он больше на 20%, хотя у нас всего 5 пользователей. Если мы добавим ещё 5, размер кода увеличится вдвое. А теперь представьте, что вам нужно добавить новое действие — списание бонусных баллов. В классе это сделать просто: в описании класса добавляем новый метод, и им могут пользоваться все объекты этого класса. А в процедурном программировании нам нужно будет прописывать столько же обработчиков, сколько и покупателей. Если у нас будет 100 покупателей, код превратится в ад.
Что дальше
Мы изучили, как работают классы, и немного программировали на Питоне. Следующий материал — про то, как устроен этот язык программирования и как его быстро освоить, если вы уже умеете писать на JavaScript.
