Uma Abordagem Prática de Orientação a Objetos com PHP (FLISOL DF 2011)

Uma abordagem prática de
Orientação a Objetos com PHP
george@georgemendonca.com.br

http://www.georgemendonca.com.br

Orientação a Objetos
• Introdução
– Versão atual: PHP 5.3 - http://www.php.net/releases.
• 5.3.0 (30/06/2009)

• 5.3.1 (19/11/2009)

• 5.3.2 (04/04/2010)

• 5.3.3 (22/07/2010)

• 5.3.4 (09/12/2010)

• 5.3.5 (06/01/2011)

• 5.3.6 (17/03/2011)
2

• Introdução
– Possui suporte a OO desde a versão 3.

– A versão 4 foi reescrita com o objetivo de tornar mais
rápida e estável.

– No PHP 5 foi desenvolvido um novo modelo de
objetos, completamente reescrito, mais completo,
permitindo uma performance melhor e mais
vantagens.

3

• Introdução
– Diferenças entre o PHP 4 e o PHP 5
• PHP 4 - Classes simples:
– Uma tentativa a orientação à objetos

– Porém sem muitos conceitos considerados importantes para
uma linguagem orientada a objetos

4

• Introdução
Diagrama de Classe <?php
Class Php4
{
/**
* Atributos simples
*/
var $a;
var $b;
var $c;

/**
* Método construtor da classe PHP 4
* Métodos simples
*/
function Php4()
{
}
}
5

• Introdução
• PHP 5 - Classes mais completas e uso de padrões:

– Com implementação de recursos semelhantes às linguagens
de programação como C++ e Java.

6

• Introdução
Class Php5
{
/**
* Visibilidade de atributos (encapsulamento)
*/
public $a;
protected $b;
private $c;

/**
* Método construtor da classe PHP 5
* Visibilidade de métodos
*/
public function __construct()
{
}
}
7

• Escrevendo uma classe
– A definição de uma classe em PHP começa com a
palavra-chave class, seguido do nome_da_classe,
que pode ser qualquer nome que não seja uma
palavra reservada no PHP.

– Seguido por um par de chaves “ { } “, que contém a
definição dos atributos (ou propriedades) e
métodos (ou comportamentos) da classe.

8

• Escrevendo uma classe

<?php
class Nome_da_Classe
{
encapsulamento $atributo1;
...
encapsulamento function nome_metodo( [argumento1, ...] )
{
/**
* Implementação do comportamento do método.
* Como uma função, um método pode retornar
* um valor se necessário.
*/
[return]
}
...
}
9

• A variável $this
– Uma pseudo variável $this está disponível quando
um método da classe é chamado dentro de um
contexto de objeto.

– Sua implementação normalmente se encontra dentro
do escopo de um método.

– $this é uma referência para o objeto ao chamar um
método ou um atributo.

10

<?php
Class Nome_da_Classe
{
encapsulamento $atributo1;
...
encapsulamento function nome_metodo()
{
// A variável $this referencia o objeto
// chamado em tempo de execução no script.
return $this->atributo1;
}
...
}

11

– Observação importante para o entendimento:
• Há uma certa dificuldade em entender a utilização desta variável
em uma classe em qualquer linguagem de programação. Então:

» Imagine uma classe como a planta de uma casa.

» Cada casa construída é um objeto desta planta, porém cada um com

sua implementação específica (local, alterações, material, etc.).

» Relacionando, a variável $this referencia cada objeto criado desta

classe (cada casa construída com base nesta planta). ;D

12

• Encapsulamento de atributos e métodos
– O encapsulamento (ou visibilidade) de um atributo ou de
um método pode ser definido prefixando a declaração
com as palavras-chave:
• public, protected e private.

– Public podem ser acessados por todo script.
– Protected limita o acesso a classes herdadas e para
classe que define o objeto.
– Private limita a visibilidade para apenas a classe que
define o objeto.

13

• Encapsulamento de atributos e métodos
Class Encapsulamento
{
// Visível em todo o script
public $atributoPublico;

// Visível nas classes e subclasses
protected $atributoProtegido;

// Visível apenas na classe
private $atributoPrivado;

public function metodoPublico()
{
// Visível em todos os scripts
}
protected function metodoProtegido()
{
// Visível em classes e subclasses
}
private function metodoPrivado()
{
// Visível apenas na classe
}
} 14

• Construtores e Destrutores
– PHP 5 permite que os desenvolvedores declarem
métodos construtores para as classes. Isto é feito
através do método mágico __construct().

– Classes que tem um método construtor chamam esse
método cada vez que um objeto novo é criado, sendo
apropriado para qualquer inicialização que o objeto
necessite no momento em que é instanciado.

15

• Construtores e Destrutores
<?php
Diagrama de Classe Class ConstrutorDestrutor
O construtor da classe
{ inicializa os valores dos
private $a; atributos do objeto caso
private $b; necessário.

public function __construct($a, $b)
{
$this->a = $a;
$this->b = $b;
}
public function __destruct()
{
$this->a = null; Libera o espaço em
$this->b = null; memória reservado para o
objeto no encerramento
} do script ou quando
} chamado explicitamente.
16

• Instanciando o objeto da classe

– Para criar uma instância de um objeto da classe, um
novo objeto deve ser criado (instanciado) e atribuído à
uma variável.

– Para tanto é necessário a chamada da palavra reservada
new seguido do nome da classe para criar um novo
objeto, instanciando então a classe (ou um objeto da
classe).

17


– Editor utilizado: Eclipse (Eclipse for PHP Developers)

– Estrutura de pasta proposta para os exemplos:

18

<?php
require_once './class/php4.php';
require_once './class/php5.php';
require_once './class/Encapsulamento.php';
require_once './class/ConstrutorDestrutor.php';

$oPhp4 = new Php4();
$oPhp5 = new Php5();
$oEncap = new Encapsulamento();
$oConstr = new ConstrutorDestrutor(1, 2);

echo "<pre>";
print_r($oPhp4);
print_r($oPhp5);
print_r($oEncap);
print_r($oConstr);
$oConstr->__destruct();
print_r($oConstr); 19

Saída:

Php4 Object
(
[a] =>
[b] =>
[c] =>
)

Php5 Object
(
[a:Php5:private] =>
[b:Php5:private] =>
[c:Php5:private] =>
)

Encapsulamento Object
(
[atributoPublico] =>
[atributoProtegido:protected] =>
[atributoPrivado:Encapsulamento:private] =>
) 20

• Exercitando Diagrama de Classe

– Crie a classe ao lado, seus
atributos e métodos e a manipule
através de um arquivo com o
nome appFuncionario.php.

21

• Herança - Conceitos

– Como no mundo real, em orientação a objetos a palavra
herança sugere a construção de uma classe com base em
outra já existente.

– Ou seja, a criação de uma nova classe que herda as
características, propriedades e comportamentos de uma
classe base (ou classe filha) .

22

• Herança - Conceitos
– Tal conceito é conhecido também como Generalização.

– Herança permite que a classe filha usufrua das propriedades e

comportamentos da classe pai (exceto privados), assim como a

alteração de tais comportamentos e a criação de novas

propriedades e atributos específicos.

23

• Herança no PHP
– Em PHP uma classe pode herdar propriedades e métodos de
outra classe usando a palavra-chave extends na sua
declaração.

– Não é possível herdar classes múltiplas, uma classe só pode
herdar uma classe base (ou classe pai, ou ainda classe
genérica).

– Para acessar atributos e métodos da classe pai, utiliza-se a
palavra reservada parent seguida de dois pontos duplos (::).
Nota: Construtores pais não são chamados implicitamente se a classe filha define
um construtor. Para executar o construtor da classe pai, uma chamada a
parent::__construct() dentro do construtor da classe filha é necessária. 24

• Herança no PHP Diagrama de Classe

– Vejamos o diagrama ao lado.

– A classe Dependentes (classe filha)
estende a classe Funcionario (último
exercício), aplicando o conceito de
generalização (herança).

– A classe Dependentes herda as
propriedades e atributos da classe
Funcionario (classe pai).
25

• Herança no PHP
– Implementando o diagrama de classe:

<?php

class Dependentes extends Funcionario
{
private $dependentes = array();

public function __construct($dependentes)
{
// Implementações de inicialização do objeto
}

public function imprimeDadosFuncionario()
{
// Impressão dos dados do Funcionário
}
}

26

• Herança no PHP
– Exemplo: Implementação prática.
<?php
class Dependentes extends Funcionario {

private $dependentes = array();

public function __construct( $dependentes ) {
$this->dependentes = $dependentes;
}

public function imprimeDadosFuncionario() {
echo "Matrícula: {$this->getMatricula()} 
Nome: {$this->getNome()} 
RG: {$this->getRg()} 
Departamento: {$this->getDepartamento()}
 
Dependentes: ";
foreach ($this->dependentes as $value) {
echo " - {$value} ";
}
}
} 27

• Herança no PHP
– Exemplo: Implementação prática (continuação).
<?php Saída:
// appFuncDependentes.php
require_once './class/Funcionario.php'; Ficha do funcionário: Matrícula: 777
require_once './class/Dependentes.php';
Nome: George
//Exercício sobre Herança (Generalização)
$aDpendentes = array('Maria', 'Pedro', 'Lucas'); RG: 1234567

# Instanciando o objeto e passando o array de dependentes Departamento: Informática
$oDependentes = new Dependentes( $aDpendentes );
Dependentes:
# Setando os dados do funcionário - Maria
$oDependentes->setMatricula('777'); - Pedro
$oDependentes->setNome('George'); - Lucas
$oDependentes->setRg('1234567');
$oDependentes->setDepartamento('Informática');

# Imprimindo dados dos dependentes
echo 'Dados dos dependentes: ';
$oDependentes->imprimeDadosFuncionario();
28

• Conversão da classe para string
– Impressão da classe:
// appToString.php
$funcionario = new Funcionario();

echo $funcionario;

– Erro:
Saída:

Catchable fatal error: Object of class Funcionario could not be converted to string in C:...

– Correção deste problema convertento para string:
// Classe Funcionario.php
public function __toString(){
return 'Classe Funcionario';
}

– Resultado: Saída:

Classe Funcionario 29

• Referência do objeto
– Sempre que uma variável do tipo objeto é atribuída a
uma outra variável, ele recebe somente a referência
deste objeto.
– Tais variáveis referenciam exatamente o mesmo
objeto.
<?php
require_once './class/Funcionario.php';

$oFuncionario = new Funcionario(); Departamento inserido
$oNovoFuncionario = $oFuncionario; no primeiro objeto O segundo objeto
também contém o
$oFuncionario->setDepartamento('RH'); Departamento inserido

echo "A matrícula do funcionário é: {$oNovoFuncionario->getDepartamento()}";

Saída:
A matrícula do funcionário é: RH 30

• Clonagem de Objetos
– Necessário quando precisamos clonar um objeto,
criando outro espaço em memória ao invés de uma
referência.
– Neste caso é criada uma nova instância do objeto,
contendo as mesmas propriedades e métodos.
<?php // appClonagemObjeto.php
Um novo objeto é
require_once './class/Funcionario.php'; criado através da
clonagem do primeiro.
$oFuncionario = new Funcionario();
$oNovoFuncionario = clone $oFuncionario;
$oFuncionario->setDepartamento('RH');
$oNovoFuncionario->setDepartamento('Informática');
echo "Departamento: {$oFuncionario->getDepartamento()} ";
echo "Departamento: {$oNovoFuncionario->getDepartamento()}";
Saída:
Departamento: RH
31
Departamento: Informática

• Atributos e Métodos Estáticos

– Declarar atributos ou métodos de uma classe
como estáticos faz deles acessíveis sem precisar
de instanciar a classe.

– A palavra reservada static é utilizada na declaração
de atributos e métodos estáticos.

32

– A referência aos atributos estáticos da classe é feita
através da palavra reservada self seguida de dois pontos
duplos (::) em vez de “$this->”.

– Um atributo declarado como estático não pode ser
acessado com um objeto instanciado da classe
(embora métodos estáticos podem).

33

Diagrama de Classe

<?php // Classe Matematica
class Matematica
{
public static function soma( $a, $b )
{
return $a + $b;
}
}

<?php // appMatematica.php
$num1 = 4;
$num2 = 5;
echo Matematica::soma($num1, $num2);

Saída:

9
34

• Overloading (Sobrecarga)
– Provê meios dinâmicos para manipular atributos
(propriedades) e métodos em PHP.
– Utilizados na manipulação de métodos e
propriedades não declarados explicitamente ou não
visíveis no escopo atual.
– Todos os métodos sobrecarregados devem ser
definidos como públicos.
– Este procedimento é feito através dos métodos
mágicos.
35

– Sobrecarga de atributos:

• __set () : executado para a atribuição de valores em
propriedades inacessíveis.

• __get () : utilizada para retornar valores de propriedades
inacessíveis.

• __isset () : acionado para chamar isset () ou empty () em
propriedades inacessíveis (PHP 5.1.0).

• __unset () : invocado para chamar unset () em propriedades
inacessíveis (PHP 5.1.0).
36

– Sobrecarga de métodos:

• __call () : acionado ao invocar métodos inacessíveis em um
contexto de objeto.

• __callStatic() : acionado ao invocar métodos estáticos
inacessíveis em um contexto de objeto (PHP 5.3.0).

37

– Sobrecarregando os <?php // FuncionarioOverloading.php
atributos da classe Funcionario
class FuncionarioOverloading
{
dos exemplos anteriores:
private $matricula = null;
private $nome = null;
private $rg = null;
protected $departamento = null;

public function __construct( ) { }

public function __get( $atributo )
{
return $this->$atributo;
}

public function __set( $atributo, $valor)
{
$this->$atributo = $valor;
}
} 38

– Sobrecarregando os atributos da classe Funcionario
<?php // appSobrecarga.php
$funcionario = new FuncionarioOverloading();

echo "<pre>";
print_r($funcionario);

$funcionario->__set('matricula','777');
$funcionario->__set('nome','George Mendonça');
$funcionario->__set('rg','1234567');
$funcionario->__set('departamento','Informática');

echo "<pre>";
print_r($funcionario);

echo " Dados do funcionário 
- Matrícula: {$funcionario->__get('matricula')}
- Nome: {$funcionario->__get('nome')}
- RG: {$funcionario->__get('rg')}
- Departamento: {$funcionario->__get('departamento')}"; 39

– Sobrecarregando os atributos da classe Funcionario
Saída:

FuncionarioOverloading Object
(
[matricula:FuncionarioOverloading:private] =>
[nome:FuncionarioOverloading:private] =>
[rg:FuncionarioOverloading:private] =>
[departamento:protected] =>
)

FuncionarioOverloading Object
(
[matricula:FuncionarioOverloading:private] => 777
[nome:FuncionarioOverloading:private] => George Mendonça
[rg:FuncionarioOverloading:private] => 1234567
[departamento:protected] => Informática
)

Dados do funcionário

- Matrícula: 777
- Nome: George Mendonça
- RG: 1234567
40
- Departamento: Informática

• Iteração de Objetos

– PHP 5 fornece uma maneira de definir objetos para
que seja possível iterar atributos públicos de uma
classe, como uma lista de itens.

– Por padrão, todas as propriedades visíveis (públicas)
serão usadas para a iteração.

– Essa iteração é efetualda facilmente com a estrutura
de controle foreach.

41

• Iteração de Objetos
Class Iteracao
{
public $nome = "George";
public $casado = true;
public $idade = 28;
}

<?php // appIteracaoObjetos.php
Saída:
require_once './class/IteracaoObjetos.php';
nome : George
$objeto = new IteracaoObjetos();
casado : 1
idade : 28
foreach ($objeto as $atributo => $valor) {
print "$atributo : $valor ";
}

Objeto da classe Atributo da classe Valor do atributo
42

• Indução de Tipo

– PHP 5 implementa indução de tipo.

– Neste conceito, funções e métodos podem forçar
parâmetros a serem objetos de uma classe.

– Basta especificar o nome da classe no
desenvolvimento da função ou método.

– É possível também aplicar em arrays (PHP 5.1).
43

• Indução de Tipo
Class Aves // Classe Aves.php
{
public $galinha = "có có có!";
public $pato = "quá quá quá!";
}

Class AssarAves // Classe AssarAves.php
{
public $assados = "Hummmm!";

function cardapio( Aves $cardapio)
{
echo "Galinha: $cardapio->galinha Saída:
Pato: $cardapio->pato 
Assados: $this->assados"; Galinha: có có có!
} Pato: quá quá quá!
} Assados: Hummmm!

$aves = new Aves(); // appAves.php
$assarAves = new AssarAves();
$assarAves->cardapio($aves); 44

• Reflection API

– Permite realizar a engenharia reversa de diversos

elementos em PHP5.

– É uma poderosa funcionalidade que nos permite

obter informações e metadados de classes,

objetos, funções, etc.
45

• Reflection API

<?php // appReflexao.php
require_once './class/IteracaoObjetos.php';
require_once './class/FuncionarioOverloading.php';

$refClasslIter = new ReflectionClass('IteracaoObjetos');
$refClasslFunc = new ReflectionClass('FuncionarioOverloading');

echo 'Propriedades da classe IteracaoObjetos: ';
foreach ($refClasslIter->getProperties() as $value) {
echo $value.' ';
}

echo ' Dados da classe Funcionario: ';
echo "Nome da classe: {$refClasslFunc->getName()} ";
echo "Arquivo: {$refClasslFunc->getFileName()} ";

46

• Reflection API

Saída:

Propriedades da classe IteracaoObjetos:
Property [ public $nome ]
Property [ public $casado ]
Property [ public $idade ]

Dados da classe Funcionario:
Nome da classe: Funcionario
Arquivo: C:Program FilesZendApache2htdocsphp5.3-objetosclassFuncionario.php

47

• Late Static Bindings (PHP 5.3)
– Permite referenciar uma classe chamada no contexto
de herança estática.

– Para tanto a palavra reservada static:: é utilizada na
chamada de um método estático, mas não somente
para métodos.

48

– Limitação do self::
• Em um contexto de herança, por exemplo, referências
estáticas são resolvidas usando a classe na qual foi definida,
ou seja, a qual pertence. Mas não na classe a qual foi
chamada em tempo de execução.

– Late Static Bingings
• Resolve tal limitação através da palavra reservada static::
em vez de self::, referenciando a classe chamada em tempo
de execução em vez da classe que a define. 49

– Exemplo
• Vamos implememtar o exemplo seguinte criando as classes
em um mesmo arquivo para facilitar:
– LateStaticBindings.php (classe)

• E para testar vamos implementar o arquivo:
– appLateStaticBindings.php

• Vejamos a implementação a seguir:

50


51

<?php <?php
class X // LateStaticBindings.php // appLateStaticBindings.php
{ TesteX::chamaClasse();
public static function imprimeClasse()
{
echo 'Eu sou a classe '.__CLASS__;
}

public static function chamaClasse()
{ Saída:
self::imprimeClasse();
} Eu sou a classe X
}

class TesteX extends X
{
{
}
}
52


53

<?php <?php
class Y // LateStaticBindings.php // appLateStaticBindings.php
{ TesteX::chamaClasse();
public static function imprimeClasse() echo ' ';
{ TesteY::chamaClasse();
}

public static function chamaClasse() Saída:
{
static::imprimeClasse(); Eu sou a classe X
} Eu sou a classe TesteY
}

class TesteY extends Y
{
{
}
}
54

• Autoload – Carregando classes
automaticamente
– Normalmente ao desenvolver aplicações orientadas a
objeto em PHP os desenvolvedores criam um arquivo
para cada definição de classe.

– Consequentemente uma lista de includes é
necessária para a inclusão de cada classe em
uso. No o PHP5 isso não é mais necessário.
55

• Autoload – Carregando classes automaticamente

– Com a função __autoload quando você tentar usar uma

classe/interface que ainda não foi definida, o script

engine tem uma última chance para carregar a classe

antes que o PHP aponte o erro.

– Esta função é chamada automaticamente.

56

automaticamente
– Implementação a função autoload:
<?php
function __autoload( $classe )
{
require_once "./class/{$classe}.php";
}

– Testando as classes Funcionario e Matematica:
<?php // appAutoloadClasses.php
require_once './func/autoload.php';

$oFuncionario = new Funcionario;
echo $oFuncionario.' ';
echo Matematica::multiplicacao(4, 4).' ';
echo "<pre>";
print_r($oFuncionario);
57

automaticamente

Saída:

Classe Funcionario
16

Funcionario Object
(
[matricula:Funcionario:private] =>
[nome:Funcionario:private] =>
[rg:Funcionario:private] =>
[departamento:protected] =>
)

58

• Constantes do Objeto
– É possível definir valores constantes em cada
classe, permanecendo os mesmos e imutáveis.

– Constantes diferem de variáveis no não uso do
símbolo $ para declará-las ou utilizá-las. Mas
utilizando a palavra reservada const na declaração.

– Assim como os atributos estáticos são referenciadas
ou chamadas através da palavra reservada self do
PHP. 59

– Como os atributos estáticos (static), valores
constantes não podem ser acessados a partir de
uma instância de um objeto (como por exemplo
$object::constante).

– O valor deve ser uma expressão constante, não
podendo ser (por exemplo) uma variável, um
atributo de uma classe, o resultado de uma
operação matemática ou uma chamada de função.
60

– Classe de constantes:

// Classe CadastroEmpresas.php
class CadastroEmpresas
{
const TITULO_TELA = "Cadastro de Empresas";
const NOME = "Nome:";
const CNPJ = "CNPJ:";
const RAZAO_SOCIAL = "Razão Social:";
const BOTAO_SUBMIT = " >> Salvar ";
}
61

• Constantes do Objeto Saída:

– Implementação básica:

<?php // appConstantesdaClasse.php

echo "
".CadastroEmpresas::titulo_tela."
<form>
".CadastroEmpresas::nome." <input type='text' value='' /> 
".CadastroEmpresas::cnpj." <input type='text' value='' /> 
".CadastroEmpresas::razao_social." <input type='text' value='' /> 
<input type='submit' value='".CadastroEmpresas::botao_submit."' />
</form>";
62

• Classes e Métodos Abstratos
– PHP 5 introduz métodos e classes abstratos.

– Não é permitido criar uma instância de uma classe que foi
definida como abstrata.

– Qualquer classe que contêm pelo menos um método
abstrato deve também ser abstrata.

– Métodos definidos como abstratos simplesmente
declaram a assinatura do método, eles não podem
definir a implementação.
63

– Quando uma classe herda uma classe abstrata, todos
os métodos marcados como abstratos na declaração da
classe pai devem ser definidos na classe filha.

– Além disso, esses métodos devem ser definidos com a
mesma visibilidade ou mais fraca.

– Por exemplo, se um método abstrado é definido como
protected, a implementação do método deve ser definida
como protected ou public.
64

– Exemplo 01 - Classe Abstrata Venda
<?php // Classe Abstrata Venda.php
abstract class Venda
{
private $valor = 0.0;
private $desconto = 0.0;

public function __set($atributo, $valor)
{
}

public function __get($atributo)
{
}
}

65

– Exemplo 01 - Classe Orcamento
<?php // Classe Orcamento.php
class Orcamento extends Venda
{
private $taxa = array('cheque' => 1.10, 'cartao' => 1.18 );

public function vendaVista()
{
return $this->__get('valor') - $this->desconto;
}

public function vendaCheque()
{
return ($this->__get('valor')*$this->taxa['cheque']) - $this->desconto;
}

public function vendaCartao()
{
return $this->__get('valor')*$this->taxa['cartao'] - $this->desconto;
}
}
66

– Exemplo 01 – Testando as classes de Venda

<?php // appOrcamento.php
$venda = new Orcamento(); Saída:

$venda->__set('valor', 90); === Orçamento ===
$venda->__set('desconto', 10);
echo " === Orcamento === "; Preço: 90
echo "Preço: {$venda->__get('valor')} "; Desconto: 10
echo "Desconto: {$venda->__get('desconto')} "; À vista: 80
echo "À vista: {$venda->vendaVista()} "; Cheque: 89
echo "Cheque: {$venda->vendaCheque()} "; Cartão: 96.2
echo "Cartão: {$venda->vendaCartao()} ";

67

– Exemplo 02 – Método abstrato imprimeOrcamento
// Classe Abstrata Venda.php
abstract class Venda
{
private $valor = 0.0;
private $desconto = 0.0;

public function __set($atributo, $valor)
{
}

public function __get($atributo)
{
}

abstract function imprimeOrcamento($valor, $desconto);
}
68

– Exemplo 02 – Adição do método abstrato
imprimeOrcamento
// Classe Orcamento.php
class Orcamento extends Venda
{
...
public function imprimeOrcamento($valor, $desconto)
{
$this->__set('valor', $valor);
$this->__set('desconto', $desconto);
echo " === Orcamento === ";
echo "Preço: {$this->__get('valor')} ";
echo "Desconto: {$this->__get('desconto')} ";
echo "À vista: {$this->vendaVista()} ";
echo "Cheque: {$this->vendaCheque()} ";
echo "Cartão: {$this->vendaCartao()} ";
}
...
}
69

– Exemplo 02 – Adição do método abstrato
imprimeOrcamento
Saída:
<?php // appVendaMetodoAbstrato.php
$venda = new Orcamento();

$venda->imprimeOrcamento(90, 10);

70

• Interfaces
– Interfaces de Objetos permitem a criação de código que
especifica quais métodos e variáveis uma classe deve
implementar, sem ter que definir como esses métodos
serão tratados.

– A Interface é um contrato da classe. Interfaces são
definidas usando a palavra-chave 'interface', da mesma
maneira que uma classe comum, mas sem nenhum dos
métodos ter seu conteúdo definido.
71

• Interfaces
– Todos os métodos declarados em uma interface devem ser
public, essa é a natureza de uma interface. Para implementar
uma interface, o operador implements é usado.

– Todos os métodos na interface devem ser implementados na
classe; não fazer isso resultará em um erro fatal.

– Classes podem implementar mais de uma interface se assim
for desejado, separando cada interface com uma vírgula.

Nota: Uma classe não pode implementar duas interfaces que compartilham
o mesmo nome uma vez que isso causaria ambiguidade.
72

• Interfaces
– Exemplo 01 - Interface OperacoesMatematicas

<?php //IOperacoesMatematicas.php
interface IOperacoesMatematicas
{
public static function soma($x, $y);

public static function subtracao($x, $y);

public static function multiplicacao($x, $y);

public static function divisao($x, $y);

public static function imprimeOperacoes($x, $y);
}

73

• Interfaces
– Exemplo 01 – Classe OpMatematicas que implementa a
interface OperacoesMatematicas
<?php // OpMatematicas.php
class OpMatematicas implements IOperacoesMatematicas
{
public static function soma($x, $y){ return $x + $y; }
public static function subtracao($x, $y) { return $x - $y; }
public static function multiplicacao($x, $y) { return $x * $y; }

public static function divisao($x, $y) {
return ($y <> 0) ? $x / $y : 'Divsão por zero!';
}

public static function imprimeOperacoes($a, $b) {
echo "As operacoes matematicas entre $a e $b sao: ";
echo "Soma: ".OpMatematicas::soma($a, $b)." ";
echo "Subtracao: ".OpMatematicas::subtracao($a, $b)." ";
echo "Multiplicacao: ".OpMatematicas::multiplicacao($a, $b)." ";
echo "Divisao: ".OpMatematicas::divisao($a, $b)." ";
}
} 74

• Interfaces
– Exemplo 01 – Aplicação appOpMatematicas
<?php // appOpMatematicas.php

if(isset($_POST['a']) and isset($_POST['b']))
{
$a = $_POST['a']; Saída:
$b = $_POST['b'];
OpMatematicas::imprimeOperacoes($a, $b); As operacoes matemáticas entre 7 e 9 são:
} Soma: 16
else Subtracao: -2
{ Multiplicacao: 63
?> Divisao: 0.77777777777778
<form method="post" id="operacoes">
1º Número: <input type="text" name="a" /> 
2º Número: <input type="text" name="b" /> 
<input type="submit" value=" >> Calcular " />
</form>
<?php
}
75

• Polimorfismo
– É a capacidade de dois ou mais objetos de diferentes
classes responderem à mesma mensagem de
diferentes maneiras. Ou seja, é um recurso que
possibilita que objetos diferentes sejam tratados por uma
interface única.

– O Polimorfismo se define então na implementação de
diversos comportamentos em diferentes classes, que
se relacionam através de uma única Interface ou
Superclasse.
76

• Polimorfismo
interface IAnuncioImobiliaria // IAnuncioImobiliaria.php
{
public static function imprimeDados();
}

class Anuncio1 implements IAnuncioImobiliaria // Anuncio1.php
{ // Anuncio1.php
private static $dados = 'Casa, 2 quartos, sala, cozinha,
R. 37, Qd. 32, JD Oriente, Cuiabá-MT;';
public static function imprimeDados() {echo self::$dados; }
}

{// Anuncio2.php
public static $dados = 'AP, 3 quartos, sala, cozinha, 2 garagens,
R. Barão Franca, Qd. 02, Rodovalho, Goiânia-GO;';
}

{
public static $dados = 'Sobrado, 5 quartos, 2 salas,
2 cozinhas, 3 garagens, SEPN, Qd. 205, Brasília-DF';
} 77

• Polimorfismo
<?php // appAnuncios.php

echo 'Anúncio imobiliário: ';
Anuncio1::imprimeDados();
echo ' ';
echo ' ';

Saída:

Anúncio imobiliário:

Casa, 2 quartos, sala, cozinha, R. 37, Qd. 32, JD Oriente, Cuiabá-MT;
AP, 3 quartos, sala, cozinha, 2 garagens, R. Barão Franca, Qd. 02, Rodovalho, Goiânia-GO;
Sobrado, 5 quartos, 2 salas, 2 cozinhas, 3 garagens, SEPN, Qd. 205, Brasília-DF.

78

• Exceções
– PHP 5 tem um modelo de exceção é similar ao de
outras linguagens de programação. Uma exceção pode
ser disparada (thrown), ou pega (caught ou "catched")
no PHP.

– Podemos implementar um código PHP em um bloco try,
para facilitar a captura de exceções em potencial.

– Cada bloco try, deve ter pelo menos um bloco catch
correspondente.
79

• Exceções
– Vários blocos catch podem ser usados para pegar
diferentes classes de exceções.
– A execução normal (quando nenhuma exceção é
disparada dentro de um bloco try ou quando um
catch compatível com a classe da exceção disparada
não estiver presente) continuará após o último bloco
catch definido na sequência.
– Exceções podem ser disparadas (ou re-disparadas)
dentro de um bloco catch. 80

• Exceções
– Quando uma exceção é disparada, o código logo
após à instrução não será executada, e o PHP
tentará achar o primeiro bloco catch correspondente
à exceção disparada.

81

• Exceções
– Criando uma classe de Exceção para uma classe
// DivisaoException.php
class DivisaoException extends Exception {}

// Divisao.php
class Divisao
{
public function __construct($a, $b)
{
if ($b == 0)
{
throw new DivisaoException('Erro - Divisão por zero!');
}
}
}

82

• Exceções
– Criando uma aplicação para disparar a Exceção
// appException.php
try
{
$divisao = new Divisao(5, 0);
}
catch (DivisaoException $e)
{
echo "Mensagem: {$e->getMessage()} 
Linha: {$e->getLine()} 
Arquivo: {$e->getFile()} 
Codigo: {$e->getCode()}";
}

Saída:

Mensagem: Erro - Divisão por zero!
Linha: 8
Arquivo: D:ZendApache2htdocsphp5.3-objetosclassDivisao.php
Codigo: 0 83

Até o próximo
FLISOL!

85

Uma Abordagem Prática de Orientação a Objetos com PHP (FLISOL DF 2011)

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Uma Abordagem Prática de Orientação a Objetos com PHP (FLISOL DF 2011)

Similaire à Uma Abordagem Prática de Orientação a Objetos com PHP (FLISOL DF 2011) (20)

Plus de George Mendonça

Plus de George Mendonça (20)

Uma Abordagem Prática de Orientação a Objetos com PHP (FLISOL DF 2011)