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 Database
interface pode ter os métodos connect()
e disconnect()
porque eles devem andar juntos. Se a Database
interface 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 Vehicle
classe 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):
pass
Linguagem de código: Python ( python )
Segundo, defina a Aircraft
classe que herda da Vehicle
classe 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 Car
classe que herda da Vehicle
classe. 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 Car
classe deve implementar o fly()
método da Vehicle
classe que a Car
classe não usa. Portanto, este projeto viola o princípio de segregação de interface.
Para corrigir isso, você precisa dividir a Vehicle
classe em pequenas e herdar dessas classes das classes Aircraft
e Car
:
Primeiro, divida a Vehicle
interface em duas interfaces menores: Movable
e Flyable
e herde a Movable
classe da Flyable
classe:
class Movable(ABC):
@abstractmethod
def go(self):
pass
class Flyable(Movable):
@abstractmethod
def fly(self):
pass
Linguagem de código: Python ( python )
Em segundo lugar, herda da Flyable
classe da Aircraft
classe:
class Aircraft(Flyable):
def go(self):
print("Taxiing")
def fly(self):
print("Flying")
Linguagem de código: Python ( python )
Terceiro, herde a Movable
classe da Car
classe:
class Car(Movable):
def go(self):
print("Going")
Linguagem de código: Python ( python )
Neste projeto, Car
basta 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.