Что такое ООП? Назовите основные принципы ООП с примерами.

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

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

Четыре основных принципа ООП

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

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

public class BankAccount {
    private double balance;  // приватное поле
    private String accountNumber;
    
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }
    
    // публичный метод для контролируемого доступа
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Депозит: " + amount);
        }
    }
    
    public double getBalance() {
        return balance;
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
}

Преимущества: защита данных от неправильного использования, возможность изменить внутреннюю реализацию без изменения интерфейса.

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

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

public abstract class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    abstract void makeSound();
    
    public void sleep() {
        System.out.println(name + " спит...");
    }
}

public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;
    }
    
    @Override
    void makeSound() {
        System.out.println(name + " лает: Гав-гав!");
    }
    
    public void fetch() {
        System.out.println(name + " приносит мяч");
    }
}

public class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println(name + " мяукает: Мяу!");
    }
}

Преимущества: переиспользование кода, естественная иерархия, полиморфизм.

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

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

public static void animalConcert(Animal animal) {
    animal.makeSound();  // работает для любого животного!
}

public static void main(String[] args) {
    Animal dog = new Dog("Рекс", 3, "Лабрадор");
    Animal cat = new Cat("Мурзик", 5);
    
    animalConcert(dog);   // выведет: Рекс лает: Гав-гав!
    animalConcert(cat);   // выведет: Мурзик мяукает: Мяу!
    
    // Полиморфизм в действии!
}

Полиморфизм бывает двух видов:

• Compile-time (статический) - перегрузка методов
• Runtime (динамический) - переопределение методов

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

Прячем сложность, показываем только важное. Определяем интерфейс, скрывая детали реализации.

public interface PaymentProcessor {
    boolean processPayment(double amount);
    void refund(double amount);
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public boolean processPayment(double amount) {
        // сложная логика обработки платежа через банк
        validateCard();
        callBankAPI();
        return true;
    }
    
    @Override
    public void refund(double amount) {
        // логика возврата денег
    }
    
    private void validateCard() { /* ... */ }
    private void callBankAPI() { /* ... */ }
}

public class PayPalProcessor implements PaymentProcessor {
    @Override
    public boolean processPayment(double amount) {
        // другая реализация для PayPal
        return true;
    }
    
    @Override
    public void refund(double amount) { /* ... */ }
}

public class Shop {
    public void checkout(PaymentProcessor processor, double price) {
        processor.processPayment(price);  // не важно какой процессор
    }
}

Преимущества: легче поддерживать код, просто добавить новые реализации, тестировать через mocks.

Практическое применение

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

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

Это делает код гибким, модульным и легким в поддержке.