Почему используются классы, но программирование называется объектно-ориентированным?

Почему используются классы, но программирование называется объектно-ориентированным?

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

Что такое класс и объект?

Класс — это шаблон, чертёж, описание структуры и поведения. Объект — это конкретный экземпляр класса, который существует в памяти во время выполнения программы.

# Класс — шаблон
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        return f"{self.name} says Woof!"

# Объекты — конкретные экземпляры
dog1 = Dog("Buddy", 3)    # Объект 1
dog2 = Dog("Max", 5)      # Объект 2
dog3 = Dog("Bella", 2)    # Объект 3

print(dog1.bark())  # Buddy says Woof!
print(dog2.bark())  # Max says Woof!

Аналогия из реальной жизни

• Класс = чертёж автомобиля (описание)
• Объект = конкретный автомобиль, припаркованный на улице

Чертёж один, но на основе него создано миллионы автомобилей. Каждый автомобиль — это отдельный объект со своими характеристиками.

Почему ООП называется объектно-ориентированным, а не классо-ориентированным?

Потому что фокус парадигмы на объектах, а не на классах:

1. Объекты — основная единица работы

   • Пишешь код, который работает с объектами
   • Объекты имеют состояние (атрибуты) и поведение (методы)
   • Объекты взаимодействуют друг с другом

2. Классы — просто механизм создания объектов

   • Классы — это инструмент, а не цель
   • Без объектов классы бесполезны
   • В некоторых языках (JavaScript) вообще нет классов, только прототипы

Пример: Денежные переводы

class Account:
    def __init__(self, name, balance):
        self.name = name
        self.balance = balance
    
    def deposit(self, amount):
        self.balance += amount
    
    def withdraw(self, amount):
        self.balance -= amount
    
    def transfer(self, other_account, amount):
        if self.balance >= amount:
            self.withdraw(amount)
            other_account.deposit(amount)
            return True
        return False

# Создаём объекты на основе класса
alice_account = Account("Alice", 1000)
bob_account = Account("Bob", 500)

# Работаем с объектами
alice_account.transfer(bob_account, 200)

print(f"Alice: {alice_account.balance}")  # 800
print(f"Bob: {bob_account.balance}")      # 700

Здесь мы ориентированы на объекты (alice_account и bob_account), которые взаимодействуют друг с другом. Класс Account просто определяет, как эти объекты работают.

Языки без классов, но с ООП

JavaScript (до ES6) вообще не имел классов, но это был объектно-ориентированный язык:

// Прототипное ООП (без классов)
function Dog(name, age) {
    this.name = name;
    this.age = age;
}

Dog.prototype.bark = function() {
    return this.name + " says Woof!";
};

// Объекты создаются через функцию-конструктор
let buddy = new Dog("Buddy", 3);
let max = new Dog("Max", 5);

console.log(buddy.bark());  // Buddy says Woof!
console.log(max.bark());    // Max says Woof!

Здесь нет классов, но есть объектно-ориентированное программирование — объекты взаимодействуют, имеют состояние и методы.

Три кита ООП

1. Инкапсуляция — объект скрывает свои детали

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Приватный атрибут
    
    def get_balance(self):
        return self.__balance
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

accnt = BankAccount(1000)
accnt.deposit(500)
print(accnt.get_balance())  # 1500
# accnt.__balance  # AttributeError — не можем получить доступ напрямую

2. Наследование — объекты могут быть основаны на других объектах

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return f"{self.name} barks"

class Cat(Animal):
    def speak(self):
        return f"{self.name} meows"

# Объекты разных классов, но работают одинаково
dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak())  # Buddy barks
print(cat.speak())  # Whiskers meows

3. Полиморфизм — разные объекты одинаково реагируют на одни и те же сообщения

def make_sound(animal):
    print(animal.speak())

make_sound(dog)    # Buddy barks
make_sound(cat)    # Whiskers meows

# Функция работает с любым животным, не зная его конкретный тип

Заключение

Классы и объекты — это разные концепции:

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