POO emPHP

Class

➔Classe é um molde➔Foco na Reutilização➔Quando instanciamos criamos um objeto estamos criando algo concreto baseado nesse molde que é a classe.

Atributo

➔Toda Classe possui normalmente Atributo➔OS Atributos são definidos e poderão ser utilizados durante toda a classe.➔ Vejamos o exemplo.

Exemplo de Atributo

●Class Carro{●

●public $cor;●

●public $modelo;●

●public $ligaLeve;

●}

Na pratica

●$gol = new Carro();●$gol->cor = “Preto”;●$gol->modelo = “Gol”;●$gol->ligaLeve = “Eletrica”;●

●$fusca = new Carro();●$fusca->cor = “Amarelo”;●$fusca->modelo = “Fusca”;●$fusca->ligaLeve = “Manual”;

Métodos

●Métodos é umas das partes que compoe uma classe, são açoes daquela classe●Sempre o método vai representar uma Ação●Vejamos nosso exemplo do Carro.

Métodos

●Class Carro{●public $cor;●public $modelo;●public $ligaLeve;●

●Public function andar(){echo “O “.$this->modelo.” andou!”;

●}

●}

Métodos

●$gol = new Carro();●$gol->cor = “Preto”;●$gol->modelo = “Gol”;●$gol->ligaLeve = “Eletrica”;●$gol->andar();●

●Resultado = O Gol andou!.●Perceba que o método é uma função de dentro de uma classe que execulta algo.●Verifique que quando usamos $this->modelo estamos acessando o valor do atributo modelo dentro do método.●

Mas para que serve o tal do$this?

●O $this representa o próprio objetos e a partir dele podemos execulta métodos ou mesmo recuperarmos um valor de um atributo.●

●$carro->andar(), O $this depois que o objetos e instaciado/criado é substituido peo nome do objeto, mas internamente na classe ele sempre fará referência ao $this.●

Passando parâmentros nos métodos.

●Um metodo pode receber vários parâmetros.●

●public function andar($velocidade = 5){echo “O “.$this-modelo.” andou a”.

●$velocidade. “Km/h”;●}●

Métodos construtores

●O método construtor é o método executado no momento que instaciamos o objeto. Normalmente ele serve pra atribuirmos valores aos atributos de nossa classe●

●Veja o exemplo

Exemplo métodos construtor

●Class Carro{●public $cor;●public $modelo;●public $ligaLeve;●

●Public function __construtor($modelo, $cor,$ligaLeve){●$this->modelo = $modelo;●$this->cor = $cor;●$this->ligaLeve = $ligaLeve;●}●}

Na pratica com o cosntrutor

●$gol = new Carro(“Gol”,”Preto”,”Eletrica”); construtor

●Echo $gol->andar(4); execultou o método

●

●Vai imprimir = O Gol andou 4 Km/h.●Perceba que quando passamos os parãmetros no momento da criação, na realidade eles foram passados para o construtor que atribui esse valor ao nossos atributos.●

Modificadores e acesso

●Vocês devem ter se perguntado public??●O public e um modificador de acesso que torna tanto os atributos como os métodos publicos, Como assim?●Assim = $gol->cor = “Preto”;●Perceba que estou alterando o valor do atributo cor diretamente pelo meu objeto.●Normamente isso não é uma boa prática de programaçao.●

O Modificador Private

●O modificar private faz com que o acesso aos atributos e aos métodos sejam feitos somente dentro da classe.●Class Carro{●Private $modelo;●}●$gol = new Carro();●$gol->modelo = “Preto”;●

●Isso dará erros, pois o atributo agora e privado e não temos acesso direto a ele pelo obejto.●Temos acesso somente internamente atravez da classe.

E Agora quem poderar nos ajudar? Os getteres e os setters

●Os getteres e os setteres são métodos que tem exatamente esse mesmo objetivo de fazer com que possamos alterar ou recuperar os valores de nosso atributos, quando estão private.●

●Veja um exemplo.

Exemplogetteres e os setters

●Class Carro{●private $modelo;●

●Public function setModelo($modelo){●$this->modelo = $modelo;●}●Public function getModelo(){●return $this->modelo;●}●

●}●

Na prática

●$carro = new Carro();●$carro->setModelo(“Gol”);●echo $carro->getModelo();●Vai imprimir na tela = Gol.●

●So conseguimos acesso ao atriburo modelo através dos métodos getModelo e setModelo, pelo fato deles estar private.

Mas Qual a vantagem?

●Para ficar mas clara a vantagem de utilizar getteres e setteres, vamos mudar nosso foco de carro e moto para uma conta bancária.●

●Vejamos um exemplo.

Class Conta

●Class Conta{●Private $saldo = 0;●

●Public function setSaldo($saldo){$this->saldo = $saldo;

●}●Public function getSaldo(){return $this->saldo;

●}●}

Na Pratica

●$conta = new Conta();●$conta->setSaldo(100000000);●Echo $conta->getSaldo();●

●Já pensou se todo banco fosse assim?●Você mesmo podendo escolher o seu saldo bancário?●Então é claro que tem mais segurança, então bora implementar segurança nesse sistema.

Class Conta

●Class Conta{●Private $saldo = 0;●

●Public function getSaldo(){return $this->saldo;

●}●Public function depositar($valor){●$this->saldo = $this->saldo + $valor;●}●}

Agora sim mas seguro

●$conta = new Conta();●$conta->getSaldo(); Não tenho nenhum saldo●$conta->depositar(100);●$conta->getSaldo(); Vai teronar os 1ooR$●$conta->depositar(50);●$conta->getSaldo(); Vai retornar o saldo total:150●

●Se eu tentar roubar o banco virtualmente?●$conta->saldo = 1000000;●Teremos um belo de um erro, poiso atributo saldo e private, só pode manipulado internamente pela class.

Herança

●A herança é algo que facilita bastante a vida do programador, quando pensamos em herança lembramos do que?

●Muitos de nós vemos a árvore geneálógica, com ávos, pais e filhos, mas na verdade quando se usa herança na programação e a reutilização de codigos, classes, atributos e ações.●

●Vamos ver na pratica.

Class Itau

●Class Itau{●private $taxa_por_saque = 5;●private $saldo = 0;●

●public function getTaxaPorSaque(){● return $this->taxa_por_saque;●}●public function getSaldo(){● return $this->saldo;●}●public function depositar($valor){● $this->saldo += $valor;●}●public function sacar($valor){● if($this->saldo >= $valor){● $this->saldo -= $valor;● $this->saldo -= $this->taxa_por_saque;●}● }●}

Class Bradesco

●class Bradesco{●private $taxa_por_saque = 3;●private $saldo =0;●

●public function getTaxaPorSaque(){●return $this->taxa_por_saque;●}●public function getSaldo(){return $this->saldo;

●}●public function depositar($valor){●$this->saldo += $valor;● }● public function sacar($valor){● if($this->saldo >= $valor){● $this->saldo -= $valor;● $this->saldo -= $this->taxa_por_saque;●}● }●}

Na pratica

●$conta_itau = new Itau();●$conta_itau->depositar(100);●$conta_itau->sacar(50);●echo $conta_itau-> getSaldo(); vai retornar 45, pois o itau cobra 5 R$.●

●$conta_bradesco = new Bradesco();●$conta_bradesco->depositar(100);●$conta_bradesco->sacar(50);●echo $conta_bradesco-> getSaldo(); vai retornar 47, pois o itau cobra 3 R$.●

●Agora eu pergunto? Qual a diferença entre as duas classes?●R: Somente a taxa por saque, pois o resto são totalmente iguais.●

●Agora será que sempre que irei criar uma nova classe terei que duplicar novamente?

E por esses casos que usamos a Herança.

●Então o que realmente iremos fazer, criar uma classe que possa herdar as caracteristicas da class Itau e Bradesco. Onde poderam herdar seus métodos e atributos.●

●Vamos ver na pratica?

Class Banco

●Class Banco{●protected $taxa_por_saques;●protected $saldo =0;●

●Public function getTaxaPorSaque(){●return $this->taxa_por_saque;●}●Public function getSaldo(){●return $this->saldo;●}●Public function depositar($valor){●$this->saldo += $valor;● }● Public function sacar($valor){● if($this->saldo >= $valor){● $this->saldo -= $valor;● $this->saldo -= $this->taxa_por_saque;●}● }●}

O modificador de acesso Protected.

●Você deve ter percebido que não usamos o private $saldo e private $taxa_por_saque.●O private tem visibilidade apenas dentro da própria classe.●

●O protected não tem acesso publico, mas ele dar acesso as suas classes filhas.●Filhas como assim?

Novas classes Itaue Bradesco

●class Itau extends Banco{●protected $taxa_por_saldo = 5;●}●class Bradesco extends Banco{●protected $taxa_por_saldo = 3;●}●

●Herança de forma bem simplificada e isso, Todos os métodos e atributos serão herdados de nossa classe pai, ou seja a classe que estamos estendendo, que no caso e a classe Banco.

Recapitulando

●Todas as regras que alterarmos agora na classe Banco, serão altomaticamente replicadas para as classes Itau e Bradesco.●

●Perceba que sobrescrevemos o valor do atributo protegido (protected).●$taxa_por_saque, pois essa era a única diferença entre as duas classes.

Classes abstratas

●O ponto principal de uma classe abstrata é que ela jamais poderá ser instaciada.

●Ex: $banco = new Banco();●

●Agora eu pergunto teria algum sentido eu instanciar essa classe? Criar esse objeto?

Modificando nossaclasse Banco

●abstract class Banco{●protected $taxa_por_saques;●protected $saldo =0;●

●abstract public function desconto;●

●Public function getTaxaPorSaque(){●Return $this->taxa_por_saque;●}●Public function setSaldo(){●Return $this->saldo;●}● Public function depositar($valor){● $this->saldo += $valor;● }● Public function sacar($valor){● if($this->saldo >= $valor){● $this->saldo -= $valor;● $this->saldo -= $this->taxa_por_saque;●}● } ●}

Mais o que esse abstract significa?

●Que a partir de agora a classe Banco ele servirar apenas para ser extendida por outras classes.●Se você tentar instaciar um objeto de Banco receberá um belo de um erro.●

●Exemplo = $banco = new Banco();●

●Teremos um erro, pois Banco é uma classe abstrata. Quer dizer então que posso criar outro objeto? Exemplo $santader = new Banco();