Для чего нужен каждый принцип ООП?

# Принципы ООП и их назначение

Введение

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

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

Назначение

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

Зачем нужна

• Защита данных: предотвращает некорректное использование внутреннего состояния
• Гибкость изменений: можно менять внутреннюю реализацию без изменения публичного API
• Контроль: валидация данных при установке значений

Пример

public class BankAccount {
    private double balance;  // скрыто
    
    public BankAccount(double initialBalance) {
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        }
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    public double getBalance() {
        return balance;
    }
}

При этом подходе:

• Баланс нельзя установить напрямую (balance = -1000)
• Все операции проходят валидацию
• Можно менять хранение баланса (например, с double на BigDecimal) без изменения публичного API

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

Назначение

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

Зачем нужно

• Переиспользование кода: не повторяем общую логику в разных классах
• Логическая иерархия: отражает отношения между сущностями в предметной области
• Полиморфизм: основа для динамического полиморфизма

Пример

public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void makeSound() {
        System.out.println("Some generic sound");
    }
    
    public void move() {
        System.out.println("Moving...");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    
    @Override
    public void makeSound() {
        System.out.println("Tweet!");
    }
    
    @Override
    public void move() {
        System.out.println("Flying...");
    }
}

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

• Класс move() определён один раз в Animal, но каждый класс может его переопределить
• Новый животный класс не нужно создавать с нуля
• Можно работать через общий тип Animal

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

Назначение

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

Зачем нужен

• Гибкость кода: один метод может обрабатывать объекты разных типов
• Расширяемость: добавляем новые типы без изменения существующего кода
• Абстракция: скрываем различия в реализации

Пример 1: Полиморфизм наследования (Runtime)

public void performAnimalActions(List<Animal> animals) {
    for (Animal animal : animals) {
        animal.makeSound();  // вызовется разный метод в зависимости от типа
        animal.move();
    }
}

// Использование
List<Animal> animals = Arrays.asList(
    new Dog("Rex"),
    new Bird("Tweety"),
    new Animal("Generic")
);
performAnimalActions(animals);

// Вывод:
// Woof!
// Moving...
// Tweet!
// Flying...
// Some generic sound
// Moving...

Пример 2: Полиморфизм интерфейсов

public interface PaymentProcessor {
    void process(double amount);
    boolean isAvailable();
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void process(double amount) {
        System.out.println("Processing credit card payment: $" + amount);
    }
    
    @Override
    public boolean isAvailable() {
        return true;
    }
}

public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void process(double amount) {
        System.out.println("Processing PayPal payment: $" + amount);
    }
    
    @Override
    public boolean isAvailable() {
        // проверяем доступность PayPal
        return true;
    }
}

public class Order {
    public void checkout(PaymentProcessor processor, double total) {
        if (processor.isAvailable()) {
            processor.process(total);
        }
    }
}

Пример 3: Полиморфизм перегрузки методов (Compile-time)

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public String add(String a, String b) {
        return a + b;
    }
}

Calculator calc = new Calculator();
System.out.println(calc.add(5, 3));              // 8
System.out.println(calc.add(5.5, 3.2));          // 8.7
System.out.println(calc.add(5, 3, 2));           // 10
System.out.println(calc.add("Hello ", "World")); // Hello World

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

Назначение

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

Зачем нужна

• Упрощение: клиент видит только то, что ему нужно
• Снижение зависимостей: код зависит от абстракции, а не от конкретной реализации
• Облегчение тестирования: легко мокировать абстрактные типы
• Уменьшение когнитивной нагрузки: не нужно понимать все детали реализации

Пример 1: Абстрактный класс

public abstract class Vehicle {
    protected String brand;
    
    public Vehicle(String brand) {
        this.brand = brand;
    }
    
    // абстрактный метод - должен быть реализован в подклассе
    public abstract void start();
    public abstract void stop();
    
    // конкретный метод - может использоваться всеми подклассами
    public void displayInfo() {
        System.out.println("Brand: " + brand);
    }
}

public class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("Car engine started with key");
    }
    
    @Override
    public void stop() {
        System.out.println("Car engine stopped");
    }
}

public class ElectricCar extends Vehicle {
    @Override
    public void start() {
        System.out.println("Electric car motor activated");
    }
    
    @Override
    public void stop() {
        System.out.println("Electric car motor deactivated");
    }
}

Пример 2: Интерфейс

public interface DatabaseConnection {
    void connect(String url);
    void executeQuery(String sql);
    void disconnect();
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect(String url) {
        System.out.println("Connecting to MySQL: " + url);
    }
    
    @Override
    public void executeQuery(String sql) {
        System.out.println("Executing MySQL query: " + sql);
    }
    
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from MySQL");
    }
}

public class DataService {
    private DatabaseConnection connection;
    
    public DataService(DatabaseConnection connection) {
        this.connection = connection;
    }
    
    public void fetchData(String query) {
        connection.connect("jdbc:mysql://localhost:3306/db");
        connection.executeQuery(query);
        connection.disconnect();
    }
}

DataService не знает конкретные детали реализации MySQLConnection, PostgreSQLConnection и т.д. Он работает через абстракцию DatabaseConnection.

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

Абстракция (интерфейсы, абстрактные классы)
         ↓
Наследование (классы реализуют интерфейсы)
         ↓
Полиморфизм (объекты работают через общий интерфейс)
         ↓
Инкапсуляция (скрыт внутреннее состояние)

Практический пример: E-commerce система

// Абстракция
public interface Discount {
    double applyDiscount(double price);
}

// Наследование через реализацию
public class PercentageDiscount implements Discount {
    private double percent;
    
    public PercentageDiscount(double percent) {
        this.percent = percent;
    }
    
    @Override
    public double applyDiscount(double price) {
        return price * (1 - percent / 100);
    }
}

public class FixedDiscount implements Discount {
    private double amount;
    
    public FixedDiscount(double amount) {
        this.amount = amount;
    }
    
    @Override
    public double applyDiscount(double price) {
        return Math.max(0, price - amount);
    }
}

// Инкапсуляция + Полиморфизм
public class ShoppingCart {
    private double totalPrice;
    private Discount discount;
    
    public ShoppingCart() {
        this.totalPrice = 0;
        this.discount = null;
    }
    
    public void addItem(double price) {
        if (price > 0) {
            totalPrice += price;
        }
    }
    
    public void applyDiscount(Discount discount) {
        this.discount = discount;
    }
    
    public double getTotal() {
        if (discount != null) {
            return discount.applyDiscount(totalPrice);
        }
        return totalPrice;
    }
}

// Использование
public static void main(String[] args) {
    ShoppingCart cart = new ShoppingCart();
    cart.addItem(100);
    cart.addItem(50);
    
    // Полиморфизм - работает с любой реализацией Discount
    cart.applyDiscount(new PercentageDiscount(10));
    System.out.println("Total: $" + cart.getTotal()); // 135
    
    cart.applyDiscount(new FixedDiscount(20));
    System.out.println("Total: $" + cart.getTotal()); // 130
}

Резюме

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