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

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

ООП — это парадигма программирования, основанная на концепции "объектов", которые содержат данные (атрибуты) и методы (функции). ООП позволяет организовать код в логические единицы, облегчить его переиспользование, поддержку и масштабирование.

Основные принципы ООП

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("Deposited: " + amount);
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: " + amount);
            return true;
        }
        return false;
    }
    
    public double getBalance() {
        return balance;
    }
}

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

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

Передача свойств от родительского класса к дочерним:

public class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating");
    }
    
    public String getName() {
        return name;
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    public void bark() {
        System.out.println(getName() + " barks: Woof Woof");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    public void meow() {
        System.out.println(getName() + " meows: Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.eat();
        dog.bark();
        
        Cat cat = new Cat("Whiskers");
        cat.eat();
        cat.meow();
    }
}

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

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

Один интерфейс — множество реализаций. Методы могут иметь одно имя, но разное поведение:

public abstract class Shape {
    public abstract double calculateArea();
    public abstract double calculatePerimeter();
}

public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}

public class Rectangle extends Shape {
    private double width, height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double calculateArea() {
        return width * height;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * (width + height);
    }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = new ArrayList<>();
        shapes.add(new Circle(5));
        shapes.add(new Rectangle(4, 6));
        
        for (Shape shape : shapes) {
            System.out.println("Area: " + shape.calculateArea());
            System.out.println("Perimeter: " + shape.calculatePerimeter());
        }
    }
}

Преимущества: гибкость, расширяемость, принцип подстановки Лисков.

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

Скрытие сложности, предоставление простого интерфейса:

public interface DatabaseConnection {
    void connect();
    void disconnect();
    ResultSet query(String sql);
    void execute(String sql);
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to MySQL...");
    }
    
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from MySQL...");
    }
    
    @Override
    public ResultSet query(String sql) {
        System.out.println("Executing MySQL query: " + sql);
        return null;
    }
    
    @Override
    public void execute(String sql) {
        System.out.println("Executing MySQL statement: " + sql);
    }
}

public class PostgreSQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to PostgreSQL...");
    }
    
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from PostgreSQL...");
    }
    
    @Override
    public ResultSet query(String sql) {
        System.out.println("Executing PostgreSQL query: " + sql);
        return null;
    }
    
    @Override
    public void execute(String sql) {
        System.out.println("Executing PostgreSQL statement: " + sql);
    }
}

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

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

S — Single Responsibility (Одна ответственность)

public class User {
    private String email;
    private String password;
    
    public void setEmail(String email) {
        this.email = email;
    }
}

public class UserValidator {
    public boolean isValidEmail(String email) {
        return email.contains("@") && email.contains(".");
    }
}

public class UserRepository {
    public void save(User user) {
        System.out.println("Saving user: " + user);
    }
}

O — Open/Closed (Открыто для расширения, закрыто для модификации)

public interface PaymentMethod {
    void pay(double amount);
}

public class CreditCard implements PaymentMethod {
    @Override
    public void pay(double amount) {
        System.out.println("Paying with credit card: " + amount);
    }
}

public class PayPal implements PaymentMethod {
    @Override
    public void pay(double amount) {
        System.out.println("Paying with PayPal: " + amount);
    }
}

L — Liskov Substitution (Подстановка Лисков)

public class Bird {
    public void fly() {
        System.out.println("Flying...");
    }
}

public class Sparrow extends Bird {
    @Override
    public void fly() {
        System.out.println("Sparrow is flying...");
    }
}

public class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Penguins cannot fly");
    }
}

Лучше:

public interface Flyable {
    void fly();
}

public class Sparrow implements Flyable {
    @Override
    public void fly() {
        System.out.println("Sparrow is flying...");
    }
}

public class Penguin {
    public void swim() {
        System.out.println("Penguin is swimming...");
    }
}

I — Interface Segregation (Разделение интерфейсов)

public interface Worker {
    void work();
    void eat();
    void sleep();
}

Лучше разделить:

public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

public interface Sleepable {
    void sleep();
}

public class Employee implements Workable, Eatable, Sleepable {
    @Override
    public void work() { }
    
    @Override
    public void eat() { }
    
    @Override
    public void sleep() { }
}

public class Robot implements Workable {
    @Override
    public void work() { }
}

D — Dependency Inversion (Инверсия зависимостей)

public interface DatabaseService {
    void save(String data);
}

public class MySQLService implements DatabaseService {
    @Override
    public void save(String data) {
        System.out.println("Saving to MySQL: " + data);
    }
}

public class UserService {
    private DatabaseService dbService;
    
    public UserService(DatabaseService dbService) {
        this.dbService = dbService;
    }
    
    public void saveUser(String userData) {
        dbService.save(userData);
    }
}

public class Main {
    public static void main(String[] args) {
        DatabaseService db = new MySQLService();
        UserService userService = new UserService(db);
        userService.saveUser("John Doe");
    }
}

Практический пример: E-Commerce система

public class Product {
    private String id;
    private String name;
    private double price;
    
    public Product(String id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }
    
    public double getPrice() {
        return price;
    }
}

public abstract class PaymentProcessor {
    public abstract void process(double amount);
}

public class CreditCardProcessor extends PaymentProcessor {
    @Override
    public void process(double amount) {
        System.out.println("Processing credit card payment: " + amount);
    }
}

public class Order {
    private List<Product> items;
    private PaymentProcessor processor;
    
    public Order(PaymentProcessor processor) {
        this.items = new ArrayList<>();
        this.processor = processor;
    }
    
    public void addProduct(Product product) {
        items.add(product);
    }
    
    public void checkout() {
        double total = items.stream().mapToDouble(Product::getPrice).sum();
        processor.process(total);
    }
}

Выводы

• ООП организует код в объекты с данными и методами
• Инкапсуляция скрывает детали, предоставляя интерфейс
• Наследование переиспользует код
• Полиморфизм позволяет разные реализации одного интерфейса
• Абстракция упрощает использование сложности
• SOLID принципы улучшают дизайн кода
• Java — язык с полной поддержкой ООП

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