O documento discute conceitos de programação orientada a objetos em PHP, incluindo classes, atributos, métodos, construtores, encapsulamento, herança e classes abstratas. Ele explica como classes definem moldes para objetos e como métodos representam ações, ilustrando com exemplos de classes Carro e Conta Bancária.

1. POO em
PHP

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

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

4. Exemplo de Atributo
●Class Carro{
●
●public $cor;
●
●public $modelo;
●
●public $ligaLeve;
●}

5. 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”;

6. 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.

7. Métodos
●Class Carro{
●public $cor;
●public $modelo;
●public $ligaLeve;
●
●Public function andar(){
echo “O “.$this->modelo.” andou!”;
●}
●}

8. 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.
●

9. 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.
●

10. 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”;
●}
●

11. 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

12. 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;
●}
●}

13. 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.
●

14. 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.
●

15. 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.

16. 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.

17. Exemplo
getteres e os setters
●Class Carro{
●private $modelo;
●
●Public function setModelo($modelo){
●$this->modelo = $modelo;
●}
●Public function getModelo(){
●return $this->modelo;
●}
●
●}
●

18. 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.

19. 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.

20. Class Conta
●Class Conta{
●Private $saldo = 0;
●
●Public function setSaldo($saldo){
$this->saldo = $saldo;
●}
●Public function getSaldo(){
return $this->saldo;
●}
●}

21. 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.

22. Class Conta
●Class Conta{
●Private $saldo = 0;
●
●Public function getSaldo(){
return $this->saldo;
●}
●Public function depositar($valor){
●$this->saldo = $this->saldo + $valor;
●}
●}

23. 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.

24. 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.

25. 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;
●}
● }
●}

26. 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;
●}
● }
●}

27. 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?

28. 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?

29. 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;
●}
● }
●}

30. 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?

31. Novas classes Itau
e 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.

32. 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.

33. 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?

34. Modificando nossa
classe 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;
●}
● }
●

35. 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();