Eu sei que

P.O.O.

é a pedra do teu sapato

Kilderson Sena

@derson_sena

Quem é tu mermo?

Kilderson Sena

- PHP Software Engineer

- Graduado em Análise e Desenv. Sistemas

- Movido a café e rockn'roll

- Programador há mais de 10 anos

- Pai do Kauan Lucas

fb.com/kilderson.sena

@derson_sena

@derson_sena

Quem é tu mermo?

Quem é tu mermo?

youtube.com/yiiacademybr

Quem é tu mermo?

yiiacademy.com.br

Quem é tu mermo?

Quem é tu mermo?

Quem é tu mermo?

8 Motivos para

usar o Yii2

yiiacademy.com.br/8-motivos-para-usar-o-yii-2

Aprenda Orientação a Objetos com Forma de Gelo

devtube.com.br/ebook-oo1.html

Eu tenho um presente para VOCÊS no fim da palestra

Quem aqui trabalha com O.O. ?

O que

diachos é

Orientação

Objetos ?

O que diachos é O.O. ?

é um paradigma que visa auxiliar no processo de desenvolvimento de software gerando códigos mais inteligíveis e aplicações mais seguras

O que diachos é O.O. ?

é a comunicação entre objetos através de troca de mensagens.

O que diachos é O.O. ?

O que diachos é O.O. ?

"Um programador sem OO

é um corno

sem chifres."

Vantagens

A codificação fica mais próxima do cenário real do

problema a ser resolvido

Vantagens

é muito mais simples ter uma classe Pessoa que faz o cadastro, atualização, exclusão e busca do que uma função para cada ação necessária.

Vantagens

A manutenção futura fica mais simples e rápida

Vantagens

você somente altera as classes que são necessárias, sem precisar ficar procurando funções perdidas em meio aos arquivos para alterar algo

Vantagens

Maior reutilização de código

Vantagens

... e por aí vai.

Por que PHP ?

Objeto

É "algo"que tem características, comportamentos e estado(s).

Pilares do

Paradigma 

Pilares

A

E

H

P

Pilares

A

E

H

P

Abstração

Um dos pilares mais importantes

dentro do P.O.O.

Abstração

Tem ligação direta com interfaces

Abstração

é a idéia de "pegar" do mundo real somente aquilo que é relevante.

Abstração

Vamos imaginar uma mesa. Uma mesa que tenha pés, uma base e uma finalidade... 

Abstração

...na abstração não importa quantos pés, ou tipo de base ou a finalidade da mesa...

Abstração

... e isso não fará com que a mesa que eu imaginei, deixe de ser uma mesa. Ela sempre será uma mesa.

Pilares

A

E

H

P

Encapsulamento

é um mecanismo utilizado para reunir informações em uma estrutura para esconder a implementações do objeto

Encapsulamento

é a idéia de ocultar detalhes da implementação interna do objeto.

class TV
{
    public $ligado = false;
}

class ControleRemoto
{
    public $tv;
    
    public function __construct(TV $tv)
    {
        $this->tv = $tv;
    }
    
    public function ligar()
    {
        $this->tv->ligado = true;
    }
    
    public function desligar()
    {
        $this->tv->ligado = false;
    }
}

$tv = new TV();
$controleRemoto = new ControleRemotoTV($tv);

if ($tv->ligado) {
    $controleRemoto->desligar();
} else {
    $controleRemoto->ligar();
}
class TV
{
    public $ligado = false;
}

class ControleRemoto
{
    public $tv;
    
    public function __construct(TV $tv)
    {
        $this->tv = $tv;
    }
    
    public function ligar()
    {
        $this->tv->ligado = true;
    }
    
    public function desligar()
    {
        $this->tv->ligado = false;
    }
}

$tv = new TV();
$controleRemoto = new ControleRemotoTV($tv);

if ($tv->ligado) {
    $controleRemoto->desligar();
} else {
    $controleRemoto->ligar();
}
class TV
{
    public $ligado = false;
}

class ControleRemoto
{
    public $tv;
    
    public function __construct(TV $tv)
    {
        $this->tv = $tv;
    }
    
    public function ligar()
    {
        $this->tv->ligado = true;
    }
    
    public function desligar()
    {
        $this->tv->ligado = false;
    }
}

$tv = new TV();
$controleRemoto = new ControleRemotoTV($tv);

if ($tv->ligado) {
    $controleRemoto->desligar();
} else {
    $controleRemoto->ligar();
}
class TV
{
    public $ligado = false;
}

class ControleRemoto
{
    public $tv;
    
    public function __construct(TV $tv)
    {
        $this->tv = $tv;
    }
    
    public function ligar()
    {
        $this->tv->ligado = true;
    }
    
    public function desligar()
    {
        $this->tv->ligado = false;
    }
}

$tv = new TV();
$controleRemoto = new ControleRemotoTV($tv);

if ($tv->ligado) {
    $controleRemoto->desligar();
} else {
    $controleRemoto->ligar();
}

Encapsulamento

class TV
{
    private $ligado = false;
    
    public function ligar()
    {
        if ($this->ligado === true) {
            return;
        }
        
        $this->ligado = true;
    }
    
    public function desligar()
    {
        if ($this->ligado === false) {
            return;
        }
        
        $this->ligado = false;
    }
}

Encapsulamento

class TV
{
    private $ligado = false;
    
    public function ligar()
    {
        if ($this->ligado === true) {
            return;
        }
        
        $this->ligado = true;
    }
    
    public function desligar()
    {
        if ($this->ligado === false) {
            return;
        }
        
        $this->ligado = false;
    }
}

Encapsulamento

class TV
{
    private $ligado = false;
    
    public function ligar()
    {
        if ($this->ligado === true) {
            return;
        }
        
        $this->ligado = true;
    }
    
    public function desligar()
    {
        if ($this->ligado === false) {
            return;
        }
        
        $this->ligado = false;
    }
}

Encapsulamento

class TV
{
    private $ligado = false;
    
    public function ligar()
    {
        if ($this->ligado === true) {
            return;
        }
        
        $this->ligado = true;
    }
    
    public function desligar()
    {
        if ($this->ligado === false) {
            return;
        }
        
        $this->ligado = false;
    }
}

Encapsulamento

class ControleRemoto
{
    private $tv;
    
    public function __construct(TV $tv)
    {
        $this->tv = $tv;
    }
    
    public function ligar()
    {
        $this->tv->ligar();
    }
    
    public function desligar()
    {
        $this->tv->desligar();
    }
}

Encapsulamento

class ControleRemoto
{
    private $tv;
    
    public function __construct(TV $tv)
    {
        $this->tv = $tv;
    }
    
    public function ligar()
    {
        $this->tv->ligar();
    }
    
    public function desligar()
    {
        $this->tv->desligar();
    }
}

Encapsulamento

class ControleRemoto
{
    private $tv;
    
    public function __construct(TV $tv)
    {
        $this->tv = $tv;
    }
    
    public function ligar()
    {
        $this->tv->ligar();
    }
    
    public function desligar()
    {
        $this->tv->desligar();
    }
}

Encapsulamento

// Antes
$tv = new TV();
$controleRemoto = new ControleRemotoTV($tv);

if ($tv->ligado) {
    $controleRemoto->desligar();
} else {
    $controleRemoto->ligar();
}


// Depois
$tv = new TV();
$controleRemoto = new ControleRemotoTV($tv);
$controleRemoto->ligar();
$controleRemoto->desligar();

Pilares

A

E

H

P

Herança

permite e facilita o reaproveitamento de código

Herança

uma classe herda as características e funcionalidades de uma

classe Pai / Base / Mãe

Herança

Cuidado com o "tamanho" da Herança

Herança

Sempre se "pergunte" se a

<classe filha> É UM(A) <classe pai>

Herança

abstract class Person
{
    private $name;
    
    public function __construct(string $nome)
    {
        $this->nome = $nome;
    }

    public function getNome(): string
    {
    	return $this->nome;
    }
}

class IndividualPerson extends Person
{
}

class LegalPerson extends Person
{
}

$individualPerson = new IndividualPerson('Kilderson Sena');
$legalPerson = new LegalPerson('Tembo Social');

echo $individualPerson->getNome();
echo $legalPerson->getNome();

Herança

abstract class Person
{
    private $name;
    
    public function __construct(string $nome)
    {
        $this->nome = $nome;
    }

    public function getNome(): string
    {
    	return $this->nome;
    }
}

class IndividualPerson extends Person
{
}

class LegalPerson extends Person
{
}

$individualPerson = new IndividualPerson('Kilderson Sena');
$legalPerson = new LegalPerson('Tembo Social');

echo $individualPerson->getNome();
echo $legalPerson->getNome();

Herança

abstract class Person
{
    private $name;
    
    public function __construct(string $nome)
    {
        $this->nome = $nome;
    }

    public function getNome(): string
    {
    	return $this->nome;
    }
}

class IndividualPerson extends Person
{
}

class LegalPerson extends Person
{
}

$individualPerson = new IndividualPerson('Kilderson Sena');
$legalPerson = new LegalPerson('Tembo Social');

echo $individualPerson->getNome();
echo $legalPerson->getNome();

Pilares

A

E

H

P

Polimorfismo

consiste na alteração do funcionamento interno de um método herdado do pai

Polimorfismo

tá diretamente ligado a

herança

Polimorfismo

não tem como falar de polimorfismo e não falar de

sobrecarga e sobreposição

Polimorfismo

Mesma assinatura

Classes Diferentes

Sobreposição (Override)

Polimorfismo

Sobreposição (Override)

class Vehicle
{
    public function turnOn(string $param1, int $param2): bool
    {
        // ... implementation
    }
}

class Motocicle extends Vehicle
{
    public function turnOn(string $param1, int $param2): bool
    {
    	// ... override with a new behavior
    }
}

Polimorfismo

Sobreposição (Override)

class Vehicle
{
    public function turnOn(string $param1, int $param2): bool
    {
        // ... implementation
    }
}

class Motocicle extends Vehicle
{
    public function turnOn(string $param1, int $param2): bool
    {
    	// ... override with a new behavior
    }
}

Polimorfismo

Assinaturas diferentes

Mesma classe

Sobrecarga (Overload)

Polimorfismo

Sobrecarga (Overload)

public class DataHelper {
    private int dia;
    private String mes;
    private int ano;
    
    public DataHelper() {
        this.dia = "19";
        this.mes = "10";
        this.ano = "2019";
    }

    public DataHelper(int dia) {
        this.dia = dia;
        this.mes = "10";
        this.ano = "2019";
    }

    public DataHelper(int dia, String mes) {
        this.dia = dia;
        this.mes = mes;
        this.ano = "2019";
    }
}

Polimorfismo

Sobrecarga (Overload)

public class DataHelper {
    private int dia;
    private String mes;
    private int ano;
    
    public DataHelper() {
        this.dia = "19";
        this.mes = "10";
        this.ano = "2019";
    }

    public DataHelper(int dia) {
        this.dia = dia;
        this.mes = "10";
        this.ano = "2019";
    }

    public DataHelper(int dia, String mes) {
        this.dia = dia;
        this.mes = mes;
        this.ano = "2019";
    }
}

Pilares

A

E

H

P

Coesão e

Acomplamento 

Coesão

indica o grau de relação

entre os membros de um módulo

Acoplamento

indica o grau de dependência

entre classes

Códigos com

mau cheiro

(Code Smell)

Rigidez

tendência do software ser

difícil de alterar, mesmo que sejam coisas simples

Efeito Colateral

(Fragilidade)

tendência do programa "estragar" ou "quebrar" em muitos lugares quando uma única modificação é feita

Imobilidade

quando existem partes do seu software que poderiam

ser úteis em outro sistema...

Imobilidade

...mas o esforço e os riscos para separar as partes

são muito grandes

Complexidade Desnecessária

quando existem elementos que

não serão úteis no momento

é quando um mesmo código

aparece inúmeras vezes, de formas um pouco diferentes

Repetição Desnecessária

(DRY - Don't Repeat Yourself)

se você usa muito o recurso do Find and Replace é porque você tá com muita repetição de código

Repetição Desnecessária

(DRY - Don't Repeat Yourself)

Repetição Desnecessária

(DRY - Don't Repeat Yourself)

class TV
{
    private $ligado = false;
    
    public function ligar()
    {
        if ($this->ligado === true) {
            return;
        }
        
        $this->ligado = true;
    }
    
    public function desligar()
    {
        if ($this->ligado === false) {
            return;
        }
        
        $this->ligado = false;
    }
}

Repetição Desnecessária

(DRY - Don't Repeat Yourself)

class TV
{
    private $ligado = false;
    
    public function ligar()
    {
        if ($this->ligado === true) {
            return;
        }
        
        $this->ligado = true;
    }
    
    public function desligar()
    {
        if ($this->ligado === false) {
            return;
        }
        
        $this->ligado = false;
    }
}

Repetição Desnecessária

(DRY - Don't Repeat Yourself)

class TV
{
    private $ligado = false;
    
    public function ligarDesligar(bool $ligar)
    {
        if ($this->ligado === true && $ligar === true) {
            return;
        }
        
        if ($this->ligado === false && $ligar === false) {
            return;
        }
        
        $this->ligado = $ligar;
    }
}

Repetição Desnecessária

(DRY - Don't Repeat Yourself)

class DespachanteMercadoria
{
    public function despacharCeara(array $itens)
    {
        $transportadora = new Transportadora();
        $transportadora->setItens($itens);
        
        return $transportadora->enviar('CE');
    }

    public function despacharAlagoas(array $itens)
    {
        $transportadora = new Transportadora();
        $transportadora->setItens($itens);

        return $transportadora->enviar('AL');
    }
}
class DespachanteMercadoria
{
    public function despacharCeara(array $itens)
    {
        $transportadora = new Transportadora();
        $transportadora->setItens($itens);
        
        return $transportadora->enviar('CE');
    }

    public function despacharAlagoas(array $itens)
    {
        $transportadora = new Transportadora();
        $transportadora->setItens($itens);

        return $transportadora->enviar('AL');
    }
}

Repetição Desnecessária

(DRY - Don't Repeat Yourself)

class DespachanteMercadoria
{
    public function despachar(string $uf, array $itens)
    {
        $transportadora = new Transportadora();
        $transportadora->setItens($itens);

        return $transportadora->enviar($uf);
    }
}

Repetição Desnecessária

(DRY - Don't Repeat Yourself)

Opacidade

refere-se a dificuldade de compreensão de um módulo

Princípios e

Boas Práticas

SOLID

conjunto de princípios que permite um melhor projeto de sistemas

Robert C. Martin

Vulgo: Uncle Bob

SOLID

S

Single Responsibility Principle (SRP)

(Princípio da Responsabilidade Única)

Princípio da Responsabilidade Única

Uma classe deve ter

somente uma razão para mudar

classes devem ter apenas

uma responsabilidade, realizar somente ela e realizá-la bem.

Princípio da Responsabilidade Única

é o combate as:
- Classes faz tudo

- Classes Deus

- Classes Megazord

Princípio da Responsabilidade Única

Evite fazer classes

canivete suíço

Princípio da Responsabilidade Única

História do Jornaleiro

Princípio da Responsabilidade Única

Princípio da Responsabilidade Única

class Vendedor
{
    private $nome;
    private $salario;

    public function calcularSalario()
    {
        $combustivel = 100;
        $alimentacao = 250;
        $comissao = 0.2;

        return $this->salario +
            ($this->salario * $comissao) +
            $alimentacao +
            $combustivel;
    }

    public function imprimirContraCheque()
    {
        // logica complexa de impressao
    }
}

Princípio da Responsabilidade Única

class Vendedor
{
    private $nome;
    private $salario;

    public function calcularSalario()
    {
        $combustivel = 100;
        $alimentacao = 250;
        $comissao = 0.2;

        return $this->salario +
            ($this->salario * $comissao) +
            $alimentacao +
            $combustivel;
    }

    public function imprimirContraCheque()
    {
        // logica complexa de impressao
    }
}

Princípio da Responsabilidade Única

class CalculadoraSalario
{
    public function calcularSalario()
    {
        // implementacao
    }
}

class ImpressoraContraCheque
{
    public function imprimir()
    {
        // implementacao
    }
}

class Vendedor
{
    private $nome;
    private $salario;
}

O

Open-Closed Principle (OCP)

(Princípio do Aberto-Fechado)

Princípio do Aberto-Fechado

"As entidades de software devem ser ABERTAS para ampliação, mas FECHADAS para modificação."

D

Dependency Inversion Principle (DIP)

(Princípio da Inversão de Dependência)

Princípio da Inversão de Dependência

módulos de alto nível não devem depender de módulos de baixo nível

módulos de alto nível devem depender de abstrações e não de implementações

Princípio da Inversão de Dependência

módulos de baixo nível também devem depender de abstrações

Princípio da Inversão de Dependência

a utilização desse princípio faz

com que suas classes tenha baixo acoplamento

Princípio da Inversão de Dependência

usa e abusa da injeção de dependências para alcançar

a inversão

Princípio da Inversão de Dependência

class A
{
    // .. Implementation
}

class B
{
    private $a;
    
    public function __construct()
    {
        $this->a = new A();
    }
}

Princípio da Inversão de Dependência

class A
{
    // .. Implementation
}

class B
{
    private $a;
    
    public function __construct()
    {
        $this->a = new A();
    }
}

Princípio da Inversão de Dependência

interface AInterface
{
    // Implementation
}

class A implements AInterface
{
    // .. Implementation
}

class B
{
    private $a;
    
    public function __construct(AInterface $a)
    {
        $this->a = $a;
    }
}

Princípio da Inversão de Dependência

Tell Don't Ask

não peça informações para

fazer o seu trabalho, apenas DIGA para o objeto que possui a informação para fazer o trabalho!

Tell Don't Ask

Tell Don't Ask

$nf = new NotaFiscal();

$item1 = new NotaFiscalItem('Notebook', 1500);
$item2 = new NotaFiscalItem('Monitor', 800);

$nf->itens[] = $item1;
$nf->itens[] = $item2;
$nf->total = $item1->getPreco() + $item2->getPreco();

foreach ($nf->itens as $item) {
    echo "
        {$item->getDescricao()} |
        Preço: {$item->getPreco()}
    ";
}

Tell Don't Ask

$nf = new NotaFiscal();

$item1 = new NotaFiscalItem('Notebook', 1500);
$item2 = new NotaFiscalItem('Monitor', 800);

$nf->itens[] = $item1;
$nf->itens[] = $item2;
$nf->total = $item1->getPreco() + $item2->getPreco();

foreach ($nf->itens as $item) {
    echo "
        {$item->getDescricao()} |
        Preço: {$item->getPreco()}
    ";
}

Tell Don't Ask

$nf = new NotaFiscal();

$item1 = new NotaFiscalItem('Notebook', 1500);
$item2 = new NotaFiscalItem('Monitor', 800);

$nf->itens[] = $item1;
$nf->itens[] = $item2;
$nf->total = $item1->getPreco() + $item2->getPreco();

foreach ($nf->itens as $item) {
    echo "
        {$item->getDescricao()} |
        Preço: {$item->getPreco()}
    ";
}

Tell Don't Ask

$nf = new NotaFiscal();

$item1 = new NotaFiscalItem('Notebook', 1500);
$item2 = new NotaFiscalItem('Monitor', 800);

$nf->itens[] = $item1;
$nf->itens[] = $item2;
$nf->total = $item1->getPreco() + $item2->getPreco();

foreach ($nf->itens as $item) {
    echo "
        {$item->getDescricao()} |
        Preço: {$item->getPreco()}
    ";
}

Tell Don't Ask

$nf = new NotaFiscal();

$item1 = new NotaFiscalItem('Notebook', 1500);
$item2 = new NotaFiscalItem('Monitor', 800);

$nf->adicionarItem($item1);
$nf->adicionarItem($item2);

echo $nf->relatorio();

Lei de Demeter

fale com seus amigos mais próximos e não fale com estranhos

Lei de Demeter

você não deve encadear chamadas de métodos.

Lei de Demeter

Lei de Demeter

// PHP
$obj->rotina1()
    ->rotina2()
    ->rotina3()
    ->rotina4()
    ->rotinaN();

// JAVA
obj.rotina1()
   .rotina2()
   .rotina3()
   .rotina4()
   .rotinaN();

Lei de Demeter

Exceção: ela não se aplica a Fluent Interfaces e implementações do Chaining Pattern

(muito usado em Query Builders).

Lei de Demeter

$funcionario = new Funcionario();

$funcionario->setNome("Kilderson")
    ->setSobrenome("Sena")
    ->setEmail("dersonsena@gmail.com")
    ->setCidade("Fortaleza")
    ->setUF("CE");

Object

Calisthenics

(Bônus)

Object Calisthenics

são exercícios de programação formalizado em 9 regras...

Object Calisthenics

... o exercício dessas regras te ajudará a escrever um

código melhor

Object Calisthenics

não é a VERDADE ABSOLUTA e não é regra de sobrevivência

Object Calisthenics

1) somente um nível de indentação por método

Object Calisthenics

Isso para evitar o código hadouken

Object Calisthenics

2) não utilizar a palavra-chave else

Object Calisthenics

2) não utilizar a palavra-chave else

Object Calisthenics

Sim, você consegue viver sem else

2) não utilizar a palavra-chave else

Object Calisthenics

Use e abuse do

Early Return

2) não utilizar a palavra-chave else

Object Calisthenics

2) não utilizar a palavra-chave else

Object Calisthenics

public static function formatDate($date)
{
    $format = DateTime::ATOM;
    
    if ($date instanceof DateTime) {
        $d = $date->format($format);
    } elseif (is_numeric($date)) {
        $d = date($format, $date);
    } else {
        $d = (string) $date;
    }
    
    return $d;
}

2) não utilizar a palavra-chave else

Object Calisthenics

public static function formatDate($date)
{
    $format = DateTime::ATOM;
    
    if ($date instanceof DateTime) {
        $d = $date->format($format);
    } elseif (is_numeric($date)) {
        $d = date($format, $date);
    } else {
        $d = (string) $date;
    }
    
    return $d;
}

2) não utilizar a palavra-chave else

Object Calisthenics

public static function formatDate($date)
{
    $format = DateTime::ATOM;

    if ($date instanceof DateTime) {
        return $date->format($format);
    }

    if (is_numeric($date)) {
        return date($format, $date);
    }

    return (string) $date;
}

2) não utilizar a palavra-chave else

Object Calisthenics

3) encapsular todos os tipos primitivos e strings

Object Calisthenics

Tipos primitivos (int, string e etc) não possuem significados ou representatividade

3) encapsular todos os tipos primitivos e strings

Object Calisthenics

é análogo ao Value-Object

do Domain Driven-Design

3) encapsular todos os tipos primitivos e strings

Object Calisthenics

3) encapsular todos os tipos primitivos e strings

class EmailService
{
    public function __construct(string $email)
    {
    	if (filter_var($email, FILTER_VALIDATE_EMAIL) === false) {
            throw new InvalidEmailException("Invalid E-mail");
        }
        
        return $this->send($email);
    }
}

Object Calisthenics

3) encapsular todos os tipos primitivos e strings

class Email
{
    private $email;
    
    public function __construct(string $email)
    {
        if (filter_var($email, FILTER_VALIDATE_EMAIL) === false) {
            throw new InvalidEmailException("Invalid Email");
        }
        
        $this->email = $email;
    }
}

class EmailService
{
    public function __construct(Email $email)
    {   
        return $this->send($email);
    }
}

Object Calisthenics

4) coleções de primeira classe

Object Calisthenics

4) coleções de primeira classe

se você tiver um conjunto de elementos e quiser manipulá-los, é necessário criar uma classe dedicada (collection) apenas para este conjunto

Object Calisthenics

4) coleções de primeira classe

Object Calisthenics

5) um ponto (ou "->") por linha

Object Calisthenics

5) um ponto (ou "->") por linha

análogo a Lei de Demeter

Object Calisthenics

6) não abrevie

Object Calisthenics

6) não abrevie 

class TabPrcCons
{
    private $srvs;
    
    private $vgc;
    
    private $ttl;
    
    public function calc()
    {
        // ... Implementation
    }
}

Object Calisthenics

6) não abrevie 

class TabelaPrecosConsumidor
{
    private $servicos;
    
    private $vigencia;
    
    private $total;
    
    public function calcular()
    {
        // ... Implementation
    }
}

Object Calisthenics

7) mantenha todas as entidades pequenas

Object Calisthenics

7) mantenha todas as entidades pequenas

é recomendável que uma classe tenha no máximo 50 linhas

 

 e que os pacotes não tenham mais do que 10 arquivos

Object Calisthenics

8) nenhuma classe com mais de duas variáveis de instância

Object Calisthenics

8) nenhuma classe com mais de duas variáveis de instância

Se sua classe tem mais que duas variáveis de instância, é provável que ela esteja fazendo mais de uma responsabilidade.

Object Calisthenics

9) sem getters, setters ou propriedades

Object Calisthenics

9) sem getters, setters ou propriedades 

class Buyer
{
    private $name;
    private $purchases;
    
    public function getName()
    {
        return $this->name;
    }
    
    public function setName($name)
    {
    	$this->name = $name;
    }
    
    public function getPurchases()
    {
        return $this->purchases;
    }
    
    public function setPurchases($purchases)
    {
    	$this->purchases = $purchases;
    }
}

Object Calisthenics

9) sem getters, setters ou propriedades 

class Buyer
{
    private $name;
    private $purchases;
    
    public function __construct(string $name)
    {
        $this->name = $name;
    }
    
    public function getNome()
    {
        return $this->name;
    }
    
    public function addNewPurchase($purchase)
    {
    	$this->purchases[] = $purchase;
    }
}

Object Calisthenics

as regras não são obrigatórias! Utilize as que você se sente mais confortável

Conclusão

Vamos voltar um pouco no tempo...

Conclusão

os princípios de design te ajudarão a projetar códigos melhores

Conclusão

um código mau projetado é um código difícil de mudar

Conclusão

uma classe não deve ser forçada a depender de uma implementação específica

Conclusão

uma classe deve depender de um contrato, abstração ou interface

Conclusão

PREFIRA classes com

alta coesão e baixo acoplamento

Conclusão

sempre equilibre

Pragmatismo com o Bom Senso

Conclusão

Separe construção do objeto da execução dos métodos da interface

Referências

Projetando Software Orientado a Objetos com Qualidade

Marcel dos Santos - PHPSP - @marcelgsantos

PHP the Right Way

Marcel dos Santos - PHPSP - @marcelgsantos

Learning OOP in PHP  

bit.ly/Learning-OOP-in-PHO

Object Calisthenics: 9 regras para aperfeiçoar seus códigos

Marcos Felipe - @omarkdev

CURSO ORIENTAÇÃO OBJETOS

https://www.devtube.com.br

PHPWOMEN40%OFF

Valeu negada!

Kilderson Sena

fb.com/kilderson.sena

@derson_sena

@derson_sena

dersonsena

Eu sei que POO é a pedra do teu sapato (1h 30min)

By Kilderson Sena

Made with Slides.com

Eu sei que POO é a pedra do teu sapato (1h 30min)

  • 302

More from Kilderson Sena