Orientação a Objetos em PHP

Orientação a Objetos em PHP
Grupo de Usuários de PHP de Mato Grosso do Sul
03/10/09 – José Ricardo da Silva- 2º Workshop do PHPMS - Senac – Campo Grande/MS - Brasil

Conteúdo abordado
✔ Introdução à OO
✔ Definição de classes e instanciação de objetos
✔ Palavras-chave e operadores relativos à OO em PHP
✔ Herança
✔ Interfaces
✔ Conclusões
✔ Perguntas

Intro
✔ Olhe a sua volta. O que você vê?
✔ Objetos reais possuem duas características
✔ Estado
✔ Comportamento
✔ Cachorros
✔ Nome, cor, raça, estão com fome, estão felizes, etc
✔ Latem, buscam coisas, balançam o rabo

Objetos
✔ Objetos podem ser muito simples
✔ Uma lamparina
✔ Estados: acesa ou apagada
✔ Comportamento: pode ser ligada e desligada
✔ Ou muito complexos
✔ Vários estados e vários comportamentos
✔ Podem conter outros objetos
✔ Interagem com outros objetos
✔ Herdam propriedades e comportamentos de outros objetos

Objetos em software
✔ O estado é armazenado em variáveis
✔ E o comportamento é definido através de métodos

Classes
✔ Templates de objetos
✔ Definem estado
✔ Atributos
✔ De objetos e da própria classe
✔ E comportamento
✔ Métodos
✔ De objetos e da própria clase
✔ Palavra-chave: class e new
✔ Novidades: $this e ->

class Cachorro {
var $nome;
var $cor;
var $raca;
var $estaComFome = false;
var $estaFeliz = true;
}
$meuCachorro = new Cachorro();
$meuCachorro -> nome = “bidu”;
$meuCachorro -> cor = “marrom”;
$meuCachorro -> raca = “vira-latas”;

Objeto
✔ Uma instância de uma classe
✔ Armazena dados
✔ Ocupa espaço na memória
Animal
CachorroSubclasse
Objeto

class Cachorro {
var $nome;
var $cor;
var $raca;
}
$meuCachorro -> raca = “vira-latas”;
PHP 4? WTF?

Visibilidade
✔ Introduzidas no PHP5
✔ public
✔ private
✔ protected

class Cachorro {
public $nome;
private $cor;
private $raca;
}

class Cachorro {
public $nome;
private $cor;
private $raça;
private $estaComFome = false;
private $estaFeliz = true;
}
Fatal error: Cannot access
private property
Cachorro::$cor in ...

Encapsulamento
✔ Princípio fundamental de OO
✔ Esconder o estado de um objeto
✔ Troca de estado → Invocação de método
Lembram?

class Cachorro {
private $raca;
private $estaComFome = true;
private $estaFeliz = false;
private $racas = array('vira-latas',
'pastor alemão', 'pitbull');
public function definaRaca($raca) {
if (in_array($raca, $this -> racas))
$this -> raca = $raca;
}
public function comer() {
$estaComFome = false;
$estaFeliz = true;
}
}
$meuCachorro -> definaRaca('pitbull');
$meuCachorro -> comer();

class Cachorro {
public $racas = array('vira-latas',
'pastor alemão', 'pitbull');
public function definaRaca($raca) { … }
...
}
$meuCachorro -> definaRaca($meuCachorro -> racas[1]);
echo $meuCachorro -> racas[2];
new SplMaxHeap();

Encapsulamento - Benefícios
✔ O estado é o que diferencia um objeto de outro
✔ Inclusive de um objeto inválido
✔ Mantém-se o controle sobre como o “mundo”
manipula o objeto
✔ Cachorro de cor “livro” ou de raça “abacate”?
✔ Assume-se que o método funciona
✔ “Como” não é importante, é?
✔ Pressupostos sobre o funcionamento podem trazer
problemas
✔ Manipulação externa de estado → dor de cabeça

Atributos e Métodos de Classe
✔ Sem instanciação de objeto
✔ Palavra-chave: static
✔ Default: public

class Cachorro {
private $nome;
private $cor;
private $raça;
static $racas = array('vira-latas',
'pastor alemão',
'pitbull');
}

class Cachorro {
private $nome;
private $cor;
private $raça;
private static $racas = array('vira-latas',
'pastor alemão',
'pitbull');
}

Static
✔ Nos métodos
✔ Sai a $this
✔ Entra a self
✔ No acesso
✔ Sai o ->
✔ Entra o operador de resolução de escopo
✔::

class Cachorro {
private $nome;
private $cor;
private $raça;
'pastor alemão',
'pitbull');
public static $patas = 2;
if (in_array($raca, self::$racas))
}
}
$cachorro = new Cachorro();
$cachorro -> definaRaca('pitbull');
echo 'Cachorros têm: ' . Cachorro::$patas . 'patas';

class Cachorro {
...
'pastor alemão',
'pitbull');
if (in_array($raca, self::$racas))
}
public static function imprimaRacas() {
// $this? nem pensar
foreach(self::$racas as $raca)
echo $raca . “n”;
}
}
Cachorro::imprimaRacas();

Constantes de classe
✔ É possível definir também valores constantes a uma
classe
✔ Palavra-chave: const

class Cachorro {
private $nome;
private $cor;
private $raca;
const patas = 2; // sem cifrão
}
echo 'Cachorros têm: ' . Cachorro::patas . ' patas';

Herança
✔ No mundo real é comum encontrarmos objetos com
características em comum
Veiculo
Carro Moto Bicicleta Avião
$velocidade
acelerar()
freiar()
$cor

Herança
✔ Hierarquia de classes
✔ Uma super-classe é uma generalização de uma ou mais
subclasses
✔ Subclasses
✔ Herdam os atributos e os métodos de suas super-classes
✔ Podem definir novos atributos e métodos
✔ Mecanismo de reuso
✔ Aumenta a complexidade

class Base {
private $varPrivada = 'privada';
protected $varProtegida = 'protegida';
public $varPublica = 'publica';
private function priFunction() {
echo "Função {$this -> varPrivada} chamadan";
}
protected function proFunction() {
echo "Função {$this -> varProtegida} chamadan";
}
public function pubFunction() {
echo "Função {$this -> varPublica} chamadan";
}
public function outraFuncao() {
$this -> priFunction();
$this -> proFunction();
$this -> pubFunction();
}
}
$obj = new Base();
$obj -> outraFuncao();
Função privada chamada
Função protegida chamada
Função publica chamada

class Base {
}
}
}
}
}
$obj = new Base();
$obj -> varProtegida = 'novo valor';

class Base {
}
}
}
}
}
$obj = new Base();
echo $obj -> varProtegida;

class Base {
}
}
}
}
}
$obj = new Base();
$obj -> proFunction();

class Base {
}
}
}
$this -> priFunction(); $this -> proFunction(); this -> pubFunction();
}
}
class Classe1 extends Base { }
$obj = new Classe1();
Função publica chamada

class Base {
}
}
}
}
}
class Classe1 extends Base {
}
class Base {
}
}
}
}
}
echo "Função {$this -> varPublica} da classe filha chamadan";
}
}
Função publica da classe filha chamada

class Base {
}
}
}
}
}
echo "Função {$this -> varProtegida} da classe filha chamadan";
}
}
Função protegida da classe filha chamada

class Base {
}
}
}
}
}
echo "Função {$this -> varPrivada} da classe filha chamadan";
}
}
Função da classe filha chamada

class Base {
}
}
}
}
}
}
}

class Base {
}
}
}
}
}
}
}
Fatal Error!

abstract class Veiculo {
protected $velocidade;
abstract public function acelerar($qtde);
}
abstract class VeiculoMotorizado extends Veiculo {
protected $nivelDoTanque;
public function nivelDoTanque() {
return $this -> nivelDoTanque;
}
}
class Moto extends VeiculoMotorizado {
public function gireAcelerador($qtde) { … }
public function acelerar($qtde) {
$this -> velocidade += $this -> gireAcelerador($qtde);
}
}
class Carro extends VeiculoMotorizado {
public function piseAcelerador($qtde) { ... }
public function acelerar($qtde) {
$this -> velocidade += $this -> piseAcelerador($qtde);
}
}
$obj = new Carro();
$obj -> acelerar(2);
echo $obj -> nivelDoTanque();

Interfaces
✔ Um contrato
✔ Especificam quais métodos uma classe deve
implementar
✔ Não definem como os métodos devem ser
implementados
✔ São definidas de maneira similar à definição de
classes
✔ Palavras-chave: interface e implements
✔ Métodos sem corpo
✔ Todos os métodos são públicos

interface Bicicleta {
public function mudarDirecao($valor);
public function acelerar($incremento);
public function freiar($decremento);
}
class Trek implements Bicicleta {
public function mudarDirecao($valor) {…}
public function acelerar($incremento) {
// trocando de marcha
$this -> trocaMarcha($this -> marcha - 1);
// acelerando...
}
public function freiar($decremento) { … }
}
class BarraForte implements Bicicleta {
public function acelerar($incremento) { … }
public function freiar($decremento) {
// colocando o pé no chão $decremento vezes
$this -> coloqueOPeNoChao($decremento);
}
}

interface Produto {
public function definirPreco($valor);
public function obterPreco($valor);
}
interface Veiculo {
}
interface Bicicleta extends Veiculo {
public function empinar($grau);
}
interface BicicletaComMarchas extends Bicicleta, Produto {
public function trocarMarcha($incOuDec);
}

class Caloi implements BicicletaComMarchas {
public function definirPreco($valor) {
// …
}
public function obterPreco($valor) { … }
public function mudarDirecao($valor) { … }
public function freiar($decremento) { … }
public function empinar($grau) { … }
public function trocarMarcha($incOuDec) { … }
}

interface Bicicleta {
const TIPO = “terrestre”;
}
class BarraForte implements Bicicleta {
const TIPO = “anfíbio”;
public function freiar($decremento) {
// colocando o pé no chão $decremento vezes
$this -> coloqueOPeNoChao($decremento);
}
}

interface Produto {
public function comprar();
public function definirNome($nome);
public function vender();
}
interface Objeto {
public function girar($direcao);
public function definirNome($nome);
public function remover();
}
interface Bicicleta extends Objeto, Produto {
} ?

Final
✔ Introduzida no PHP5
✔ Previne que classes filhas sobrescrevam um método
✔ Previne que classes sejam extendidas
✔ Não se aplica a propriedades

class Base {
public function test() {
echo "test() foi invocada";
}
final public function maisTestes() {
echo "Mais testes";
}
}
class Filha extends Base {
public function maisTestes() {
echo "oh-oh";
}
}

final class Base {
...
}
class Filha extends Base {
}

Conclusões
✔ Construção de software a partir de objetos que
interagem entre si
✔ Cada um é responsável pela
✔ Manutenção de seu estado
✔ Execução de suas operações
✔ Maior manutenibilidade
✔ Objetos são entidades que encapsulam funcionalidades
✔ Componentes reusáveis
✔ Se um objeto “quebra”, troque-o
✔ Mapeamento
entidades do mundo real → objetos do sistema

About
Site: http://www.josericardo.eti.br

E-mail: contato@josericardo.eti.br

Twitter: http://www.twitter.com/zehzinho
Alguma dúvida? :)

Referências
✔ http://www.php.net/manual
✔ http://www.php.net/manual/en/language.oop5.php
✔ http://www.slideshare.net/sudarsun/object-oriented-design
✔ http://java.sun.com/docs/books/tutorial/java/concepts/index.html

Orientação a Objetos em PHP

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Orientação a Objetos em PHP

Orientação a Objetos em PHP