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

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

Интерфейс — это контракт (договор), который определяет набор методов, которые должен реализовать любой класс, объявивший его реализацию. Это один из ключевых механизмов в Java для достижения абстракции, полиморфизма и слабой связанности (loose coupling).

Базовое определение

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

// Определение интерфейса
public interface Animal {
    void makeSound();  // Абстрактный метод
    void move();       // Абстрактный метод
    
    // Константа (по умолчанию public static final)
    String KINGDOM = "Animalia";
}

// Реализация интерфейса
public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
    
    @Override
    public void move() {
        System.out.println("Running on four legs");
    }
}

Ключевые свойства интерфейсов

1. Множественная реализация

Класс может реализовать несколько интерфейсов, в отличие от наследования классов:

public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

// Один класс может реализовать оба интерфейса
public class Duck implements Animal, Flyable, Swimmable {
    @Override
    public void makeSound() {
        System.out.println("Quack!");
    }
    
    @Override
    public void move() {
        System.out.println("Waddling");
    }
    
    @Override
    public void fly() {
        System.out.println("Flying high");
    }
    
    @Override
    public void swim() {
        System.out.println("Swimming in pond");
    }
}

2. Полиморфизм через интерфейсы

Это позволяет писать flexible код, который работает с объектами через интерфейс, а не конкретный класс:

public class AnimalOrchestra {
    public static void performConcert(List<Animal> animals) {
        for (Animal animal : animals) {
            animal.makeSound();  // Полиморфный вызов
            animal.move();
        }
    }
    
    public static void main(String[] args) {
        List<Animal> orchestra = new ArrayList<>();
        orchestra.add(new Dog());
        orchestra.add(new Cat());
        orchestra.add(new Duck());
        
        performConcert(orchestra);  // Работает с любыми реализациями Animal
    }
}

Эволюция интерфейсов (Java 8+)

Default методы (Java 8)

С Java 8 интерфейсы могут содержать реализованные методы с ключевым словом default:

public interface Animal {
    void makeSound();
    
    // Default метод с реализацией
    default void sleep() {
        System.out.println("Zzz... sleeping");
    }
}

// Класс может не переопределять default метод
public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
    // sleep() наследуется из интерфейса
}

Почему это важно: Позволяет добавлять новые методы в интерфейсы без нарушения backward compatibility.

Static методы (Java 8)

public interface PaymentProcessor {
    void processPayment(double amount);
    
    // Static метод
    static PaymentProcessor createDefault() {
        return new DefaultPaymentProcessor();
    }
}

Private методы (Java 9)

public interface DataProcessor {
    void process();
    
    // Private метод для переиспользования в default методах
    private void validateData() {
        System.out.println("Validating...");
    }
    
    default void processWithValidation() {
        validateData();
        process();
    }
}

Практические примеры использования

Пример 1: Strategy Pattern

// Интерфейс определяет контракт для различных стратегий
public interface PaymentStrategy {
    void pay(double amount);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " via Credit Card");
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying " + amount + " via PayPal");
    }
}

public class CheckoutService {
    private PaymentStrategy strategy;
    
    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void checkout(double amount) {
        strategy.pay(amount);
    }
}

Пример 2: Dependency Injection

// Интерфейс как контракт
public interface UserRepository {
    User findById(Long id);
    void save(User user);
}

// Различные реализации
public class DatabaseUserRepository implements UserRepository {
    @Override
    public User findById(Long id) {
        // Запрос в БД
        return null;
    }
    
    @Override
    public void save(User user) {
        // Сохранение в БД
    }
}

public class MockUserRepository implements UserRepository {
    @Override
    public User findById(Long id) {
        // Mock данные для тестов
        return new User();
    }
    
    @Override
    public void save(User user) {
        // Mock сохранение
    }
}

@Service
public class UserService {
    private final UserRepository repository;
    
    // Инъекция через конструктор
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

Пример 3: Functional Interface (для lambdas)

// Functional interface с одним абстрактным методом
@FunctionalInterface
public interface Validator<T> {
    boolean isValid(T value);
}

// Использование с lambda выражениями
public class ValidationService {
    public static void main(String[] args) {
        Validator<String> emailValidator = email -> email.contains("@");
        Validator<Integer> ageValidator = age -> age >= 18;
        
        System.out.println(emailValidator.isValid("test@example.com")); // true
        System.out.println(ageValidator.isValid(25)); // true
    }
}

Интерфейсы vs Абстрактные классы

// Абстрактный класс для общей функциональности
public abstract class Vehicle {
    protected String brand;
    
    public Vehicle(String brand) {
        this.brand = brand;
    }
    
    abstract void drive();
    
    public void showBrand() {
        System.out.println("Brand: " + brand);
    }
}

// Интерфейс для контракта
public interface Refuelable {
    void refuel();
}

public class Car extends Vehicle implements Refuelable {
    public Car(String brand) {
        super(brand);
    }
    
    @Override
    void drive() {
        System.out.println("Driving car");
    }
    
    @Override
    public void refuel() {
        System.out.println("Refueling with petrol");
    }
}

Best Practices

1. Используй интерфейсы для контрактов — определяй поведение через интерфейсы
2. Программируй к интерфейсу, не к реализации — это ключ к гибкому коду
3. Keep интерфейсы простыми — one responsibility
4. Используй functional interfaces когда нужно одно действие
5. Default методы осторожно — не усложняй интерфейс

Заключение

Интерфейсы — это фундаментальный инструмент объектно-ориентированного программирования в Java. Они позволяют строить расширяемый, тестируемый и слабо связанный код. Глубокое понимание интерфейсов критично для написания хорошей архитектуры и применения design patterns.