В чем разница между процедурным программированием и ООП?

Разница между процедурным программированием и ООП

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

Процедурное программирование

Основной принцип: Программа — это последовательность процедур (функций) и данных.

// Процедурный подход
public class AccountProcessor {
    
    public void transferMoney(double[] sourceBalance, 
                              double[] targetBalance, 
                              int sourceId, 
                              int targetId, 
                              double amount) {
        // Проверка баланса
        if (sourceBalance[sourceId] >= amount) {
            sourceBalance[sourceId] -= amount;
            targetBalance[targetId] += amount;
            printTransaction(sourceId, targetId, amount);
        } else {
            printError("Insufficient funds");
        }
    }
    
    public void printTransaction(int from, int to, double amount) { ... }
    public void printError(String msg) { ... }
}

Характеристики процедурного подхода:

• Данные и функции разделены
• Функции получают данные, обрабатывают и возвращают результаты
• Программа читается как последовательность операций
• Глобальное состояние часто мутирует
• Сложнее с масштабированием больших проектов

Примеры языков: C, Pascal, процедурный стиль Python/Java

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

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

// ООП подход
public class Account {
    private double balance;
    private String accountHolder;
    private int accountId;
    
    public Account(int accountId, String holder, double initialBalance) {
        this.accountId = accountId;
        this.accountHolder = holder;
        this.balance = initialBalance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            logTransaction("DEPOSIT", amount);
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            logTransaction("WITHDRAW", amount);
            return true;
        }
        return false;
    }
    
    public void transferTo(Account target, double amount) {
        if (this.withdraw(amount)) {
            target.deposit(amount);
        }
    }
    
    private void logTransaction(String type, double amount) { ... }
    public double getBalance() { return balance; }
}

Использование:

Account source = new Account(1, "John", 1000);
Account target = new Account(2, "Jane", 500);
source.transferTo(target, 100);

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

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

Данные скрыты внутри объекта, доступ через методы:

public class Account {
    private double balance;  // Скрыто
    
    public double getBalance() {  // Контролируемый доступ
        return balance;
    }
    
    public void setBalance(double newBalance) {
        if (newBalance >= 0) {
            balance = newBalance;  // Валидация
        }
    }
}

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

Разные типы счётов могут наследовать базовый функционал:

public class SavingsAccount extends Account {
    private double interestRate;
    
    public void applyInterest() {
        double interest = getBalance() * interestRate;
        this.deposit(interest);
    }
}

public class CheckingAccount extends Account {
    private double overdraftLimit;
    
    @Override
    public boolean withdraw(double amount) {
        if (amount <= getBalance() + overdraftLimit) {
            return super.withdraw(amount);
        }
        return false;
    }
}

3. Полиморфизм

Разные типы объектов обрабатываются единообразно:

List<Account> accounts = new ArrayList<>();
accounts.add(new SavingsAccount(...));
accounts.add(new CheckingAccount(...));
accounts.add(new Account(...));

// Полиморфный вызов
for (Account account : accounts) {
    account.deposit(100);  // Вызовет нужный метод для каждого типа
}

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

Скрытие сложности за простыми интерфейсами:

public interface PaymentProcessor {
    boolean processPayment(double amount);
    String getStatus();
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public boolean processPayment(double amount) {
        // Сложная логика работы с банком
        return callBankAPI(amount);
    }
}

Прямое сравнение

Структура данных — Процедурный подход:

// Функции отделены от данных
public class DataStore {
    public static double[] salaries = new double[100];
    public static String[] names = new String[100];
}

public class SalaryProcessor {
    public static void giveRaise(int employeeId, double percent) {
        DataStore.salaries[employeeId] *= (1 + percent);
    }
    
    public static void printPayroll() {
        for (int i = 0; i < DataStore.salaries.length; i++) {
            System.out.println(DataStore.names[i] + ": " + 
                             DataStore.salaries[i]);
        }
    }
}

Структура данных — ООП подход:

public class Employee {
    private String name;
    private double salary;
    
    public void giveRaise(double percent) {
        salary *= (1 + percent);
    }
    
    @Override
    public String toString() {
        return name + ": " + salary;
    }
}

// Использование
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("John", 50000));
employees.forEach(e -> e.giveRaise(0.1));
employees.forEach(System.out::println);

Основные преимущества ООП

1. Модульность и переиспользуемость

Объекты можно переиспользовать в разных частях программы:

Account bankAccount = new Account(...);
Account cryptoWallet = new CryptoAccount(...);
Account investmentAccount = new InvestmentAccount(...);
// Все наследуют базовый функционал Account

2. Легче поддерживать и расширять

Чтобы добавить новый тип счёта, просто создаёте новый класс:

public class BusinessAccount extends Account { ... }

Осталась часть кода не изменится.

3. Лучше отражает реальный мир

Объекты соответствуют концепциям предметной области (Account, Employee, Product).

4. Управление состоянием

Объект отвечает за своё состояние, минимизирует баги от глобального состояния.

Недостатки ООП

• Может быть overkill для небольших скриптов
• Требует больше планирования архитектуры
• Кривая обучения круче, чем процедурный подход

Вывод

ОООП — это парадигма, которая доминирует в современной разработке, особенно в Java. Она лучше масштабируется и поддерживается, чем чистый процедурный подход. Однако даже в ООП коде можно писать плохой код. Ключ — применять принципы SOLID, чистую архитектуру и KISS.

Для Java разработчика глубокое понимание ООП и его принципов — это основа профессионализма.