What is the difference between a functional approach and an object-oriented approach?

The functional approach focuses on computations as evaluations of mathematical functions, avoiding state changes and mutable data. The object-oriented approach focuses on objects, which are instances of classes containing data (properties) and behavior (methods) that interact with each other.

Key differences:

• State: Functional programming aims for immutable data and absence of side effects. OOP often involves changing the state of objects.
• Central concept: In functional programming, it is functions. In OOP - objects.
• Mutability of data: Functional programming encourages the use of immutable data structures. In OOP, data within objects can be mutable.
• Parallelism: Functional programming is often easier to parallelize due to the absence of mutable state and side effects. In OOP, parallelism can be more complex due to the need for synchronization when accessing mutable data.
• Abstraction: In functional programming, abstraction is achieved through higher-order functions and function composition. In OOP - through classes, interfaces, inheritance, polymorphism.

Example:

Functional approach (Java 8+):

// Example of using Stream API to transform a list
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squaredNumbers = numbers.stream()
                                     .map(n -> n * n) // Immutable transformation
                                     .collect(Collectors.toList());

// Using a function
Function<Integer, Integer> square = x -> x * x;
int result = square.apply(5);

Object-oriented approach:

// Example of a class with state and a method
class Counter {
    private int count = 0; // State

    public void increment() {
        count++; // Changes state
    }

    public int getCount() {
        return count;
    }
}

// Using an object
Counter myCounter = new Counter();
myCounter.increment();
int currentValue = myCounter.getCount();

Comparison table:

Attribute	Functional approach	Object-oriented approach
Central idea	Functions	Objects
State	Avoidance of mutable state	State is part of the object
Data	Preference for immutable data	Data can be mutable
Side effects	Minimization or absence	Can be present
Parallelism	Easier to implement	Requires additional synchronization
Abstraction	Higher-order functions, function composition	Classes, interfaces, inheritance, polymorphism

In Java, a combined approach is often used, utilizing elements of both styles.