В чем разница между функциональным и объектно-ориентированным подходом?

Разница между функциональным и объектно-ориентированным подходом

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

Объектно-ориентированный подход (OOP)

ОБП строится вокруг концепции объектов - сущностей, которые содержат данные (состояние) и методы (поведение).

Основные принципы OOP:

• Инкапсуляция: состояние скрыто внутри объекта
• Наследование: классы наследуют свойства и методы
• Полиморфизм: разные объекты одного типа могут вести себя по-разному
• Абстракция: скрывание деталей реализации

// OOP подход
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;
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
        }
    }
    
    public double getBalance() {
        return balance;
    }
}

// Использование
BankAccount account = new BankAccount("123456", 1000);
account.deposit(500);
account.withdraw(200);
System.out.println(account.getBalance());

Особенности:

• Состояние (balance) изменяется со временем
• Объект содержит и состояние, и поведение
• Инкапсуляция скрывает внутренние детали

Функциональный подход (FP)

Функциональное программирование строится на концепции функций как первоклассных объектов и избегает изменяемого состояния (immutability).

Основные принципы FP:

• Функции как первоклассные значения
• Неизменяемость: данные не меняются
• Чистые функции: нет побочных эффектов
• Композиция функций

// FP подход
record BankAccount(String accountNumber, double balance) {}

// Функции для работы с аккаунтом (чистые функции)
class BankOperations {
    static BankAccount deposit(BankAccount account, double amount) {
        if (amount > 0) {
            return new BankAccount(account.accountNumber(), 
                                 account.balance() + amount);
        }
        return account;
    }
    
    static BankAccount withdraw(BankAccount account, double amount) {
        if (amount > 0 && account.balance() >= amount) {
            return new BankAccount(account.accountNumber(), 
                                 account.balance() - amount);
        }
        return account;
    }
}

// Использование
BankAccount account = new BankAccount("123456", 1000);
account = BankOperations.deposit(account, 500);
account = BankOperations.withdraw(account, 200);
System.out.println(account.balance());

Особенности:

• Состояние неизменяемо
• Функции не имеют побочных эффектов
• Каждая операция возвращает новый объект
• Легче тестировать и предсказать поведение

Сравнительная таблица

Практический пример: обработка списка

OOP подход:

public class UserProcessor {
    private List<User> users = new ArrayList<>();
    
    public void addUser(User user) {
        users.add(user);
    }
    
    public void filterAdults() {
        users.removeIf(user -> user.getAge() < 18);
    }
    
    public void printUsers() {
        for (User user : users) {
            System.out.println(user.getName());
        }
    }
}

// Использование
UserProcessor processor = new UserProcessor();
processor.addUser(new User("Alice", 25));
processor.addUser(new User("Bob", 17));
processor.filterAdults();
processor.printUsers();

Функциональный подход:

// Чистые функции
class UserFunctions {
    static List<User> filterAdults(List<User> users) {
        return users.stream()
                   .filter(user -> user.getAge() >= 18)
                   .toList();
    }
    
    static void printUsers(List<User> users) {
        users.forEach(user -> System.out.println(user.getName()));
    }
}

// Использование (композиция функций)
List<User> allUsers = Arrays.asList(
    new User("Alice", 25),
    new User("Bob", 17)
);

List<User> adults = UserFunctions.filterAdults(allUsers);
UserFunctions.printUsers(adults);

Java 8+ Streams API - синтез подходов

Java попытался объединить оба подхода с Stream API:

List<String> names = users.stream()
    .filter(user -> user.getAge() >= 18)
    .map(User::getName)
    .filter(name -> name.startsWith("A"))
    .toList();

Это функциональный стиль, но с ООП синтаксисом.

Lambda выражения в Java

// Lambda - функция как первоклассный объект
Function<Integer, Integer> square = x -> x * x;
System.out.println(square.apply(5));  // 25

// Прохождение функции как параметра
List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
List<Integer> squared = numbers.stream()
    .map(square)
    .toList();

Когда использовать какой подход

Используйте OOP когда:

• Нужна сложная иерархия объектов
• Объекты имеют сложное состояние
• Нужна инкапсуляция и скрытие деталей
• Работаете с доменными моделями

Используйте Функциональный подход когда:

• Нужна обработка и трансформация данных
• Критична надежность и testability
• Нужен параллелизм и многопоточность
• Работаете с потоками данных (Stream)
• Нужна композиция простых операций

Современный Java

Современный Java поддерживает оба подхода и позволяет их комбинировать:

// Комбинированный подход
public class UserService {
    private final UserRepository repository;  // OOP
    
    public List<String> getAdultUserNames(int minAge) {
        return repository.findAll().stream()  // FP
            .filter(user -> user.getAge() >= minAge)
            .map(User::getName)
            .sorted()
            .toList();
    }
}

Вывод

Оббективно-ориентированный и функциональный подходы решают разные проблемы. OOP лучше для моделирования сложных доменов, FP лучше для обработки данных и параллельных вычислений. Современный Java позволяет использовать оба подхода, выбирая наиболее подходящий для каждой ситуации. Хороший разработчик должен понимать оба подхода и применять их комбинированно.