Princípio de segregação de interface Python

Resumo : neste tutorial, você aprenderá sobre o princípio de segregação de interface e como aplicá-lo em Python.

Introdução ao princípio de segregação de interface

O princípio de segregação de interface é um dos cinco princípios SOLID na programação orientada a objetos:

• S  – Princípio da responsabilidade única
• O  – Princípio Aberto-Fechado
• L  – Princípio da Substituição de Liskov
• I  – Princípio de Segregação de Interface
• D  – Princípio de Inversão de Dependência

Uma interface é uma descrição dos comportamentos que um objeto pode realizar. Por exemplo, quando você pressiona o botão liga/desliga no controle remoto da TV, ele liga a TV e você não precisa se preocupar com como.

Na programação orientada a objetos, uma interface é um conjunto de métodos que um objeto deve ter. O objetivo das interfaces é permitir que os clientes solicitem os métodos corretos de um objeto através de sua interface.

Python usa classes abstratas como interfaces porque segue o chamado princípio de digitação duck. O princípio da digitação do pato afirma que “se ele anda como um pato e grasna como um pato, deve ser um pato”. Em outras palavras, os métodos de uma classe determinam quais serão seus objetos, e não o tipo da classe.

O princípio de segregação de interface afirma que uma interface deve ser tão pequena quanto possível em termos de coesão. Em outras palavras, deve fazer UMA coisa.

Isso não significa que a interface deva ter um método. Uma interface pode ter vários métodos coesos.

Por exemplo, a Databaseinterface pode ter os métodos connect()e disconnect()porque eles devem andar juntos. Se a Databaseinterface não usar os dois métodos, ficará incompleta.

Tio Bob , que é o criador do termo SOLID, explica o princípio de segregação de interfaces aconselhando que “Crie interfaces refinadas que sejam específicas do cliente. Os clientes não devem ser forçados a implementar interfaces que não utilizam.”

Exemplo de princípio de segregação de interface

Considere o seguinte exemplo:

Primeiro, defina uma Vehicleclasse abstrata que tenha dois métodos abstratos go()e fly():

from abc import ABC, abstractmethod


class Vehicle(ABC):
    @abstractmethod
    def go(self):
        pass

    @abstractmethod
    def fly(self):
        passLinguagem de código:  Python  ( python )

Segundo, defina a Aircraftclasse que herda da Vehicleclasse e implemente os métodos go()e fly():

class Aircraft(Vehicle):
    def go(self):
        print("Taxiing")

    def fly(self):
        print("Flying")Linguagem de código:  Python  ( python )

Terceiro, defina a Carclasse que herda da Vehicleclasse. Como um carro não pode voar, levantamos uma exceção no fly()método:

class Car(Vehicle):
    def go(self):
        print("Going")

    def fly(self):
        raise Exception('The car cannot fly')Linguagem de código:  Python  ( python )

Neste design, a Carclasse deve implementar o fly()método da Vehicleclasse que a Carclasse não usa. Portanto, este projeto viola o princípio de segregação de interface.

Para corrigir isso, você precisa dividir a Vehicleclasse em pequenas e herdar dessas classes das classes Aircrafte Car:

Primeiro, divida a Vehicleinterface em duas interfaces menores: Movablee Flyablee herde a Movableclasse da Flyableclasse:

class Movable(ABC):
    @abstractmethod
    def go(self):
        pass


class Flyable(Movable):
    @abstractmethod
    def fly(self):
        passLinguagem de código:  Python  ( python )

Em segundo lugar, herda da Flyableclasse da Aircraftclasse:

class Aircraft(Flyable):
    def go(self):
        print("Taxiing")

    def fly(self):
        print("Flying")Linguagem de código:  Python  ( python )

Terceiro, herde a Movableclasse da Carclasse:

class Car(Movable):
    def go(self):
        print("Going")Linguagem de código:  Python  ( python )

Neste projeto, Carbasta implementar o go()método que necessita. Não precisa implementar o fly()método que não usa.

Resumo

• O princípio de segregação de interfaces recomenda que as interfaces sejam pequenas em termos de coesão.
• Crie interfaces refinadas específicas do cliente. Os clientes não devem ser forçados a implementar interfaces que não utilizam.