├── .gitignore
├── README.md
└── src
    └── GSoares
        └── SOLID
            ├── DependencyInversion
                ├── Correct.php
                ├── README.md
                └── Wrong.php
            ├── InterfaceSegregation
                ├── Correct.php
                ├── README.md
                └── Wrong.php
            ├── LiskovSubstitution
                ├── Correct.php
                ├── README.md
                └── Wrong.php
            ├── OpenClosed
                ├── Correct.php
                ├── README.md
                └── Wrong.php
            └── SingleResponsability
                ├── Correct.php
                ├── README.md
                └── Wrong.php


/.gitignore:
--------------------------------------------------------------------------------
1 | /.settings
2 | /.buildpath
3 | /.project
4 | /index.php
5 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | SOLID
 2 | =====
 3 | 
 4 | Projeto com exemplos em PHP dos Princípios SOLID para maior qualidade em programação. Os exemplos foram escritos em PHP, 
 5 | pois é a liguagem que trabalho, mas SOLID está relacionado a boas práticas de programação, não estando ligado 
 6 | diretamente a nenhuma linguagem de programação.
 7 | 
 8 | 
 9 | * Por que aprender SOLID?
10 | 
11 | Porque é uma ótima prática que irá melhorar a qualidade do seu software:
12 | 
13 | * Facilitando o entendimento do código.
14 | * Evitando discrepância e redundância.
15 | * Proporcionando mais coesão ao código.
16 | * Melhorando a organização do seu código.
17 | * Eliminando dependências e acoplamentos desnecessárias.
18 | * Padrão conciso:
19 |   * Fácil entendimento. 
20 |   * Fácil manutenção.
21 |   * Menor curva de aprendizado.
22 |   * Maior produtividade.
23 |   * Menos custo.
24 | 
25 | * Atalhos 
26 | 
27 | * [Single Responsability Principle (SRP)](src/GSoares/SOLID/SingleResponsability)
28 | * [Open/Closed Principle (OCP)](src/GSoares/SOLID/OpenClosed)
29 | * [Liskov Substitution Principle (LSP)](src/GSoares/SOLID/LiskovSubstitution)
30 | * [Interface Segregation Principle (ISP)](src/GSoares/SOLID/InterfaceSegregation)
31 | * [Dependency Inversion Principle (DIP)](src/GSoares/SOLID/DependencyInversion)
32 | 


--------------------------------------------------------------------------------
/src/GSoares/SOLID/DependencyInversion/Correct.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 | ### EXPLICAÇÕES ####
 4 | 
 5 | No exemplo abaixo abstraimos os detalhes do "Computer", ou seja abstraimos o comportamento dele de ligar e 
 6 | desligar através da interface "PowerDevice". Agora "invertemos" a dependência do "Button" para o 
 7 | "Computer", ou seja, ambos dependem de abstração. Dessa fora a classe "Button" poderá travalhar com qualquer 
 8 | "Power Device", não se preocupando como os detalhes do mesmo.
 9 | */
10 | namespace GSoares\SOLID\DependencyInversion;
11 | 
12 | interface PowerDevice
13 | {
14 |    public function on();
15 |    public function off();
16 |        
17 | }
18 | 
19 | class Computer implements PowerDevice
20 | {
21 |     public function on()
22 |     {
23 |         echo 'Computer power on!';
24 |     }
25 |     
26 |     public function off()
27 |     {
28 |         echo 'Computer power off...';
29 |     }
30 | }
31 | 
32 | class Button 
33 | {
34 |     /**
35 |      * @var PowerDevice
36 |      */
37 |     private $powerDevice;
38 |     
39 |     public function setPowerDevice(PowerDevice $powerDevice)
40 |     {
41 |         $this->powerDevice = $powerDevice;
42 |     }
43 |     
44 |     public function turnOn()
45 |     {
46 |         if (condition) { //some condition
47 |             $this->powerDevice->on();
48 |         }
49 |     }
50 |     
51 | }


--------------------------------------------------------------------------------
/src/GSoares/SOLID/DependencyInversion/README.md:
--------------------------------------------------------------------------------
1 | Dependency Inversion Principle (DIP)
2 | =====
3 | 
4 | A definição de DIP que significa "Inversão de Dependência" afirma que: 
5 | 
6 | 1) "Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender de abstrações".
7 | 2) "Abstrações não devem depender de detalhes. Detalhes devem depender de abstrações."


--------------------------------------------------------------------------------
/src/GSoares/SOLID/DependencyInversion/Wrong.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 | ### EXPLICAÇÕES ####
 4 | 
 5 | No exemplo abaixo podemos perceber que o botao depende de uma classe concreta "Computer" e conhece detalhes de
 6 | implementação da mesma violando o DIP que afirma que detalhes devem depender de abstrações.
 7 | */
 8 | namespace GSoares\SOLID\DependencyInversion;
 9 | 
10 | class Computer
11 | {
12 |     public function on() {}
13 | }
14 | 
15 | class Button 
16 | {
17 |     /**
18 |      * @var Computer
19 |      */
20 |     private $computer;
21 | 
22 |     public function activate()
23 |     {
24 |         if (condition) { //some condition
25 |             $this->computer->on();
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/GSoares/SOLID/InterfaceSegregation/Correct.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 | ### EXPLICAÇÕES ####
 4 | 
 5 | Para fazer com que a classe "Vehicle" não seja mais genérica, foi criada a interface "AutomotiveVehicle" que possui
 6 | as funcões de veículo, porém com métodos adicionais que dizem respeito apenas a veículos automotivos. Desta forma temos 
 7 | interfaces mais específicas que pode ser usadas por mais classes com comportamentos diferentes.
 8 | */
 9 | namespace GSoares\SOLID\InterfaceSegregation;
10 | 
11 | interface Vehicle 
12 | {
13 | 	public function run();
14 | }
15 | 
16 | interface AutomotiveVehicle extends Vehicle
17 | {
18 |     public function turnOn();
19 |     public function fuel();
20 | }
21 | 
22 | class Motorcycle implements AutomotiveVehicle
23 | {
24 |     public function turnOn()
25 |     {
26 |         echo 'Motorcycle Turning on...';
27 |     }
28 | 
29 |     public function run()
30 |     {
31 |         echo 'Motorcycle running...';
32 |     }
33 | 
34 |     public function fuel()
35 |     {
36 |         echo 'Fuel the Motorcycle';
37 |     }
38 | }
39 | 
40 | class Bicycle implements Vehicle 
41 | {
42 | 	public function run() 
43 | 	{
44 | 		echo 'Bicycle running...';
45 | 	}
46 | }


--------------------------------------------------------------------------------
/src/GSoares/SOLID/InterfaceSegregation/README.md:
--------------------------------------------------------------------------------
1 | Interface Segregation Principle (ISP)
2 | =====
3 | 
4 | A definição do ISP, ou o princípio da segregação de interface, afirma que: "Clientes não devem ser forçados a depender 
5 | de métodos que não usam", ou seja, classes não devem ser obrigadas a implementar metodos que não utilizam. 
6 | 
7 | * Este princípio trata da coesão das interfaces. 


--------------------------------------------------------------------------------
/src/GSoares/SOLID/InterfaceSegregation/Wrong.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 | ### EXPLICAÇÕES ####
 4 | 
 5 | As classe "Bicycle" é obrigada a implementar os métodos "turnOn" e "fuel", pois a interface "Vehicle" é genérica demais.
 6 | Sempre que eu implementar uma interface todos os métodos da mesma devem ser úteis para a classe em questão. Se existir 
 7 | algum método desnecessário sendo implementado, ou você está implementando a interface errada, ou a interface é genérica 
 8 | demais e necessidade ser segregada, ou separada em interfaces mais específicas.
 9 | */
10 | namespace GSoares\SOLID\InterfaceSegregation;
11 | 
12 | interface Vehicle 
13 | {
14 | 	public function turnOn();
15 | 	public function run();
16 | 	public function fuel();
17 | }
18 | 
19 | class Motorcycle implements Vehicle
20 | {
21 |     public function turnOn()
22 |     {
23 |         echo 'Motorcycle Turning on...';
24 |     }
25 | 
26 |     public function run()
27 |     {
28 |         echo 'Motorcycle running...';
29 |     }
30 | 
31 |     public function fuel()
32 |     {
33 |         echo 'Fuel the Motorcycle';
34 |     }
35 | }
36 | 
37 | class Bicycle implements Vehicle 
38 | {
39 | 	public function turnOn() 
40 | 	{
41 | 		//does nothing, because bicycles doesn't turn on
42 | 	}
43 | 	
44 | 	public function run() 
45 | 	{
46 | 		echo 'Bicycle running...';
47 | 	}
48 | 	
49 | 	public function fuel() 
50 | 	{
51 | 	    //does nothing, because bicycles doesn't turn on
52 | 	}
53 | }


--------------------------------------------------------------------------------
/src/GSoares/SOLID/LiskovSubstitution/Correct.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 | /*
 3 | ### EXPLICAÇÕES ####
 4 | 
 5 | Ambos quadrado e retângulo são paralelogramas, quadrilateros convexos que possuem dois pares lados paralelos, 
 6 | porém com regras diferenciadas. Observando que uma regra da classe base necessita ser modificada por classe derivada, 
 7 | devemos então criar um nível de abstração mais acima, contêndo somente os comportamentos e atributos comuns.
 8 | 
 9 | Criamos a classe abstrata "Parallelogram" com o metodo "resize" que deve ser implementado pelas classes derivadas 
10 | para que as mesmas façam o redimencionamento de acordo com a regra de cada forma geométrica.
11 | */
12 | namespace GSoares\SOLID\LiskovSubstitution;
13 | 
14 | abstract class Parallelogram 
15 | {
16 |     protected $height;
17 |     protected $width;
18 |     
19 |     public function getWidth()
20 |     {
21 |         return $this->width;
22 |     }
23 |     
24 |     public function getHeight()
25 |     {
26 |         return $this->height;
27 |     }
28 |     
29 |     public function calculateArea()
30 |     {
31 |         return $this->height * $this->width;
32 |     }
33 |     
34 |     public abstract function resize($height, $width);
35 | }
36 | 
37 | class Rectangle extends Parallelogram 
38 | {
39 | 	public function resize($height, $width)
40 | 	{
41 | 	    $this->height = $height;
42 | 	    $this->width = $width;
43 | 	}
44 | }
45 | 
46 | class Square extends Parallelogram {
47 |     
48 | 	public function resize($height, $width)
49 | 	{
50 | 	    $this->width = $width;
51 | 	    $this->height = $width;
52 | 	}
53 | }
54 | 
55 | class GraphicEditor
56 | {
57 |     public function resize(Parallelogram $parallelogram)
58 |     {
59 |         $parallelogram->resize(
60 |             $parallelogram->getHeight() * 2,
61 |             $parallelogram->getWidth() * 4
62 |         );
63 |     }
64 | }


--------------------------------------------------------------------------------
/src/GSoares/SOLID/LiskovSubstitution/README.md:
--------------------------------------------------------------------------------
 1 | Liskov Substitution Principle (LSP)
 2 | =====
 3 | 
 4 | A definição do LSP que foi criado por Barbara Liskov, em 1988 (daí o nome), afirma 
 5 | que "Classes derivadas devem poder ser substituídas por suas classes base".
 6 | 
 7 | 
 8 | “Se para cada objeto o1 do tipo S há um objeto o2 do tipo T de forma que, para todos os programas P definidos em 
 9 | termos de T, o comportamento de P é inalterado quando o1 é substituído por o2 então S é um subtipo de T”
10 | 
11 | 
12 | * Atender o LSP, significa que as classes derivadas são completamente substituíveis por suas classes-base, ou seja, 
13 | todo o código que utilizar a classe base será capaz de atender o LSP.
14 | 


--------------------------------------------------------------------------------
/src/GSoares/SOLID/LiskovSubstitution/Wrong.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 | ### EXPLICAÇÕES ####
 4 | 
 5 | Caso o metodo "resize" receba um "Rectangle", ele irá redimencionar o mesmo da forma esperada, porém se receber um 
 6 | "Square", não importa os parâmetros utilizados, o redimencionamento sempre será para um quadrado.
 7 | 
 8 | Este "bug" ocorre, porque a classe derivada "Square" não respeita a regra da classe base "Rectangle" de variar a 
 9 | largura e altura de forma independente. Ou seja, a classe "Square" fez um "override" alterando a regra da classe base 
10 | que manipula os atributos "width" e "height" compartilhados por elas.
11 | 
12 | A violação do LSP ocorre aqui, pois no método "resize" não é possível substituir um objeto da classe derivada por outro 
13 | sem quebrar a regra, pois a atribuição de largura e altura teve a regra alterada na classe "Square". Todo o quadrado é 
14 | um retângulo, porém nem todo o retângulo é um quadrado.
15 | */
16 | namespace GSoares\SOLID\LiskovSubstitution;
17 | 
18 | class Rectangle 
19 | {
20 |     protected $height;
21 |     protected $width; 
22 |     
23 |     public function setWidth($width)
24 |     {
25 |         $this->width = $width;
26 |     }
27 |     
28 |     public function setHeight($height)
29 |     {
30 |         $this->height = $height;
31 |     }
32 |     
33 |     public function getWidth()
34 |     {
35 |         return $this->width;
36 |     }
37 |     
38 |     public function getHeight()
39 |     {
40 |         return $this->height;
41 |     }
42 |     
43 |     public function calculateArea()
44 |     {
45 |         return $this->height * $this->width;
46 |     }
47 | }
48 | 
49 | class Square extends Rectangle {
50 |     
51 | 	public function setWidth($width) 
52 | 	{
53 | 		$this->width = $width;
54 | 		$this->height = $width;
55 | 	}
56 | 	
57 | 	public function setHeight($height) 
58 | 	{
59 | 		$this->width = $height;
60 | 		$this->height = $height;
61 | 	}
62 | }
63 | 
64 | class GraphicEditor
65 | {
66 |     public function resize(Rectangle $rectangle)
67 |     {
68 |         $rectangle->setHeight($rectangle->getHeight() * 2);
69 |         $rectangle->setWidth($rectangle->getWidth() * 4);
70 |     }
71 | }


--------------------------------------------------------------------------------
/src/GSoares/SOLID/OpenClosed/Correct.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  ### EXPLICAÇÕES ####
 4 | 
 5 | No exemplo abaixo a classe "Vehicle" foi transformada em abstrata e o metodo "tunOn" foi abstratido pelas classes que 
 6 | estendem "Vehicle", desta forma, se criarmos um novo veículo, por exemplo "Truck", não será mais necessário alterar
 7 | o código existente (método Driver::drive), necessitando apenas que "Truck" estenda "Vehicle" e implemente o método "turnOn".
 8 | */
 9 | namespace GSoares\SOLID\OpenClosed;
10 | 
11 | abstract class Vehicle 
12 | {
13 |     public function run(){}
14 |     abstract public function turnOn();
15 | }
16 | 
17 | class Motorcycle extends Vehicle
18 | {
19 |     public function turnOn()
20 |     {
21 |         echo 'Turning on the motorcycle';
22 |     } 
23 | }
24 | 
25 | class Car extends Vehicle
26 | {
27 |     public function turnOn()
28 |     {
29 |         echo 'Turning on the car';
30 |     }
31 | }
32 | 
33 | class Truck extends Vehicle
34 | {
35 |     public function turnOn()
36 |     {
37 |         echo 'Turning on the truck';
38 |     }
39 | }
40 | 
41 | class Driver 
42 | {
43 |     public function drive(Vehicle $vehicle)
44 |     {
45 |         $vehicle->turnOn();
46 |         $vehicle->run();
47 |     }
48 | }


--------------------------------------------------------------------------------
/src/GSoares/SOLID/OpenClosed/README.md:
--------------------------------------------------------------------------------
1 | Open/Closed Principle (OCP)
2 | =====
3 | 
4 | A definição deste princípio OCP, que significa "Aberto e Fechado" afirma que: 
5 | “Uma classe deve estar aberta para extensão, mas fechada para alteração”.
6 | 
7 | Para contemplar este princípio utilizamos de abastrações e poliforfismo. Ao estender um novo comportamento em uma 
8 | classe, devemos criar código novo e não alterar código existente.
9 |  


--------------------------------------------------------------------------------
/src/GSoares/SOLID/OpenClosed/Wrong.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  ### EXPLICAÇÕES ####
 4 | 
 5 | Como o princípio do "Aberto e Fechado" diz que a classe deve estar aberta para extensão e fechada para alteração, 
 6 | porém no exemplo abaixo o método "drive" da classe "Driver" precisará ser alterado sempre que for criado um novo 
 7 | tipo de veículo. Ou seja, ao adicionar um novo comportamento o código existente terá que ser alterado, indo totalmente 
 8 | contra o princípio do "Open/Closed"
 9 | */
10 | namespace GSoares\SOLID\OpenClosed;
11 | 
12 | class Vehicle 
13 | {
14 |     public function run(){}
15 | }
16 | 
17 | class Motorcycle extends Vehicle
18 | {
19 |     
20 | }
21 | 
22 | class Car extends Vehicle
23 | {
24 |     
25 | }
26 | 
27 | class Driver 
28 | {
29 |     public function drive(Vehicle $vehicle)
30 |     {
31 |         if ($vehicle instanceof Motorcycle) {
32 |             $this->turnOnMotorcycle();
33 |         }       
34 |         
35 |         if ($vehicle instanceof Car) {
36 |             $this->turnOnCar();
37 |         }
38 |         
39 |         $vehicle->run();
40 |     }
41 |     
42 |     private function turnOnCar()
43 |     {
44 |         echo 'Turning on the car';
45 |     }
46 |     
47 |     private function turnOnMotorcycle()
48 |     {
49 |         echo 'Turning on the motorcycle';
50 |     }
51 | }


--------------------------------------------------------------------------------
/src/GSoares/SOLID/SingleResponsability/Correct.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 |  ### EXPLICAÇÕES ####
 4 | 
 5 | Para distribuir as resonsabilidades de forma correta, agora a classe "Account" efetua o cálculo de saldo e 
 6 | a classe "Sale" apenas calcula o valor da venda e repassa o mesmo para um metodo da classe "Account" calcular o saldo.
 7 | */
 8 | namespace GSoares\SOLID\SingleResponsability;
 9 | 
10 | class NoBalanceAvailableException extends \Exception {}
11 | 
12 | class Product {
13 |     public function getValue() {}
14 | }
15 | 
16 | class Account 
17 | {
18 |     public function getBalance() {}
19 |     public function setBalance() {}
20 |     
21 |     public function calculateBalance($value)
22 |     {
23 |         $this->setBalance($this->getBalance() - $value);
24 |     }
25 |     
26 |     public function haveBalanceAvailable($value)
27 |     {
28 |         return $this->getBalance() >= $value;
29 |     }
30 | }
31 | 
32 | class Customer 
33 | {
34 |     public function getAccount() {}
35 | }
36 | 
37 | class Sale
38 | {
39 |     public function getValue() {}
40 |     public function setValue() {}
41 |     
42 |     public function sell(array $products, Customer $customer)
43 |     {
44 |         $value = $this->calculateTotalValue($products);
45 |         
46 |         if (!$customer->getAccount()->haveBalanceAvailable($value)) {
47 |             throw new NoBalanceAvailableException();
48 |         }
49 | 
50 |         /*..... something.....*/
51 |         
52 |         $this->setValue($value);
53 |         $customer->getAccount()->calculateBalance($value);
54 |     }
55 |     
56 |     public function calculateTotalValue(array $products)
57 |     {
58 |         $value = 0;
59 |         
60 |         foreach ($products as $product) {
61 |             $value += $product->getValue();
62 |         }
63 |         
64 |         return $value;
65 |     }
66 | }


--------------------------------------------------------------------------------
/src/GSoares/SOLID/SingleResponsability/README.md:
--------------------------------------------------------------------------------
1 | Single Responsability Principle (SRP)
2 | =====
3 | 
4 | A definição de LRP que significa "Única Responsabilidade" afirma que: “Uma classe deve ter somente uma razão para mudar”, ou
5 | seja, uma classe deve apenas ter uma razão de existir e não cuidar de regras que não pertencem ao escopo de sua existência, 
6 | possuindo uma "responsabilidade única". 


--------------------------------------------------------------------------------
/src/GSoares/SOLID/SingleResponsability/Wrong.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 | ### EXPLICAÇÕES ####
 4 | 
 5 | - No exemplo abaixo podemos identificar que a classe "Sale" que deveria apenas 
 6 | trabalhar com os valores da venda, também calcula o saldo da conta do cliente.
 7 | 
 8 | - Isto está ERRADO, pois o cálculo do saldo diz respeito a conta e a contabilização do mesmo deveria ficar
 9 | na classe "Account" ou em um serviço responsável por cálculo de saldo. Do jeito implementado abaixo, 
10 | a classe teria "dois motivos" para ser alterada: 
11 |     1) Houve mudança nas regras de venda ou 
12 |     2) Houve mudança no cálculo de saldo da conta.
13 | 
14 | E isso vai contra o princípio de "Single Responsability Principle" que afirma que: 
15 |     “Uma classe deve ter somente uma razão para mudar”.
16 | */
17 | namespace GSoares\SOLID\SingleResponsability;
18 | 
19 | class NoBalanceAvailableException extends \Exception {}
20 | 
21 | class Product {
22 |     public function getValue() {}
23 | }
24 | 
25 | class Account 
26 | {
27 |     public function getBalance() {}
28 |     public function setBalance() {}
29 | }
30 | 
31 | class Customer 
32 | {
33 |     public function getAccount() {}
34 | }
35 | 
36 | class Sale
37 | {
38 |     public function getValue() {}
39 |     public function setValue() {}
40 |     
41 |     public function sell(array $products, Customer $customer)
42 |     {
43 |         $value = $this->calculateTotalValue($products);
44 |         
45 |         if (!$this->haveBalanceAvailable($customer, $value)) {
46 |             throw new NoBalanceAvailableException();
47 |         }
48 | 
49 |         /*..... something.....*/
50 |         
51 |         $this->setValue($value);
52 |         $this->calculateBalance($customer);
53 |     }
54 |     
55 |     public function calculateBalance(Customer $customer)
56 |     {
57 |         $customer->getAccount()->setBalance($customer->getAccount()->getBalance() - $this->getValue());
58 |     }
59 |     
60 |     public function haveBalanceAvailable(Customer $customer, $value)
61 |     {
62 |         return $customer->getAccount()->getBalance() >= $value;
63 |     }
64 |     
65 |     private function calculateTotalValue(array $products)
66 |     {
67 |         $value = 0;
68 |     
69 |         foreach ($products as $product) {
70 |             $value += $product->getValue();
71 |         }
72 |     
73 |         return $value;
74 |     }
75 | }


--------------------------------------------------------------------------------