Рубрики
Без рубрики

ТВЕРДЫЕ Принципы

Принципы SOLID – это набор из 5 правил, которым следует следовать для объектно-ориентированного программирования (ООП). Сыворотка… Помеченный как codequality, java, ооп.

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

Я расскажу обо всех 5 принципах в этом посте, но я также буду ссылаться на другие посты, где я более подробно объясняю каждый принцип с примерами кода и фрагментами кода. Если вы не понимаете ООП или хотите освежить знания, я бы посоветовал прочитать эти посты, где я объясняю основы ООП, прежде чем продолжить

Классы и объекты

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

Наследование и полиморфизм

Принцип единой ответственности (SRP), вероятно, является самым простым из 5 принципов для понимания. У каждого класса должно быть одно и только одно задание. Это кажется простым, и большинство разработчиков смогут сказать вам об этом, даже если им будет трудно следовать ему. Трудность для понимания этого принципа заключается в том, что единственная ответственность класса может быть очень конкретной или немного более абстрактной. Например, у вас может быть один класс, целью которого является хранение данных для прямоугольника, его размера и положения, но тогда у вас может быть класс более общего назначения, в котором он содержит все данные для прямоугольника, но также обрабатывает вычисление его площади и периметра. Во втором примере есть несколько заданий, которые он может выполнять, он может вычислять свою площадь или периметр, но у него все еще есть одна обязанность – обрабатывать прямоугольник. Если этот же класс также обрабатывал пользовательский знак, он больше не несет одной ответственности и, следовательно, нарушает SRP.

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

Подробнее о Принципе единой ответственности читайте здесь.

Принцип “Открыто-закрыто” гласит, что объекты должны быть открыты для расширения, но закрыты для модификации. Это означает, что любой объект также должен легко расширяться или дополняться функциональностью, но не должен быть изменен или изменен. Этот принцип довольно трудно понять с самого начала, поскольку он не имеет смысла вне парадигмы ООП. Давайте представим, что у нас есть фрагмент кода, который обрабатывает определенную функциональность, затем мы компилируем этот код так, чтобы мы не могли его изменить. Мы должны иметь возможность добавлять функциональность в код, чтобы сделать его открытым для расширения, не изменяя исходный код, чтобы сделать его закрытым для модификации. Очевидно, что за пределами ООП это невозможно, так как для добавления функциональности мы должны сначала изменить исходный код, а затем перекомпилировать код. Однако в ООП вы можете использовать скомпилированный исходный код класса и наследовать от него в новом классе – новый класс будет дочерним по отношению к предварительно скомпилированному классу. Наследование от базового класса позволяет добавлять функциональность, которой нет у базового класса, но также сохраняет базовый класс закрытым от модификации. Проще говоря, при наследовании от базового класса вам не нужно изменять или модифицировать базовый класс.

Подробнее о принципе “Открыто-закрыто” читайте здесь.

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

Подробнее о принципе замещения Лискова читайте здесь.

Принцип разделения интерфейсов гласит, что класс не следует заставлять реализовывать интерфейс или метод, которые они не используют или которые не имеют смысла в этом контексте. Обычно при кодировании в контексте ООП используется полиморфизм, поэтому вы можете использовать универсальный код во многих различных конкретных реализациях. Однако это может привести к тому, что класс будет реализовывать интерфейс, позволяющий использовать полиморфизм, что на самом деле не имеет смысла. Например, класс, который имеет дело с контактной информацией, не должен реализовываться из класса или интерфейса, который имеет дело с заработной платой или почасовой ставкой человека. Еще одна причина, по которой люди нарушают принцип разделения интерфейсов, заключается в том, что в их интерфейсах слишком много методов. Допустим, у вас есть интерфейс, который заставляет реализовывать два метода “talk” и “fly”, которые мы используем в реализациях разных типов птиц. Однако некоторые птицы не летают, поэтому, если вы создадите класс для птицы Додо, вы будете реализовывать его из этого интерфейса, а затем будете вынуждены реализовать метод “fly”, который в данном контексте не имеет смысла. Это не означает, что каждый интерфейс должен иметь только один метод. Разбиение ваших интерфейсов на компоненты разумного размера – сложная задача, и, скорее всего, позже это приведет к рефакторингу вашей кодовой базы. Шаблон проектирования системы компонентов сущностей является хорошим примером принципа разделения интерфейсов.

Подробнее о принципе разделения интерфейсов читайте здесь.

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

Подробнее о принципе инверсии зависимостей читайте здесь.

ТВЕРДЫЕ принципы – это отличные правила, которым нужно следовать, и они могут упростить обслуживание, расширение вашей кодовой базы и избежать неприятных запахов. Однако принятие любого из этих принципов и работа с ним на самом деле могут ухудшить вашу кодовую базу. Например, если сделать ваш код полностью закрытым для модификации, это предотвратит любой рефакторинг или изменения функций, сделает каждый конкретный класс зависимым от интерфейсов, что приведет к созданию огромной кодовой базы для управления и т.д. Важно пересмотреть свою кодовую базу, и если вы не можете полностью следовать какому-либо принципу, это нормально. Как и в случае со многими советами и рекомендациями, связанными с программным обеспечением, относитесь к ним как к хорошим рекомендациям, а не как к строгим режимам, которым необходимо полностью следовать.

Этот пост был первоначально опубликован на Этот пост был первоначально опубликован на

Оригинал: “https://dev.to/acroynon/the-solid-principles-15a5”