Как бы выглядела абстракция на уровне владения одного класса другими

# Абстракция на уровне владения одного класса другими

Абстракция владения классов (ownership) — это паттерн проектирования, определяющий отношения между объектами и управление их жизненным циклом. В Java это реализуется через несколько ключевых принципов.

Основные концепции

1. Композиция и Агрегация

Когда один класс содержит экземпляры других классов, мы создаём отношение владения:

public class Car {
    private Engine engine;  // Car владеет Engine
    private List<Wheel> wheels;  // Car владеет Wheel
    
    public Car() {
        this.engine = new Engine();  // Car создаёт и управляет Engine
        this.wheels = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            wheels.add(new Wheel());
        }
    }
}

В этом примере Car полностью владеет Engine и Wheel. Это значит:

• Car отвечает за создание этих объектов
• Car отвечает за их уничтожение
• Время жизни Engine и Wheel = время жизни Car

2. Делегирование и Интерфейсы

Абстракция на уровне владения достигается через интерфейсы:

public interface PowerSource {
    void start();
    void stop();
    int getPower();
}

public class Car {
    private PowerSource engine;  // Зависимость от интерфейса
    
    public Car(PowerSource engine) {
        this.engine = engine;  // Инъекция зависимости
    }
    
    public void start() {
        engine.start();
    }
}

public class ElectricEngine implements PowerSource {
    @Override
    public void start() { }
}

Car не знает о конкретной реализации двигателя, только об интерфейсе.

3. Инкапсуляция Владения

public class Database {
    private Connection connection;  // приватное владение
    private List<Statement> statements = new ArrayList<>();
    
    public Database(String url) throws SQLException {
        this.connection = DriverManager.getConnection(url);
    }
    
    public void closeAll() {
        statements.forEach(stmt -> {
            try {
                stmt.close();
            } catch (SQLException e) {
                // логирование
            }
        });
        try {
            connection.close();
        } catch (SQLException e) {
            // логирование
        }
    }
}

Database инкапсулирует управление ресурсами и скрывает детали владения от внешнего мира.

4. Try-with-Resources для Автоматического Управления

public class FileProcessor {
    public void processFile(String path) {
        try (FileInputStream fis = new FileInputStream(path);
             BufferedInputStream bis = new BufferedInputStream(fis)) {
            // обработка файла
        } catch (IOException e) {
            // обработка ошибок
        }
    }
}

Паттерны Управления Владением

Исключительное Владение

Только один объект может владеть ресурсом:

public class Logger {
    private PrintWriter writer;  // исключительное владение
    
    public Logger(String fileName) throws FileNotFoundException {
        writer = new PrintWriter(new FileWriter(fileName));
    }
    
    public void close() {
        if (writer != null) {
            writer.close();
        }
    }
}

Совместное Владение

Несколько объектов могут ссылаться на один ресурс:

public class CachedData {
    private SharedResource resource;
    
    public CachedData(SharedResource resource) {
        this.resource = resource;  // ссылка на общий ресурс
    }
}

Иерархическое Владение

public class Company {
    private List<Department> departments;
    
    public class Department {
        private List<Employee> employees;
        
        public Department() {
            this.employees = new ArrayList<>();
        }
    }
    
    public Company() {
        this.departments = new ArrayList<>();
    }
}

Company владеет Department, Department владеет Employee.

Лучшие Практики

1. Явное управление жизненным циклом
2. Инъекция зависимостей
3. Интерфейсы вместо реализаций
4. Try-with-resources для автоматизации
5. Single Responsibility Principle

Абстракция владения позволяет создавать чистый, понятный и легко тестируемый код.