Что такое абстракция?

Абстракция в Java

Абстракция — это один из четырёх основных принципов объектно-ориентированного программирования (ООП). Это процесс скрытия сложных внутренних деталей реализации и предоставления только необходимого интерфейса пользователю.

Что такое абстракция

Абстракция позволяет вам работать с объектами на высоком уровне, не зная о деталях их реализации. Это как использование автомобиля: вы нажимаете на педаль газа, и машина едет, но вам не нужно знать, как работает двигатель внутри.

Два способа реализации абстракции в Java

1. Абстрактные классы (abstract class)

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

public abstract class Animal {
    // Абстрактный метод (без реализации)
    public abstract void makeSound();
    
    // Конкретный метод (с реализацией)
    public void sleep() {
        System.out.println("Animal is sleeping");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof woof!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

// Использование
public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound();  // Выведет: Woof woof!
        dog.sleep();      // Выведет: Animal is sleeping
        
        Animal cat = new Cat();
        cat.makeSound();  // Выведет: Meow!
    }
}

2. Интерфейсы (interface)

Интерфейс — это контракт, который определяет, какие методы должны быть реализованы. Интерфейс полностью абстрактен (все методы абстрактные).

public interface Drawable {
    void draw();
    void erase();
}

public interface Movable {
    void move(int x, int y);
}

public class Circle implements Drawable, Movable {
    private int x, y, radius;
    
    @Override
    public void draw() {
        System.out.println("Drawing circle at (" + x + ", " + y + ")");
    }
    
    @Override
    public void erase() {
        System.out.println("Erasing circle");
    }
    
    @Override
    public void move(int newX, int newY) {
        this.x = newX;
        this.y = newY;
        System.out.println("Circle moved to (" + newX + ", " + newY + ")");
    }
}

// Использование
public class GraphicsApp {
    public static void main(String[] args) {
        Drawable shape = new Circle();
        shape.draw();   // Выведет: Drawing circle at (0, 0)
        shape.erase();  // Выведет: Erasing circle
        
        Movable movable = (Movable) shape;
        movable.move(50, 100);  // Выведет: Circle moved to (50, 100)
    }
}

Практический пример: База данных

// Определяем абстрактный интерфейс
public interface DatabaseConnection {
    void connect();
    void disconnect();
    void executeQuery(String query);
}

// Реализация для MySQL
public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to MySQL database...");
    }
    
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from MySQL");
    }
    
    @Override
    public void executeQuery(String query) {
        System.out.println("Executing MySQL query: " + query);
    }
}

// Реализация для PostgreSQL
public class PostgreSQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to PostgreSQL database...");
    }
    
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from PostgreSQL");
    }
    
    @Override
    public void executeQuery(String query) {
        System.out.println("Executing PostgreSQL query: " + query);
    }
}

// Код приложения работает с абстрактным интерфейсом
public class UserRepository {
    private DatabaseConnection db;
    
    public UserRepository(DatabaseConnection database) {
        this.db = database;  // Можно передать любую реализацию
    }
    
    public void getUser(int id) {
        db.connect();
        db.executeQuery("SELECT * FROM users WHERE id = " + id);
        db.disconnect();
    }
}

// Использование
public class Application {
    public static void main(String[] args) {
        // Работает с MySQL
        DatabaseConnection mysqlDb = new MySQLConnection();
        UserRepository repo1 = new UserRepository(mysqlDb);
        repo1.getUser(1);
        
        // Легко переключиться на PostgreSQL, не меняя UserRepository
        DatabaseConnection postgresDb = new PostgreSQLConnection();
        UserRepository repo2 = new UserRepository(postgresDb);
        repo2.getUser(1);
    }
}

Преимущества абстракции

1. Скрытие сложности — пользователь видит только необходимый интерфейс
2. Переиспользование кода — абстрактные определения могут быть реализованы по-разному
3. Слабая связанность — код зависит от интерфейсов, а не от конкретных реализаций
4. Легче расширять — можно добавлять новые реализации без изменения существующего кода
5. Тестируемость — легче создавать mock-объекты для тестирования

abstract класс vs interface

abstract класс используй когда:

• Классы имеют общую реализацию (не только сигнатуры)
• Нужны protected или private члены
• Переменные не должны быть final
• Нужны конструкторы

interface используй когда:

• Определяешь контракт без реализации
• Несвязанные классы должны реализовать интерфейс
• Нужна множественная реализация

Реальный пример из Spring Framework

// Spring использует абстракцию везде
public interface UserService {
    User getUserById(Long id);
    User saveUser(User user);
    void deleteUser(Long id);
}

public class UserServiceImpl implements UserService {
    // Реализация
}

// Контроллер работает с интерфейсом
@RestController
public class UserController {
    @Autowired
    private UserService userService;  // Абстрация
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

Вывод

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