Полиморфизм и принцип низкой связности (low coupling principle) в Java

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

В системе с низкой связанностью каждый компонент можно модифицировать или изменить, не затрагивая остальную часть системы. Это упрощает обслуживание, обновление и тестирование системы по мере ее роста. Кроме того, низкая связанность способствует разработке повторно используемых компонентов, поскольку изменения в одном компоненте не влияют на другие.

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

Вот пример полиморфизма в Java, где создается класс текстового процессора, который может обрабатывать текст по-разному, в зависимости от типа переданного ему объекта

public abstract class TextProcessor {
    public abstract String processText(String text);
}

public class UppercaseTextProcessor extends TextProcessor {
    @Override
    public String processText(String text) {
        return text.toUpperCase();
    }
}

public class LowercaseTextProcessor extends TextProcessor {
    @Override
    public String processText(String text) {
        return text.toLowerCase();
    }
}

public class TextProcessorMain {
    public static void processText(TextProcessor processor, String text) {
        System.out.println(processor.processText(text));
    }

    public static void main(String[] args) {
        processText(new UppercaseTextProcessor(), "Hello World");
        processText(new LowercaseTextProcessor(), "Hello World");
    }
}

Теперь давайте посмотрим как же применить принцип низкой связности к примеру, который мы привели выше:

public interface TextProcessor {
    String processText(String input);
}

public class LowerCaseProcessor implements TextProcessor {
    @Override
    public String processText(String input) {
        return input.toLowerCase();
    }
}

public class UpperCaseProcessor implements TextProcessor {
    @Override
    public String processText(String input) {
        return input.toUpperCase();
    }
}

public class TextProcessorFactory {
    public static TextProcessor getProcessor(String type) {
        switch (type) {
            case "lower" -> return new LowerCaseProcessor();
            case "upper" -> return new UpperCaseProcessor();
            default -> return null;
        }
    }
}

public class TextProcessorMain {
    public static void main(String[] args) {
        TextProcessor lowerProcessor = TextProcessorFactory.getProcessor("lower");
        TextProcessor upperProcessor = TextProcessorFactory.getProcessor("upper");
        System.out.println(lowerProcessor.processText("HELLO"));
        System.out.println(upperProcessor.processText("hello"));
    }
}

В этом примере TextProcessorинтерфейс и его конкретные реализации UpperCaseProcessor и LowerCaseProcessor такие же, как и в предыдущем примере. Класс TextProcessorMainтеперь зависит от TextProcessorFactoryкласса, который используется для создания экземпляров текстовых процессоров. Класс TextProcessorMainвызывает только getTextProcessorметод TextProcessorFactoryкласса и не должен ничего знать о конкретных реализациях TextProcessorинтерфейса. Такой подход обеспечивает еще более низкую связь между TextProcessorMainклассом и конкретными реализациями TextProcessorинтерфейса.

В заключение следует отметить, что Низкая связанность является критически важным аспектом проектирования программного обеспечения, который способствует сопровождению, масштабируемости и возможности повторного использования кода. Это связано с полиморфизмом, и сочетание этих двух концепций может привести к созданию более надежных и гибких программных систем.