Какие основные принципы объектно-ориентированного программирования (ООП) ты знаешь?

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

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

1. Инкапсуляция (Encapsulation)

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

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

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 1500
# account._balance = -1000  # Плохо! Нарушена инкапсуляция

Преимущества:

• Защита данных от несанкционированного доступа
• Возможность добавлять проверки и логику
• Упрощение изменения внутренней реализации

2. Наследование (Inheritance)

Наследование — это механизм, который позволяет создавать новые классы на основе существующих, переиспользуя код.

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        return "Some sound"

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.make_sound())  # Woof!
print(cat.make_sound())  # Meow!

Типы наследования:

• Одиночное наследование — класс наследует от одного родителя
• Множественное наследование — класс наследует от нескольких родителей
• Многоуровневое наследование — цепочка наследования (A → B → C)

class Vehicle:
    pass

class Car(Vehicle):
    pass

class ElectricCar(Car):
    pass

Преимущества:

• Переиспользование кода
• Создание иерархии типов
• Полиморфизм через переопределение методов

3. Полиморфизм (Polymorphism)

Полиморфизм — это способность объектов различных типов выполнять один и тот же интерфейс.

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

shapes = [Circle(5), Rectangle(4, 6)]

for shape in shapes:
    print(f"Площадь: {shape.area()}")
# Вывод:
# Площадь: 78.5
# Площадь: 24

Виды полиморфизма:

• Полиморфизм методов — переопределение методов в подклассах
• Утиная типизация — объект должен иметь нужный метод, тип не важен

class Dog:
    def speak(self):
        return "Bark!"

class Person:
    def speak(self):
        return "Hello!"

def make_speak(entity):
    return entity.speak()

print(make_speak(Dog()))  # Bark!
print(make_speak(Person()))  # Hello!

4. Абстракция (Abstraction)

Абстракция — это скрытие сложности и представление только необходимых деталей.

from abc import ABC, abstractmethod

class Database(ABC):
    @abstractmethod
    def connect(self):
        pass
    
    @abstractmethod
    def query(self, sql):
        pass

class PostgreSQL(Database):
    def connect(self):
        return "Подключение к PostgreSQL"
    
    def query(self, sql):
        return f"Выполняем: {sql}"

class MongoDB(Database):
    def connect(self):
        return "Подключение к MongoDB"
    
    def query(self, sql):
        return f"Запрос: {sql}"

db = PostgreSQL()
print(db.connect())
print(db.query("SELECT * FROM users"))

Преимущества:

• Простота использования
• Гибкость реализации
• Независимость от деталей

Взаимосвязь принципов

Эти четыре принципа работают вместе:

• Инкапсуляция скрывает детали
• Наследование переиспользует код
• Полиморфизм обеспечивает гибкость
• Абстракция упрощает сложность

Примерно так можно создать масштабируемую систему:

from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    @abstractmethod
    def process(self, amount):
        pass

class CreditCardProcessor(PaymentProcessor):
    def __init__(self, card_number):
        self._card_number = card_number
    
    def process(self, amount):
        # Защищенный доступ к приватным атрибутам
        if self._validate_card():
            return f"Обработано {amount} на {self._card_number}"
        return "Ошибка"
    
    def _validate_card(self):
        return len(self._card_number) == 16

class PayPalProcessor(PaymentProcessor):
    def process(self, amount):
        return f"PayPal платеж: {amount}"

def checkout(processor: PaymentProcessor, amount):
    return processor.process(amount)

# Полиморфизм: обе системы работают через один интерфейс
cc_processor = CreditCardProcessor("1234567890123456")
paypal = PayPalProcessor()

print(checkout(cc_processor, 100))
print(checkout(paypal, 100))

Эти принципы — основа для написания чистого, масштабируемого и поддерживаемого кода.