Avançando com Orientação a Objetos com PHP: Herança, Polimorfismo e Interfaces

Olá pessoal, meu nome é Vinicius Dias e serei seu instrutor nessa segunda parte do treinamento de Orientação a Objetos utilizando o PHP como linguagem de programação. Nesse curso aprenderemos a utilizar código por meio de herança, e entenderemos por que herança não é a solução para todos os problemas - e também como contornar alguns desses problemas por meio de classes e métodos abstratos, interfaces e composição de objetos.

Aprenderemos a organizar o nosso código colocando arquivos em pastas diferentes e separando as classes em pacotes. Ao final, descobriremos um meio de não ser mais necessário fazer o require de cada um dos arquivos de classe, algo que acaba se tornando um problema em determinado momento.

Depois de reorganizarmos o nosso código, entenderemos a fundo como funcionam as classes abstratas, métodos abstratos e interfaces; conheceremos alguns métodos abstratos do PHP; falaremos sobre traits, uma funcionalidade interessante do PHP, mas que deve ser utilizada com cuidado; e discutiremos as diferenças entre classes de serviço e classes de modelo.

Claro, é impossível ensinar todo o conteúdo de orientação a objetos em apenas um treinamento. Eu mesmo aprendo mais sobre esse paradigma todos os dias, portanto é muito importante que esse estudo seja constante.

Espero que esse curso lhe dê uma base bastante sólida para que você continue com seu aprendizado. Se durante o treinamento surgir alguma dúvida, não hesite em entrar em contato conosco por meio do fórum da Alura. Eu mesmo tento responder pessoalmente, e temos também uma comunidade de instrutores e alunos bastante solícita que certamente saberá responder o seu problema.

Bons estudos!

Nesse vídeo iremos relembrar o conteúdo que aprendemos no treinamento anterior. Portanto, se você estiver bem confiante e fez o curso recentemente, poderá seguir alguns passos e então pular para o próximo vídeo. A ideia é adicionarmos um novo atributo à classe Titular para representar o seu endereço, representado por uma nova classe.

Começaremos criando, em "src", a classe Endereco. Nela teremos os atributos privados $cidade, $bairro, $rua e $numero. Como dito no curso anterior, se estiver usando o PHP 7.4, você poderá definir os tipos desses atributos como no exemplo abaixo.

class Endereco
{
    private string $cidade;
    private string $bairro;
    private string $rua;
    private string $numero;
}

Note que definimos o $numero como uma string, e não como um inteiro. Isso porque, se trabalharmos com o $numero sendo um inteiro, podemos ter desperdícios de memória (se utilizarmos números muito grandes) ou termos uma representação não muito consistente. Por exemplo, não conseguiríamos representar "71b" com um inteiro. A ideia central é: se não realizaremos cálculos com os valores de alguma propriedade ou variável, não precisamos defini-la como um tipo numérico.

Como nesse treinamento estamos utilizando o PHP 7.3, versão na qual a tipagem de atributos ainda não era possível, removeremos essas definições do nosos código. No PhpStorm, podemos usar o atalho "Alt + J" do teclado para selecionar vários textos iguais, o que facilitará essa edição.

class Endereco
{
    private $cidade;
    private $bairro;
    private $rua;
    private $numero;
}

Prosseguindo, criaremos um construtor __construct() para inicializar todos os atributos. No PhpStorm, o atalho "Alt + Insert" nos dá acesso à opção "Constructor...", que gera automaticamente um construtor com os atributos selecionados na janela que é aberta em seguida. No nosso caso, selecionaremos todos eles. Depois disso, removeremos o comentário gerado pela IDE e definiremos todos os atributos recebidos no construtor como strings.

class Endereco
{
    private $cidade;
    private $bairro;
    private $rua;
    private $numero;

    public function __construct(string $cidade, string $bairro, string $rua, string $numero)
    {
        $this->cidade = $cidade;
        $this->bairro = $bairro;
        $this->rua = $rua;
        $this->numero = $numero;
    }

}

Além do construtor, precisaremos dos métodos de acesso, ou seja, dos nossos getters, que também criaremos por meio do atalho "Alt + Insert > Getters...".

class Endereco
{
    private $cidade;
    private $bairro;
    private $rua;
    private $numero;

    public function __construct(string $cidade, string $bairro, string $rua, string $numero)
    {
        $this->cidade = $cidade;
        $this->bairro = $bairro;
        $this->rua = $rua;
        $this->numero = $numero;
    }

    public function getCidade(): string
    {
        return $this->cidade;
    }

    public function getBairro(): string
    {
        return $this->bairro;
    }

    public function getRua(): string
    {
        return $this->rua;
    }

    public function getNumero(): string
    {
        return $this->numero;
    }

}

Como temos feito nossos códigos em português, não faz sentido usarmos o verbo get. Portanto, renomearemos nossos métodos com o verbo recupera().

public function recuperaCidade(): string
{
    return $this->cidade;
}

public function recuperaBairro(): string
{
    return $this->bairro;
}

public function recuperaRua(): string
{
    return $this->rua;
}

public function recuperaNumero(): string
{
    return $this->numero;
}

Com o endereço criado, voltaremos à classe Titular e adicionaremos ao construtor o parâmetro Endereco $endereco. Com "Alt + Enter > Initialize Fields" (ou "Initialize Properties"), o PhpStorm se encarregará de adicionar a nova propriedade e fazer a sua atribuição no próprio construtor.

class Titular
{
    private $cpf;
    private $nome;
    private $endereco;

    public function __construct(CPF $cpf, string $nome, Endereco $endereco)
    {
        $this->cpf = $cpf;
        $this->validaNomeTitular($nome);
        $this->nome = $nome;
        $this->endereco = $endereco;
    }
//...

Ainda nessa classe, criaremos também o método recuperaEndereco() que simplesmente retorna $this->endereco. Em banco.php, os pontos em que criamos uma nova conta passarão a apresentar um erro, afinal, além do CPF e do nome, precisamos passar também um endereço.

No nosso caso, imaginaremos que os usuários "Vinicius Dias" e "Patricia" são casados e moram no mesmo endereço. Criaremos então uma variável $endereco recebendo uma nova instância de Endereco com a cidade "Petrópolis", o bairro "um bairro", a rua "minha rua" e o número "71B".

Temos também uma terceira conta, armazenada na variável $outra, para qual criaremos um $outroEndereco com os dados 'A', 'b', 'c' e '1D' representando, respectivamente, cidade, bairro, rua e número.

require_once 'src/Conta.php';
require_once 'src/Titular.php';
require_once 'src/CPF.php';


$endereco = new Endereco('Petrópolis', 'um bairro', 'minha rua', '71B');
$vinicius = new Titular(new CPF('123.456.789-10'), 'Vinicius Dias', $endereco);
$primeiraConta = new Conta($vinicius);
$primeiraConta->deposita(500);
$primeiraConta->saca(300); // isso é ok




echo $primeiraConta->recuperaNomeTitular() . PHP_EOL;
echo $primeiraConta->recuperaCpfTitular() . PHP_EOL;
echo $primeiraConta->recuperaSaldo() . PHP_EOL;




$patricia = new Titular(new CPF('698.549.548-10'), 'Patricia', $endereco);
$segundaConta = new Conta($patricia);
var_dump($segundaConta);


$outroEndereco = new Endereco('A', 'b', 'c', '1D');
$outra = new Conta(new Titular(new CPF('123.654.789-01'), 'Abcdefg', $outroEndereco));
unset($segundaConta);
echo Conta::recuperaNumeroDeContas();

Se executarmos o código dessa forma, teremos um erro, já que nos esquecemos de fazer o require do arquivo Endereco.php. Esse é um problema no qual trabalharemos no futuro. Por enquanto, resolveremos simplesmente fazendo require 'src/Endereco.php'.

require_once 'src/Conta.php';
require_once 'src/Titular.php';
require_once 'src/CPF.php';
require_once 'src/Endereco.php';

Entretanto, uma nova execução continuará apresentando um erro. Isso porque, como nosso Titular precisa de um Endereco, este último precisará ser importado primeiro. Trabalhoso, não? Teremos uma solução mais elegante para isso no futuro, mas por enquanto simplesmente mudaremos a ordem das importações.

require_once 'src/Conta.php';
require_once 'src/Endereco.php';
require_once 'src/Titular.php';
require_once 'src/CPF.php';

Dessa vez a nossa execução acontecerá sem erros. Com isso, revisamos bastante conteúdo do curso anterior, como a criação de uma classe com atributos privados, a criação do construtor e dos métodos de acesso, a composição de objetos e assim por diante. No próximo vídeo começaremos a implementar novas funcionalidades.

Surgiu a necessidade de implementarmos no nosso sistema um módulo que nos permitirá manter um controle de funcionários, que no futuro contará inclusive com um login. Sendo assim, criaremos uma nova classe Funcionario com os atributos $nome, $cpf e $cargo.

class Funcionario
{
    private $nome;
    private $cpf;
    private $cargo;
}

Com o atalho "Alt + Insert", criaremos o construtor da classe e os getters desses atributos, sem nos esquecermos de substituir get por recupera.

class Funcionario
{
    private $nome;
    private $cpf;
    private $cargo;

    public function __construct(string $nome, string $cpf, string $cargo)
    {
        $this->nome = $nome;
        $this->cpf = $cpf;
        $this->cargo = $cargo;
    }

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

    public function recuperaCpf(): string
    {
        return $this->cpf;
    }

    public function recuperaCargo(): string
    {
        return $this->cargo;
    }
}

Porém, repare que nosso Funcionario tem $nome e $cpf, atributos que o Titular também tem. Além disso, nos esquecemos que já existe uma classe CPF e não faz sentido mantermos esse atributo como string no nosso código. Ou seja, além de termos código duplicado, cometemos um erro em relação a como nosso sistema está modelado, causando uma inconsistência em classes semelhantes.

Talvez fosse mais interessante extrairmos o código comum às duas classes para um arquivo separado. Conversaremos sobre essa possibilidade no próximo vídeo.