Depois de um longo hiato, estou retomando a série dos principios SOLID, trazendo o quarto dos princípios.

인터페이스 분리 원리

(Principio da Segregação de Interface)

Uma classe não deve ser forçada a implementar interfaces que não irá utilizar.

Abstração é o coração da orientação a objetos. Em PHP, nos conseguimos alcançar um nível de abstração utilizando interfaces e classes abstratas.

Mas, antes, vamos dar um passo atrás: o que é interface?

인터페이스와 추상적인 연결을 클래스로 사용하여 구현합니다. 인터페이스에 대한 사전 지식은 인터페이스에 대한 사전 평가를 통해 사전에 평가해야 합니다.

Partindo deste princípio, parece óbvio que uma classe não deva ser forçada a Implementar algo que não irá usar. Mas nesse artigo, você verá que este princípio é muito fácil de violar.

Seguindo o nosso exemplo de Employees e Contractors, até o eu criei uma classe chamada UserService que injeta os repositories para os dois tipos de usuário.

Vamos fazer uma pequena alteração, a partir de agora será um service para cada tipo de usuário.

class EmployeeService
{
  protected $employeeRepository;

  public function __construct(EmployeeRepository $employeeRepository)
  {
    $this->userRepository = $userRepository;
  }
}

class ContractorService
{
  protected $contractorRepository;

  public function __construct(ContractorRepository $contractorRepository)
  {
    $this->contractorRepository = $contractorRepository;
  }
}

Mesma 인터페이스 구현UserInterface .

interface UserInterface
{
  public function register(array $attributes, UserRepository $userRepository);
  public function calcWorkedHours(array $hours);
}

Interface criada com a assinatura do método register (que foi criado nos posts anteriores), e agora adicionei o método calcWorkedHours que será um método útil para o usuário do tipo Contractor onde as 하세요.

Vamos는 인터페이스가 아닌 서비스를 구현합니다.

class EmployeeService implements UserInterface
{
  public function register(array $attributes, UserRepository $userRepository)
  {
    // implementação do código
  }
}

class ContractorService implements UserInterface
{
  public function register(array $attributes, UserRepository $userRepository)
  {
    // implementação do código
  }

  public function calcWorkedHours(array $hours)
  {
    // implementação do código
  }
}

Dessa maneira nos vamos ter um erro na classe EmployeeService pois elaimplementa a UserInterface mas não usa o método calcWorkedHours .

Uma maneira errada de resolver isso seria implementationar o metodo, mas sem nenhuma implementationação dentro do escopo.

필요에 따라 계속해서 인터페이스를 구현해야 합니다.

interface UserInterface
{
  public function register(array $attributes, UserRepository $userRepository);
}

interface ContractorInterface
{
  public function calcWorkedHours(array $hours);
}

인터페이스를 이중 인터페이스로, 구현하는 클래스로 사용합니다.

class EmployeeService implements UserInterface
{
  public function register(array $attributes, UserRepository $userRepository)
  {
    // implementação do código
  }
}

class ContractorService implements UserInterface, ContractorInterface
{
  public function register(array $attributes, UserRepository $userRepository)
  {
    // implementação do código
  }

  public function calcWorkedHours(array $hours)
  {
    // implementação do código
  }
}

Dessa maneira, não obrigamos nenhuma classe a implementar algo que não irá utilizar. Sendo assim, não violamos o princípio da segregação de interface. :)

텐타모스 엔텐더 apenas a teoria dos princípios, parecem bem mais complicados do que realmente são.

종속성 반전 원칙(Princípio da Inversão de Dependência) 없음.

Dúvidas e 피드백 são semper bem-vindos.