Когда лучше использовать интерфейс?

# Когда использовать интерфейсы в Java

Интерфейсы - один из самых важных инструментов объектно-ориентированного программирования. Правильное использование интерфейсов определяет качество архитектуры приложения.

Что такое интерфейс?

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

public interface PaymentGateway {
    PaymentResult charge(PaymentRequest request);
    void refund(String transactionId);
}

1. Абстрагирование зависимостей (Dependency Inversion)

Когда использовать: Когда нужна слабая связанность между компонентами.

// Плохо: зависимость от конкретной реализации
public class OrderService {
    private StripePaymentGateway paymentGateway = new StripePaymentGateway();
    
    public void processOrder(Order order) {
        paymentGateway.charge(order.getAmount());
    }
}

// Хорошо: зависимость от интерфейса
public interface PaymentGateway {
    PaymentResult charge(Money amount);
}

public class OrderService {
    private final PaymentGateway paymentGateway;
    
    public OrderService(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }
    
    public void processOrder(Order order) {
        paymentGateway.charge(order.getAmount());
    }
}

// Теперь можно легко подменить реализацию
public class StripePaymentGateway implements PaymentGateway {
    @Override
    public PaymentResult charge(Money amount) {
        // Stripe-specific logic
    }
}

public class PayPalPaymentGateway implements PaymentGateway {
    @Override
    public PaymentResult charge(Money amount) {
        // PayPal-specific logic
    }
}

Преимущества:

• Легко подменить реализацию
• Легко тестировать (использовать mock-и)
• Слабая связанность

2. Множественная наследуемость поведения

Когда использовать: Когда класс должен иметь несколько "ролей" или поведений.

// Интерфейсы для разных аспектов
public interface Loggable {
    void log(String message);
}

public interface Cacheable {
    Object getCached(String key);
    void cache(String key, Object value);
}

public interface Validatable {
    boolean isValid();
}

// Класс может реализовать все эти интерфейсы
public class UserService implements Loggable, Cacheable, Validatable {
    @Override
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
    
    @Override
    public Object getCached(String key) {
        // Cache logic
    }
    
    @Override
    public boolean isValid() {
        // Validation logic
    }
}

3. Контракт для публичного API

Когда использовать: Когда предоставляешь публичный API или SDK.

// Это часть публичного API
public interface DataRepository {
    <T> Optional<T> findById(Long id);
    <T> List<T> findAll();
    <T> T save(T entity);
    void delete(Long id);
}

// Внутренняя реализация может быть скрыта
// Клиент знает только об интерфейсе
public class JpaDataRepository<T> implements DataRepository {
    // Реализация через JPA
}

public class MongoDataRepository<T> implements DataRepository {
    // Реализация через MongoDB
}

4. Стратегия и Ломаные типы

Когда использовать: Для реализации паттернов Strategy, Factory, Observer и т.д.

Strategy Pattern

// Интерфейс для стратегии
public interface SortingStrategy {
    void sort(List<Integer> list);
}

public class QuickSort implements SortingStrategy {
    @Override
    public void sort(List<Integer> list) {
        // Quick sort implementation
    }
}

public class MergeSort implements SortingStrategy {
    @Override
    public void sort(List<Integer> list) {
        // Merge sort implementation
    }
}

// Использование
public class Sorter {
    private SortingStrategy strategy;
    
    public Sorter(SortingStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void sort(List<Integer> list) {
        strategy.sort(list);
    }
}

Observer Pattern

public interface EventListener {
    void onEvent(Event event);
}

public class LoggingListener implements EventListener {
    @Override
    public void onEvent(Event event) {
        logger.info("Event occurred: " + event);
    }
}

public class NotificationListener implements EventListener {
    @Override
    public void onEvent(Event event) {
        notificationService.send(event.getMessage());
    }
}

public class EventPublisher {
    private List<EventListener> listeners = new ArrayList<>();
    
    public void subscribe(EventListener listener) {
        listeners.add(listener);
    }
    
    public void publish(Event event) {
        listeners.forEach(listener -> listener.onEvent(event));
    }
}

5. Работа с коллекциями

Когда использовать: Для гибкости работы с разными типами коллекций.

// Правильно: работаем с интерфейсом
public List<User> getUsers(Collection<User> users) {
    return users.stream()
        .filter(User::isActive)
        .collect(Collectors.toList());
}

// Неправильно: зависим от конкретного типа
public List<User> getUsers(ArrayList<User> users) {
    // код выше
}

// Использование
List<User> list = new ArrayList<>();
Set<User> set = new HashSet<>();
getUsers(list);  // работает
getUsers(set);   // работает

6. Тестирование с Mock-объектами

Когда использовать: Для написания unit-тестов.

// Сервис зависит от интерфейса
public class EmailService {
    private final SmtpClient client;
    
    public EmailService(SmtpClient client) {
        this.client = client;
    }
    
    public void sendEmail(String email, String message) {
        client.send(email, message);
    }
}

// Интерфейс
public interface SmtpClient {
    void send(String email, String message);
}

// В тестах
@Test
public void testEmailSending() {
    // Mock реализация
    SmtpClient mockClient = mock(SmtpClient.class);
    EmailService service = new EmailService(mockClient);
    
    service.sendEmail("test@example.com", "Hello");
    
    verify(mockClient).send("test@example.com", "Hello");
}

7. Plugin/Extension системы

Когда использовать: Для расширяемых приложений.

public interface Plugin {
    void initialize();
    void execute();
    String getName();
}

public class ReportPlugin implements Plugin {
    @Override
    public void initialize() {
        // Initialize report plugin
    }
    
    @Override
    public void execute() {
        // Generate reports
    }
    
    @Override
    public String getName() {
        return "Report Plugin";
    }
}

public class PluginManager {
    private List<Plugin> plugins = new ArrayList<>();
    
    public void registerPlugin(Plugin plugin) {
        plugins.add(plugin);
    }
    
    public void executeAll() {
        plugins.forEach(plugin -> {
            plugin.initialize();
            plugin.execute();
        });
    }
}

Когда НЕ использовать интерфейсы

// Плохо: интерфейс для одной реализации без причины
public interface UserValidator {
    boolean validate(User user);
}

public class SimpleUserValidator implements UserValidator {
    @Override
    public boolean validate(User user) {
        return user.getEmail() != null;
    }
}

// Лучше: просто класс, если нет необходимости в абстракции
public class UserValidator {
    public boolean validate(User user) {
        return user.getEmail() != null;
    }
}

Java 8+: Default методы в интерфейсах

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

public interface Repository<T> {
    Optional<T> findById(Long id);
    
    // Default метод - может быть переопределен
    default List<T> findAll() {
        throw new UnsupportedOperationException();
    }
    
    // Статический метод
    static <T> Repository<T> create(Class<T> clazz) {
        return new InMemoryRepository<>(clazz);
    }
}

// Реализация может не переопределять findAll()
public class SimpleRepository<T> implements Repository<T> {
    @Override
    public Optional<T> findById(Long id) {
        // Implementation
    }
}

Functional Interface (Java 8+)

Когда использовать: Для функционального программирования.

// Functional interface - ровно один abstract метод
@FunctionalInterface
public interface Transformer<T, R> {
    R transform(T input);
}

// Использование с lambda
Transformer<String, Integer> toInt = str -> Integer.parseInt(str);
Transformer<String, String> upper = String::toUpperCase;

// Встроенные функциональные интерфейсы
Function<String, Integer> function = Integer::parseInt;
Consumer<String> consumer = System.out::println;
Predicate<Integer> predicate = i -> i > 0;
Supplier<String> supplier = () -> "Hello";

Best Practices

1. SOLID принцип (I): Правило разделения интерфейса - интерфейс не должен содержать методы, которые не используются реализацией

// Плохо
public interface Animal {
    void eat();
    void fly();
    void swim();
}

// Хорошо: разделить на специфичные интерфейсы
public interface Eatable {
    void eat();
}

public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

public class Bird implements Flyable, Eatable {
    // Только нужные методы
}

1. Программируй по контракту, не по реализации
2. Один интерфейс - одна ответственность
3. Используй параметризованные интерфейсы (generics)

Интерфейсы - это основа гибкого, тестируемого и масштабируемого кода в Java.