Для чего нужно ООП?

Для чего нужно ООП (Объектно-Ориентированное Программирование)

ООП — это парадигма программирования, которая кардинально изменила способ разработки больших, сложных систем. Это не просто синтаксис и классы, а философия организации кода, которая решает реальные проблемы разработки на практике.

Проблема: Программирование без ООП

Процедурный подход (без ООП)

// Старый подход: просто функции и данные
int bankAccountBalance = 1000;
String accountOwner = "John";
int savingsBalance = 500;
String savingsOwner = "John";

// Функции без связи с данными
public static void depositMoney(int accountId, int amount) {
    if (accountId == 1) {
        bankAccountBalance += amount;
    } else if (accountId == 2) {
        savingsBalance += amount;
    }
    // С 50 счётами это станет кошмаром
}

public static void withdrawMoney(int accountId, int amount) {
    if (accountId == 1) {
        if (bankAccountBalance >= amount) {
            bankAccountBalance -= amount;
        }
    } else if (accountId == 2) {
        if (savingsBalance >= amount) {
            savingsBalance -= amount;
        }
    }
    // Дублирование логики везде
}

public static void printAccountDetails(int accountId) {
    if (accountId == 1) {
        System.out.println("Account: " + accountOwner + ", Balance: " + bankAccountBalance);
    } else if (accountId == 2) {
        System.out.println("Account: " + savingsOwner + ", Balance: " + savingsBalance);
    }
    // Легко ошибиться при добавлении нового счёта
}

// Используем
bankAccountBalance = 1000;  // Ошибка: забыли про accountOwner
depositMoney(1, 500);

Проблемы:

• Данные и функции отделены (не связаны логически)
• Дублирование кода (if-else везде)
• Сложно добавлять новые типы счётов
• Легко случайно нарушить инварианты (баланс < 0)
• Нет инкапсуляции

Решение: ООП подход

// ООП подход: данные И поведение вместе
public class BankAccount {
    private String owner;
    private double balance;
    private String accountType;
    
    public BankAccount(String owner, String accountType) {
        this.owner = owner;
        this.accountType = accountType;
        this.balance = 0;
    }
    
    // Поведение напрямую связано с данными
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited: " + amount);
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            System.out.println("Withdrawn: " + amount);
        } else {
            System.out.println("Insufficient funds");
        }
    }
    
    public void printDetails() {
        System.out.println("Owner: " + owner + ", Balance: " + balance);
    }
    
    public double getBalance() {
        return balance;
    }
}

// Используем
BankAccount myAccount = new BankAccount("John", "Checking");
myAccount.deposit(500);
myAccount.withdraw(100);
myAccount.printDetails();

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

• Данные и операции логически связаны
• Нет дублирования
• Инкапсуляция (balance не может стать отрицательным)
• Легко добавлять новые типы счётов

Четыре столпа ООП

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

Идея: Скрыть внутренние детали реализации и предоставить контролируемый интерфейс.

public class User {
    // Приватные поля — защищены от прямого доступа
    private String password;
    private int age;
    
    // Публичный интерфейс — контролируемый доступ
    public void setPassword(String newPassword) {
        if (isValidPassword(newPassword)) {
            this.password = hashPassword(newPassword);
        }
    }
    
    public void setAge(int age) {
        if (age > 0 && age < 150) {
            this.age = age;  // Валидация
        }
    }
    
    // Без инкапсуляции
    // user.password = "123";  // Плохой пароль, хранится в открытом виде
    // user.age = -5;  // Отрицательный возраст
    
    // С инкапсуляцией
    // user.setPassword("123");  // Валидируется
    // user.setAge(-5);  // Отклоняется
}

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

• Защита данных
• Валидация
• Возможность менять реализацию без изменения интерфейса

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

Идея: Повторное использование кода через иерархию типов.

// Базовый класс
public abstract class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public abstract void makeSound();  // Каждый животное звучит по-своему
    
    public void sleep() {  // Общее поведение
        System.out.println(name + " is sleeping");
    }
}

// Подклассы наследуют и специализируют
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

// Без наследования пришлось бы дублировать sleep() для каждого типа

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

• DRY (Don't Repeat Yourself)
• Иерархическая организация
• Переиспользуемый код

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

Идея: Один интерфейс, много реализаций.

// Один интерфейс
public interface DatabaseDriver {
    void connect();
    void executeQuery(String sql);
    void disconnect();
}

// Много реализаций
public class MySQLDriver implements DatabaseDriver { ... }
public class PostgresDriver implements DatabaseDriver { ... }
public class MongoDriver implements DatabaseDriver { ... }

// Код работает с интерфейсом, а не с конкретной реализацией
public class DataService {
    private DatabaseDriver driver;  // Не зависит от конкретной БД!
    
    public DataService(DatabaseDriver driver) {
        this.driver = driver;  // Инъекция зависимости
    }
    
    public void fetchData() {
        driver.connect();
        driver.executeQuery("SELECT * FROM users");
        driver.disconnect();
    }
}

// Легко менять реализацию без изменения DataService
DataService service1 = new DataService(new MySQLDriver());
DataService service2 = new DataService(new PostgresDriver());

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

• Гибкость
• Слабая связанность (loose coupling)
• Легко расширять
• SOLID принципы

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

Идея: Скрыть сложность, предоставить простой интерфейс.

// Сложная реальность: сборка автомобиля — процесс с 1000 шагов
public class Car {
    private Engine engine;
    private Transmission transmission;
    private Suspension suspension;
    // ... 100 других компонентов
    
    // Абстрактный интерфейс: просто "ехать"
    public void drive() {
        engine.start();
        transmission.engageGear(1);
        suspension.adjustHeight();
        // ... 1000 строк сложной логики скрыты
        System.out.println("Car is driving smoothly");
    }
    
    public void brake() {
        // Сложная физика торможения
        System.out.println("Car stopped");
    }
}

// Пользователь просто вызывает методы
Car myCar = new Car();
myCar.drive();   // Не нужно знать про Engine, Transmission, etc.
myCar.brake();

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

• Упрощение интерфейса
• Управление сложностью
• Лучшая читаемость

Практические примеры из реального кода

Spring Framework (весь построен на ООП)

// Интерфейс (абстракция)
public interface UserRepository {
    User findById(Long id);
    void save(User user);
}

// Реализация для БД
@Repository
public class UserRepositoryJPA implements UserRepository {
    @Override
    public User findById(Long id) { /* ... */ }
    
    @Override
    public void save(User user) { /* ... */ }
}

// Сервис не знает о реализации (полиморфизм)
@Service
public class UserService {
    @Autowired
    private UserRepository repository;  // Могла быть любая реализация
    
    public User getUser(Long id) {
        return repository.findById(id);  // Вызовется нужная реализация
    }
}

Observer паттерн (событийность)

// Инкапсуляция + наследование + полиморфизм
public class Button {
    private List<ActionListener> listeners = new ArrayList<>();
    
    public void addListener(ActionListener listener) {
        listeners.add(listener);
    }
    
    public void click() {
        for (ActionListener listener : listeners) {
            listener.onAction();  // Полиморфизм
        }
    }
}

public interface ActionListener {
    void onAction();
}

// Разные реализации
public class PrintListener implements ActionListener {
    @Override
    public void onAction() {
        System.out.println("Button clicked");
    }
}

public class SaveListener implements ActionListener {
    @Override
    public void onAction() {
        database.save();
    }
}

// Использование
Button button = new Button();
button.addListener(new PrintListener());
button.addListener(new SaveListener());
button.click();  // Оба слушатели реагируют (полиморфизм)

Сравнение: С ООП vs Без ООП

Когда НЕ использовать ООП

// Маленький скрипт — ООП оverkill
public class SimpleCalculator {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        System.out.println(a + b);
    }
}

// Лучше просто функция
function add(a, b) {
    return a + b;
}

Вывод

ООП нужно для:

1. Управления сложностью — разбить монолит на управляемые части
2. Переиспользования кода — наследование, композиция
3. Защиты данных — инкапсуляция
4. Гибкости и расширяемости — полиморфизм
5. Масштабируемости — от малых до огромных систем
6. Командной разработки — четкие интерфейсы и ответственность

Это был прорыв в программировании, позволивший писать системы, которые раньше казались невозможными.