Какие базовые концепции есть в ООП

Какие базовые концепции есть в ООП

Объектно-ориентированное программирование (ООП) основано на четырёх ключевых концепциях.

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

Определение: Скрытие внутреннего состояния объекта и предоставление контролируемого доступа через методы.

public class BankAccount {
    // Private поле - скрыто от внешнего доступа
    private double balance;
    
    // Public методы - контролируемый доступ
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;  // Валидация перед изменением
        }
    }
    
    public double getBalance() {
        return balance;  // Только чтение, без прямого доступа
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;  // Валидация перед изменением
    }
}

BankAccount account = new BankAccount();
account.deposit(1000);      // ✓ Контролируемо
// account.balance = -500;   // ✗ Ошибка компиляции, приватное

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

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

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

Определение: Создание новых классов на основе существующих, переиспользуя и расширяя функциональность.

// Базовый класс (родитель)
public abstract class Animal {
    protected String name;  // Protected - доступно подклассам
    
    public Animal(String name) {
        this.name = name;
    }
    
    // Abstract метод - должен быть переопределён
    public abstract void makeSound();
    
    // Обычный метод
    public void eat() {
        System.out.println(name + " is eating");
    }
}

// Наследующий класс (дочерний)
public class Dog extends Animal {
    public Dog(String name) {
        super(name);  // Вызов конструктора родителя
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " says Woof!");
    }
    
    // Дополнительная функциональность
    public void fetch() {
        System.out.println(name + " is fetching");
    }
}

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

// Использование
Dog dog = new Dog("Rex");
dog.eat();         // Из Animal
dog.makeSound();   // Переопределено в Dog
dog.fetch();       // Только в Dog

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

• Single Inheritance: Класс наследует от одного класса (Java)
• Multiple Inheritance: От нескольких (Java не поддерживает, есть Interface)
• Multilevel Inheritance: A → B → C (цепочка)
• Hierarchical: Много классов наследуют от одного

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

Определение: Способность объектов одного типа вести себя по-разному в зависимости от контекста.

Compile-time (Static) Polymorphism

public class Calculator {
    // Перегрузка методов (Method Overloading)
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public String add(String a, String b) {
        return a + b;
    }
}

Calculator calc = new Calculator();
calc.add(5, 10);              // int version → 15
calc.add(5.5, 10.5);          // double version → 16.0
calc.add("Hello", "World");   // String version → "HelloWorld"

Runtime (Dynamic) Polymorphism

public abstract class Shape {
    public abstract double getArea();
    public abstract void draw();
}

public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing circle");
    }
}

public class Rectangle extends Shape {
    private double width, height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double getArea() {
        return width * height;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing rectangle");
    }
}

// Полиморфизм: один тип может быть разными объектами
Shape circle = new Circle(5);      // Тип Shape, объект Circle
Shape rect = new Rectangle(10, 20); // Тип Shape, объект Rectangle

List<Shape> shapes = Arrays.asList(circle, rect);
for (Shape shape : shapes) {
    shape.draw();        // Вызовется нужный метод (Circle или Rectangle)
    shape.getArea();     // Разные расчёты для каждого
}

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

Определение: Скрытие сложности и показ только необходимого интерфейса.

// Интерфейс - определяет контракт
public interface PaymentProcessor {
    void processPayment(double amount);
    void refund(double amount);
    boolean isAvailable();
}

// Абстрактный класс - частичная реализация
public abstract class BasePaymentProcessor implements PaymentProcessor {
    protected double fee = 0.02;  // 2% комиссия
    
    public double calculateAmount(double amount) {
        return amount + (amount * fee);
    }
    
    @Override
    public boolean isAvailable() {
        return true;  // По умолчанию доступно
    }
}

// Конкретная реализация
public class CreditCardProcessor extends BasePaymentProcessor {
    @Override
    public void processPayment(double amount) {
        double finalAmount = calculateAmount(amount);
        System.out.println("Processing credit card payment: " + finalAmount);
        // Логика обработки
    }
    
    @Override
    public void refund(double amount) {
        System.out.println("Refunding to credit card: " + amount);
        // Логика возврата
    }
}

// Использование - видим только интерфейс
PaymentProcessor processor = new CreditCardProcessor();
processor.processPayment(100);  // Не видим сложность внутри
processor.refund(100);

Практическое применение: Real-world пример

// 1. ИНКАПСУЛЯЦИЯ
public class User {
    private String email;
    private String passwordHash;
    
    public void setEmail(String email) {
        if (email.contains("@")) {  // Валидация
            this.email = email;
        }
    }
}

// 2. НАСЛЕДОВАНИЕ
public abstract class BaseService {
    protected DatabaseConnection db;
    
    public BaseService(DatabaseConnection db) {
        this.db = db;
    }
}

public class UserService extends BaseService {
    public User findById(Long id) {
        return db.query("SELECT * FROM users WHERE id = ?", id);
    }
}

// 3. ПОЛИМОРФИЗМ
public interface Logger {
    void log(String message);
}

public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println(message);
    }
}

public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        writeToFile(message);
    }
}

public class Service {
    private Logger logger;  // Полиморфный тип
    
    public Service(Logger logger) {
        this.logger = logger;  // Может быть ConsoleLogger или FileLogger
    }
    
    public void doSomething() {
        logger.log("Action performed");  // Вызовется нужный log()
    }
}

// 4. АБСТРАКЦИЯ
public interface PaymentService {
    void charge(double amount);
}

public class Order {
    private PaymentService paymentService;  // Видим только интерфейс
    
    public void checkout(double total) {
        paymentService.charge(total);  // Не знаем как внутри обрабатывается
    }
}

SOLID принципы (расширение ООП)

// S - Single Responsibility
public class UserRepository {  // Только работа с БД
    public User save(User user) { }
}

public class UserValidator {   // Только валидация
    public boolean isValid(User user) { }
}

// O - Open/Closed
public interface ReportGenerator {
    void generate();  // Открыто для расширения
}

// L - Liskov Substitution
List<PaymentProcessor> processors = Arrays.asList(
    new CreditCardProcessor(),
    new PayPalProcessor(),
    new StripeProcessor()
);  // Все могут быть использованы взаимозаменяемо

// I - Interface Segregation
public interface Drawable {
    void draw();
}
public interface Resizable {
    void resize();
}
// Вместо одного большого интерфейса

// D - Dependency Inversion
public class OrderService {
    private final PaymentProcessor processor;  // Зависит от абстракции
    
    public OrderService(PaymentProcessor processor) {  // Инъекция
        this.processor = processor;
    }
}

Выводы

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

1. ✓ Инкапсуляция - скрытие деталей
2. ✓ Наследование - переиспользование кода
3. ✓ Полиморфизм - разное поведение одного интерфейса
4. ✓ Абстракция - работа с интерфейсом, не реализацией

Применение в Java:

• public/private/protected модификаторы
• extends для наследования
• implements для интерфейсов
• @Override для переопределения
• abstract классы и методы

Правило: Правильное применение этих концепций делает код более гибким, понятным и поддерживаемым!