Как изменить сигнатуру класса с интерфейсом для использования полиморфизма

Полиморфизм и работа с интерфейсами

Основной принцип: программирование под интерфейс

Индекс чувствителен к реализации, программируй для интерфейса, а не для конкретного класса.

// ПЛОХО: зависимость от конкретного класса
public class PaymentProcessor {
    public void processPayment() {
        CreditCardPayment payment = new CreditCardPayment();
        payment.pay(100);
    }
}

// Проблемы:
// - Если добавить PayPalPayment, нужно менять код ProcessPaymentProcessor
// - Сложно тестировать (нельзя подменить реальный платёж)
// - Нарушение принципа Open/Closed из SOLID

Решение: Используй интерфейс

// 1. Определяем интерфейс
public interface Payment {
    void pay(double amount);
    boolean isSuccessful();
}

// 2. Разные реализации
public class CreditCardPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Оплата картой: " + amount);
    }
    
    @Override
    public boolean isSuccessful() {
        return true;
    }
}

public class PayPalPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Оплата PayPal: " + amount);
    }
    
    @Override
    public boolean isSuccessful() {
        return true;
    }
}

public class BitcoinPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Оплата Bitcoin: " + amount);
    }
    
    @Override
    public boolean isSuccessful() {
        return true;
    }
}

// 3. Код работает с интерфейсом, не с реализацией
public class PaymentProcessor {
    private Payment payment;  // интерфейс!
    
    public PaymentProcessor(Payment payment) {
        this.payment = payment;  // инъекция зависимости
    }
    
    public void processPayment(double amount) {
        payment.pay(amount);
        if (payment.isSuccessful()) {
            System.out.println("Оплата успешна");
        }
    }
}

// 4. Использование
Payment creditCard = new CreditCardPayment();
PaymentProcessor processor1 = new PaymentProcessor(creditCard);
processor1.processPayment(100);

Payment paypal = new PayPalPayment();
PaymentProcessor processor2 = new PaymentProcessor(paypal);
processor2.processPayment(50);

Payment bitcoin = new BitcoinPayment();
PaymentProcessor processor3 = new PaymentProcessor(bitcoin);
processor3.processPayment(75);

Изменение сигнатуры для полиморфизма

Правило 1: Параметры методов — интерфейсы

// ПЛОХО: конкретный класс
public void saveUser(PostgresqlUser user) { }
public void sendEmail(GmailSender sender) { }

// ХОРОШО: интерфейсы
public interface UserRepository {
    void save(User user);
}

public interface EmailSender {
    void send(String to, String subject, String body);
}

public class UserService {
    private UserRepository repository;
    private EmailSender emailSender;
    
    public UserService(UserRepository repository, EmailSender emailSender) {
        this.repository = repository;
        this.emailSender = emailSender;
    }
    
    public void registerUser(String email, String password) {
        User user = new User(email, password);
        repository.save(user);  // работает с любой реализацией
        emailSender.send(email, "Welcome", "Account created");  // любой sender
    }
}

// Реализации
public class PostgresUserRepository implements UserRepository {
    @Override
    public void save(User user) {
        // SQL запрос в PostgreSQL
    }
}

public class MongoUserRepository implements UserRepository {
    @Override
    public void save(User user) {
        // Сохранение в MongoDB
    }
}

public class GmailSender implements EmailSender {
    @Override
    public void send(String to, String subject, String body) {
        // Отправка через Gmail API
    }
}

public class SendGridSender implements EmailSender {
    @Override
    public void send(String to, String subject, String body) {
        // Отправка через SendGrid
    }
}

Правило 2: Возвращаемые типы — интерфейсы

// ПЛОХО: конкретный класс
public ArrayList<User> getUsers() { }

// ХОРОШО: интерфейс Collection
public Collection<User> getUsers() {
    return new ArrayList<>();
    // или можно вернуть List, Set, etc.
}

// ЕЩЁ ЛУЧШЕ: List
public List<User> getUsers() {
    return new ArrayList<>();
}

// Преимущества:
// - Клиент не знает о реализации
// - Можно поменять ArrayList на LinkedList без изменения сигнатуры

Правило 3: Поля класса — интерфейсы

// ПЛОХО
public class OrderService {
    private PostgresqlOrderRepository repo;
    private SmtpEmailSender sender;
}

// ХОРОШО
public class OrderService {
    private OrderRepository repository;  // интерфейс
    private EmailSender emailSender;     // интерфейс
    
    // Dependency Injection через constructor
    public OrderService(OrderRepository repository, EmailSender emailSender) {
        this.repository = repository;
        this.emailSender = emailSender;
    }
}

Пример: Логирование

// Интерфейс
public interface Logger {
    void log(String message);
    void error(String message);
}

// Реализации
public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("[LOG] " + message);
    }
    
    @Override
    public void error(String message) {
        System.err.println("[ERROR] " + message);
    }
}

public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        Files.writeString(Path.of("app.log"), message);
    }
    
    @Override
    public void error(String message) {
        Files.writeString(Path.of("error.log"), message);
    }
}

public class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        database.insert("logs", message);
    }
    
    @Override
    public void error(String message) {
        database.insert("errors", message);
    }
}

// Использование
public class Application {
    private Logger logger;
    
    public Application(Logger logger) {
        this.logger = logger;  // любой Logger!
    }
    
    public void run() {
        logger.log("Приложение стартует");
        try {
            // код
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }
}

// В разных контекстах используем разные реализации
// Dev: new Application(new ConsoleLogger());
// Prod: new Application(new DatabaseLogger());
// Tests: new Application(new MockLogger());

Factory Pattern для создания объектов

// Интерфейс для фабрики
public interface PaymentFactory {
    Payment createPayment(String type);
}

public class DefaultPaymentFactory implements PaymentFactory {
    @Override
    public Payment createPayment(String type) {
        return switch(type) {
            case "credit_card" -> new CreditCardPayment();
            case "paypal" -> new PayPalPayment();
            case "bitcoin" -> new BitcoinPayment();
            default -> throw new IllegalArgumentException("Unknown type");
        };
    }
}

// Использование
public class PaymentService {
    private PaymentFactory factory;
    
    public PaymentService(PaymentFactory factory) {
        this.factory = factory;
    }
    
    public void processPayment(String type, double amount) {
        Payment payment = factory.createPayment(type);
        payment.pay(amount);
    }
}

Тестирование с полиморфизмом

// Mock реализация для тестов
public class MockPayment implements Payment {
    private double lastAmount = 0;
    private boolean shouldFail = false;
    
    @Override
    public void pay(double amount) {
        this.lastAmount = amount;
    }
    
    @Override
    public boolean isSuccessful() {
        return !shouldFail;
    }
    
    public double getLastAmount() { return lastAmount; }
}

// Тест
@Test
public void testPaymentProcessing() {
    MockPayment mockPayment = new MockPayment();
    PaymentProcessor processor = new PaymentProcessor(mockPayment);
    
    processor.processPayment(100);
    
    assertEquals(100, mockPayment.getLastAmount());
}

Выводы

1. Всегда программируй под интерфейс, не под реализацию
2. Используй интерфейсы в:
   • Параметрах методов
   • Возвращаемых типах
   • Полях класса
3. Dependency Injection через конструктор
4. Это позволяет:
   • Легко менять реализацию
   • Тестировать с Mock объектами
   • Соблюдать принципы SOLID
   • Масштабировать систему