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:
– Boas práticas:
• Criar uma classe por arquivo e nomear arquivo com o nome da classe
– Ex.: MinhaClasse.php
• Tipificar as variáveis PHP na nomenclatura da variável
– Ex.: $aCidades [ ] = $oCidade (array de cidades recebe objeto cidade)
• Utilize caminho relativo na inclusão de arquivos
– "./pasta/arquivo.php"
• Se tiver somente código PHP não feche a tag PHP (porque?) 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 pai) .
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:
<?php // appToString.php
require_once './class/Funcionario.php';
$oFuncionario = new Funcionario();
echo $oFuncionario;
– Erro:
Saída:
Catchable fatal error: Object of class Funcionario could not be converted to string in \var\www\...
– Correção deste problema convertento para string:

// Adicionar à classe Funcionario (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 <?php // FuncionarioOverloading.php
class FuncionarioOverloading
os atributos da {
private $matricula = null;
private $nome = null;
classe Funcionario private $rg = null;
protected $departamento = null;
dos exemplos
public function __construct( ) { }
anteriores: public function __get( $atributo )

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

{
$this->$atributo = $valor;
}
} 38
– Sobrecarregando os atributos da classe Funcionario
dos exemplos anteriores:
<?php // appSobrecarga.php
require_once './class/FuncionarioOverloading.php';
$oFuncionario = new FuncionarioOverloading();

echo "<pre>";
print_r($oFuncionario);
$oFuncionario->__set('matricula','777');
$oFuncionario->__set('nome','George Mendonça');
$oFuncionario->__set('rg','1234567');
$oFuncionario->__set('departamento','Informática');
echo "<pre>";
echo " Dados do funcionário 

- Matrícula: {$oFuncionario->__get('matricula')}
- Nome: {$oFuncionario->__get('nome')}
- RG: {$oFuncionario->__get('rg')}
- Departamento: {$oFuncionario->__get('departamento')}"; 39
– Sobrecarregando os atributos da classe Funcionario
dos exemplos anteriores:
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
$oIteracao = new IteracaoObjetos();
casado : 1
idade : 28
foreach ($oIteracao 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!
$oAves = new Aves();

$oAssarAves = new AssarAves();
$oAssarAves->cardapio($oAves); 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';
$oRefClasslIter = new ReflectionClass('IteracaoObjetos');

$oRefClasslFunc = new ReflectionClass('FuncionarioOverloading');
echo 'Propriedades da classe IteracaoObjetos: ';

foreach ($oRefClasslIter->getProperties() as $value) {
echo $value.' ';
}
echo ' Dados da classe Funcionario: ';

echo "Nome da classe: {$oRefClasslFunc->getName()} ";
echo "Arquivo: {$oRefClasslFunc->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: /var/www/php5.3-objetos/10-reflexao/class/FuncionarioOverloading.php
47
• 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.
48
• 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.
49
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>";
50
automaticamente
Saída:
Classe Funcionario
16
Funcionario Object
(
[matricula:Funcionario:private] =>
[nome:Funcionario:private] =>
[rg:Funcionario:private] =>
[departamento:protected] =>
)
51
• 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.
52
– 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. 53
– 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:
54
55
<?php <?php // appLateStaticBindings.php
class X // X.php require_once './func/autoload.php';
{
public static function imprimeClasse() TesteX::chamaClasse();
{
echo 'Eu sou a classe '.__CLASS__;
}
public static function chamaClasse() Saída:

{
self::imprimeClasse(); Eu sou a classe X
}
}
class TesteX extends X // TesteX.php

{
public static function imprimeClasse()
{
}
} 56
57
<?php <?php // appLateStaticBindings.php
class Y // Y.php require_once './func/autoload.php';
{
public static function imprimeClasse() TesteX::chamaClasse();
{ echo ' ';
echo 'Eu sou a classe '.__CLASS__; TesteY::chamaClasse();
}
public static function chamaClasse()

{ Saída:
static::imprimeClasse();
} Eu sou a classe X
} Eu sou a classe TesteY
class TesteY extends Y // TesteY.php

{
public static function imprimeClasse()
{
}
} 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 – Calculando o orçamento
<?php // appOrcamento.php
$oOrcamento = new Orcamento(); Saída:
$oOrcamento->__set('valor', 90); === Orçamento ===

$oOrcamento->__set('desconto', 10);
echo " === Orcamento === "; Preço: 90
echo "Preço: {$oOrcamento->__get('valor')} "; Desconto: 10
echo "Desconto: {$oOrcamento->__get('desconto')} "; À vista: 80
echo "À vista: {$oOrcamento->vendaVista()} "; Cheque: 89
echo "Cheque: {$oOrcamento->vendaCheque()} "; Cartão: 96.2
echo "Cartão: {$oOrcamento->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
=== Orçamento ===
$oOrcamento = new Orcamento();
Preço: 90
Desconto: 10
$oOrcamento->imprimeOrcamento(90, 10);
À vista: 80
Cheque: 89
Cartão: 96.2
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

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

{
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
<?php
try {
$oDivisao = 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: /var/www/php5.3-objetos/17-excecoes/class/Divisao.php
Codigo: 0 83
84
Até o próximo
FLISOL!
85

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 (FLISOL DF 2011)

Загружено:

Авторское право:

Доступные форматы

Uma abordagem prática de

Orientação a Objetos com PHP

– A versão 4 foi reescrita com o objetivo de tornar mais

– No PHP 5 foi desenvolvido um novo modelo de

– Porém sem muitos conceitos considerados importantes para

– Com implementação de recursos semelhantes às linguagens

– Seguido por um par de chaves “ { } “, que contém a

– Sua implementação normalmente se encontra dentro

– $this é uma referência para o objeto ao chamar um

» 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

– Public podem ser acessados por todo script.

// Visível nas classes e subclasses

// Visível apenas na classe

public function metodoPublico()

– Classes que tem um método construtor chamam esse

public function __construct($a, $b)

– Para criar uma instância de um objeto da classe, um

– Para tanto é necessário a chamada da palavra reservada

$oPhp4 = new Php4();

– Crie a classe ao lado, seus

– Como no mundo real, em orientação a objetos a palavra

– Ou seja, a criação de uma nova classe que herda as

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

– Não é possível herdar classes múltiplas, uma classe só pode

– Para acessar atributos e métodos da classe pai, utiliza-se a

– Vejamos o diagrama ao lado.

– A classe Dependentes (classe filha)

– A classe Dependentes herda as

class Dependentes extends Funcionario

public function __construct($dependentes)

public function imprimeDadosFuncionario()

private $dependentes = array();

public function __construct( $dependentes ) {

public function imprimeDadosFuncionario() {

# Instanciando o objeto e passando o array de dependentes Departamento: Informática

# Imprimindo dados dos dependentes

– Correção deste problema convertento para string:

$oFuncionario = new Funcionario(); Departamento inserido

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

– Declarar atributos ou métodos de uma classe

– A palavra reservada static é utilizada na declaração

– Um atributo declarado como estático não pode ser

<?php // Classe Matematica

• __set () : executado para a atribuição de valores em

• __get () : utilizada para retornar valores de propriedades

• __isset () : acionado para chamar isset () ou empty () em

• __unset () : invocado para chamar unset () em propriedades

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

• __callStatic() : acionado ao invocar métodos estáticos

anteriores: public function __get( $atributo )

public function __set( $atributo, $valor)

$oFuncionario = new FuncionarioOverloading();

echo "<br/><strong>Dados do funcionário</strong><br />

– PHP 5 fornece uma maneira de definir objetos para

– Por padrão, todas as propriedades visíveis (públicas)

– Essa iteração é efetualda facilmente com a estrutura