PHP 5.3 - Classes e Objetos

Orientação
a Objetos
Bacharel em Ciência da Computação (UFG)
Especializando em Engenharia de Software
Analista de Sistemas – SIGMA / MDIC

Professor Formador EAD – NEAD/ETEB
george@georgemendonca.com.br
http://www.georgemendonca.com.br
Orientação a Objetos
• Introdução
– No PHP 5 foi desenvolvido um novo Modelo de Objetos.
– O tratamento de objetos foi completamente reescrito,

permitindo uma performance melhor e mais vantagens.
– Versão atual: PHP 5.3.
13/02/2011 2
• 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
13/02/2011 3
• Introdução
Diagrama de Classe Class Php4
{
/**
* Atributos simples
*/
var $a;
var $b;
var $c;
/**
* Método construtor da classe PHP 4
* Métodos simples
*/
function Php4()
{
}
}
13/02/2011 4
• 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.
13/02/2011 5
• Introdução
Diagrama de Classe Class Php5
{
/**
* Visibilidade de atributos
*/
private $a;
private $b;
private $c;
/**
* Método construtor da classe PHP 5
* Visibilidade de métodos
*/
public function __construct()
{
}
}
13/02/2011 6
• Escrevendo uma classe
– Toda definição de classe 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 da classe.
13/02/2011 7
• Escrevendo uma classe
Class Nome_da_Classe
{
encapsulamento $atributos;
...
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]
}
...
}
13/02/2011 8
• 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 que chama o método ou

o atributo.
13/02/2011 9
• A variável $this
Class Classe
{
encapsulamento $atributo;
...
encapsulamento function nome_metodo()
{
// A variável $this referencia o objeto
return $this->atributo;
}
...
}
13/02/2011 10
• 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 possa vir a precisar no momento em que
é instanciado.
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.
13/02/2011 11
• Construtores e Destrutores
Class ConstrutorDestrutor
Diagrama de Classe { 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
13/02/2011
} chamado explicitamente.
12
• Encapsulamento de atributos e métodos
– O encapsulamento (visibilidade) de um atributo ou método pode
ser definido prefixando a declaração com as palavras-chave:
• public
• protected
• 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/02/2011 13
• Encapsulamento de atributos e métodos
Diagrama de Classe 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
}
13/02/2011 } 14
• 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).
13/02/2011 15
<?php
require_once './class/php4.php';
require_once './class/php5.php';
require_once './class/ConstrutorDestrutor.php';
require_once './class/Encapsulamento.php';
$oPhp4 = new Php4();

$oPhp5 = new Php5();
$oConstr = new ConstrutorDestrutor(1, 2);
$oEncap = new Encapsulamento();
echo "<pre>";
print_r($oPhp4);
print_r($oPhp5);
print_r($oConstr);
print_r($oEncap);
$oConstr->__destruct();
print_r($oConstr);
13/02/2011 16
Saída:
Php4 Object
(
[a] =>
[b] =>
[c] =>
)
Php5 Object
(
[a:Php5:private] =>
[b:Php5:private] =>
[c:Php5:private] =>
)
ConstrutorDestrutor Object
(
[a:ConstrutorDestrutor:private] => 0
[b:ConstrutorDestrutor:private] => 0
)
Encapsulamento Object
(
[atributoPublico] =>
[atributoProtegido:protected] =>
13/02/2011 [atributoPrivado:Encapsulamento:private] => 17
)
• Exercitando
– Crie a seguinte classe com nome Funcionario e a manipule através

de um arquivochamado appFuncionario.php.
– Diagrama de classe:
13/02/2011 18
• 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.
– Tal conceito é conhecido também como Generalização.
– Herança permite que a classe filha usufrua das propriedades e
comportamentos da classe pai, assim como a alteração de tais
comportamentos e a criação de novas propriedades e atributos
específicos.
13/02/2011 19
• 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 (::).
13/02/2011 20
• Herança no PHP Diagrama de Classe
– Vejamos o diagrama ao lado.
– A classe Dependentes estende a classe

Funcionario, aplicando o conceito de
generalização (herança).
– A classe Dependentes herda as

propriedades e atributos da classe
Funcionario.
13/02/2011 21
• Herança no PHP
– Código fonte:
<?php
class Dependentes extends Funcionario

{
private $dependentes = array();
public function __construct($dependentes)

{
public function imprimeDadosFuncionario()

{
}
}
13/02/2011 22
• Herança no PHP
– Exemplo: Implementação prática.
class Dependentes extends Funcionario // Dependentes.php
{
private $dependentes = array();
public function __construct($dependentes)
{
$this->dependentes = $dependentes;
}
public function imprimeDadosFuncionario()
{
echo 'Matrícula: '.$this->getMatricula().'<br /><br />';
echo 'Nome: '.$this->getNome().'<br /><br />';
echo 'RG: '.$this->getRg().'<br /><br />';
echo 'Departamento: '.$this->getDepartamento().'<br /><br />';
echo 'Dependentes: <br />';
foreach ($this->dependentes as $value)
{
echo ' - '.$value.'<br />';
}
}
13/02/2011 } 23
• Herança no PHP
– Exemplo: … continuação da Implementação prática.
// appFuncDependentes.php Saída:
require_once './class/Funcionario.php';
require_once './class/Dependentes.php'; Ficha do funcionário: Matrícula: 777
$dependentes = array('Maria', 'Pedro', 'Lucas'); Nome: George
$funcionario = new Dependentes($dependentes); RG: 1234567
$funcionario->setMatricula('777'); Departamento: Informática

$funcionario->setNome('George');
$funcionario->setRg('1234567'); Dependentes:
$funcionario->setDepartamento('Informática'); - Maria
- Pedro
echo 'Ficha do funcionário: '; - Lucas
$funcionario->imprimeDadosFuncionario();
13/02/2011 24
• 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:
13/02/2011 25
Classe Funcionario
• Referência do objeto
– Sempre que uma variável do tipo objeto é atribuida a uma
outra variável, ele recebe somente a referência deste objeto.
– Tais variáveis referenciam exatamente o mesmo objeto.
// appReferenciaObjeto.php
$novoFuncionario = $funcionario;
$funcionario->setDepartamento('RH');
echo "A matrícula do funcionário é: {$novoFuncionario->getDepartamento()}";
Saída:
A matrícula do funcionário é: RH
13/02/2011 26
• 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.
// appClonagemObjeto.php
$novoFuncionario = clone $funcionario;
$funcionario->setDepartamento('RH');
echo "A matrícula do funcionário é: {$funcionario->getDepartamento()} <br />";
echo "A matrícula do funcionário é: {$novoFuncionario->getDepartamento()}";
Saída:
A matrícula do funcionário é: RH
13/02/2011 A matrícula do funcionário é: 27
• 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.
13/02/2011 28
– 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).
13/02/2011 29
Diagrama de Classe // Classe Matematica
class Matematica
{
public static function soma( $a, $b )
{
return $a + $b;
}
}
// appMatematica.php
Saída: $num1 = 4;
$num2 = 5;
9 echo Matematica::soma($num1, $num2);
-1 echo '<br />';
20 echo Matematica::subtracao($num1, $num2);
0.8 echo '<br />';
echo Matematica::multiplicacao($num1, $num2);
echo '<br />';
echo Matematica::divisao($num1, $num2);
13/02/2011 30
• Exercícios
– Primeira etapa do exercício:
• Transformar os métodos da classe Site em estáticos e testá-los. Esta alteração
na implementação será padrão para nossos projetos.
Diagrama de Classe
13/02/2011 31
• Exercícios
– Agora vamos criar uma classe utilitária chamada Util:
(1) 3 métodos: printVar(), printR() e printDump() para depurarmos (com as
funções print_r() e var_dump()) os dados em variáveis, arrays, objetos, etc.
(2) 1 Método httpRequest: para abstrair o acesso de variáveis de requisição
HTTP através dos métodos de envio de dados GET ou POST.
(3) 2 métodos setSession() e getSession() para recuperarmos e inserirmos dados
de sessão.
Diagrama de Classe
13/02/2011 32
• 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.

13/02/2011 33
– 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).
13/02/2011 34
– 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).
13/02/2011 35
// FuncionarioOverloading.php
– Sobrecarregando os class FuncionarioOverloading
{
atributos da classe private $matricula = null;
private $nome = null;
private $rg = null;
Funcionario dos protected $departamento = null;
exemplos anteriores: public function __construct( ) { }
public function __get( $atributo )

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

{
$this->$atributo = $valor;
}
13/02/2011 } 36
– Sobrecarregando os atributos da classe Funcionario dos
exemplos anteriores:
// appFuncOver.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 "<br/><strong>Dados do funcionário</strong><br />

- Matrícula: {$funcionario->__get('matricula')}
- Nome: {$funcionario->__get('nome')}
- RG: {$funcionario->__get('rg')}
13/02/2011 - Departamento: {$funcionario->__get('departamento')}"; 37
– 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
13/02/2011 - RG: 1234567 38
- 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.
13/02/2011 39
• Iteração de Objetos
Diagrama de Classe
Class Iteracao
{
public $nome = "George";
public $casado = true;
public $idade = 28;

}
Saída:
// appIteracaoObjetos.php
nome : George $objeto = new Iteracao();
casado : 1
idade : 28 foreach ($objeto as $atributo => $valor)
{
print "$atributo : $valor <br />";
}
Objeto da classe Atributo da classe Valor do atributo

13/02/2011 40
• Indução de Tipo
– PHP 5 implementa indução de tipo.
– Neste conceito, funções e métodos podem forçar que

parâmetros devem ser um objeto 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).

13/02/2011 41
• 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<br /> Saída:
Pato: $cardapio->pato<br />
Assados: $this->assados"; Galinha: có có có!
} Pato: quá quá quá!
} Assados: Hummmm!
$aves = new Aves(); // appAves.php

$assarAves = new AssarAves();
13/02/2011 $assarAves->cardapio($aves); 42
• 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.
13/02/2011 43
• Reflection API
// appReflexao.php
$refClasslIter = new ReflectionClass('IteracaoObjetos');
$refClasslFunc = new ReflectionClass('Funcionario');
echo '<strong>Propriedades da classe IteracaoObjetos:</strong> <br />';

foreach ($refClasslIter->getProperties() as $value)
{
echo $value.'<br />';
}
echo '<br /><strong>Dados da classe Funcionario:</strong> <br />';
echo "Nome da classe: {$refClasslFunc->getName()} <br />";
echo "Arquivo: {$refClasslFunc->getFileName()} <br />";
Saída:
Propriedades da classe IteracaoObjetos:

Property [ public $nome ]
Property [ public $casado ]
Property [ public $idade ]
Dados da classe Funcionario:

Nome da classe: Funcionario
13/02/2011 44
Arquivo: C:\Program Files\Zend\Apache2\htdocs\php5.3-objetos\class\Funcionario.php
• 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.
13/02/2011 45
– 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
13/02/2011 46
da classe que a define.
– 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:
13/02/2011 47
13/02/2011 48
class X // LateStaticBindings.php // appLateStaticBindings.php
{ TesteX::chamaClasse();
public static function imprimeClasse()
{
echo 'Eu sou a classe '.__CLASS__;
}
public static function chamaClasse()

{
self::imprimeClasse(); Saída:
}
} Eu sou a classe X
class TesteX extends X

{
{
}
}
13/02/2011 49
13/02/2011 50
class Y // LateStaticBindings.php // appLateStaticBindings.php
{ TesteX::chamaClasse();
public static function imprimeClasse() echo '<br />';
{ TesteY::chamaClasse();
}
public static function chamaClasse()

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

{
{
}
}
13/02/2011 51
• 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.
13/02/2011 52
– 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.
13/02/2011 53
– Implementação básica:
function __autoload( $classe )
{
require_once "{$classe}.php";
}
– Exemplo testando as classes Funcionario, Matematica e Util

já implementadas:
require_once './func/autoload.php'; // appAutoloadClasses.php
$funcionario = new Funcionario;
echo $funcionario;
echo '<br />';
echo Matematica::multiplicacao(4, 4);
echo '<br />';
Util::printR($funcionario, __FILE__, __LINE__);
13/02/2011 54
Saída:
Classe Funcionario
16
==========================================================
Arquivo: C:\Program Files\Zend\Apache2\htdocs\php5.3-objetos\appAutoloadClasses.php
Linha: 17
==========================================================
Funcionario Object
(
[matricula:Funcionario:private] =>
[nome:Funcionario:private] =>
[rg:Funcionario:private] =>
[departamento:protected] =>
)
13/02/2011 55
– Avaliação prática:
• E se as classes estiverem separadas em diretórios diferentes? Como
por exemplo nas seguintes pastas:
model/…
view/…
controller/…
Como resolver este problema? Pesquise, implemente e entregue na

próxima aula.
13/02/2011 56
• 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.
13/02/2011 57
– 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.
13/02/2011 58
– 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 ";
}
13/02/2011 59
– Implementação básica:
// appConstantesdaClasse.php
echo
"<p><strong>".CadastroEmpresas::titulo_tela."</strong></p>
<form>
".CadastroEmpresas::nome." <input type='text' value='' /><br />
".CadastroEmpresas::cnpj." <input type='text' value='' /><br />
".CadastroEmpresas::razao_social." <input type='text' value='' /><br /><br />
<input type='submit' value='".CadastroEmpresas::botao_submit."' />
</form>";
Saída:
13/02/2011 60
• 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.
13/02/2011 61
– 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.
13/02/2011 62
– Exemplo 01 - Classe Abstrata Venda
// Classe Abstrata Venda.php
abstract class Venda
{
private $valor = 0.0;
private $desconto = 0.0;
public function __set($atributo, $valor)

{
}
public function __get($atributo)

{
}
}
13/02/2011 63
– Exemplo 01 - Classe Orcamento (herda a classe Venda)
// 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;
}
13/02/2011 } 64
– Exemplo 01 – Testando as classes de Venda
// appVenda.php
$venda = new Orcamento();
Saída:
$venda->__set('valor', 90);
$venda->__set('desconto', 10); === Orçamento ===
echo "<strong> === Orcamento === </strong><br /><br />";
echo "Preco: {$venda->__get('valor')}<br />"; Preço: 90
echo "Desconto: {$venda->__get('desconto')}<br />"; Desconto: 10
echo "A vista: {$venda->vendaVista()}<br />"; À vista: 80
echo "Cheque: {$venda->vendaCheque()}<br />"; Cheque: 89
echo "Cartao: {$venda->vendaCartao()}<br />"; Cartão: 96.2
13/02/2011 65
– Exemplo 02 – Adição do 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);

13/02/2011 } 66
// Classe Orcamento.php
class Orcamento extends Venda
{
...
public function imprimeOrcamento($valor, $desconto)
{
$this->__set('valor', $valor);
$this->__set('desconto', $desconto);
echo "<strong> === Orcamento === </strong><br /><br />";
echo "Preco: {$this->__get('valor')}<br />";
echo "Desconto: {$this->__get('desconto')}<br />";
echo "A vista: {$this->vendaVista()}<br />";
echo "Cheque: {$this->vendaCheque()}<br />";
echo "Cartao: {$this->vendaCartao()}<br /><br />";
}
...
}
13/02/2011 67
// appVenda.php
$a = Util::httpRequest('a');
$b = Util::httpRequest('b');
if(!empty($a) and !empty($b))

{ Saída:
$venda = new Orcamento();
$venda->imprimeOrcamento($a, $b);
echo "<button onclick=\"window.location='appVenda.php'\">
>> Refazer Orçamento
</button>";
}
else
{?>
<form method="post">
Valor <input type="text" name="a" /> <br />
Desconto <input type="text" name="b"> <br />
<input type="submit" value=" >> Gerar Orçamento " />
</form>
<?php
}
13/02/2011 68
• 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.
13/02/2011 69
• 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
13/02/2011 o mesmo nome uma vez que isso causaria ambiguidade. 70
• Interfaces
– Exemplo 01 - Interface OperacoesMatematicas
// Interface 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);

}
13/02/2011 71
• Interfaces
– Exemplo 01 – Classe OpMatematicas que implementa a interface
OperacoesMatematicas
// Classe OpsMatematicas.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 : 'Divsao por zero!';
}
public static function imprimeOperacoes($a, $b)
{
echo "<b>As operacoes matematicas entre $a e $b sao</b>: <br />";
echo "Soma: ".OpMatematicas::soma($a, $b)."<br />";
echo "Subtracao: ".OpMatematicas::subtracao($a, $b)."<br />";
echo "Multiplicacao: ".OpMatematicas::multiplicacao($a, $b)."<br />";
echo "Divisao: ".OpMatematicas::divisao($a, $b)."<br />";
}
13/02/2011 } 72
• Interfaces
– Exemplo 01 – Aplicação appOpMatematicas
// appOpMatematicas.php
$a = Util::httpRequest('a');
$b = Util::httpRequest('b');
if(!empty($a) and !empty($b))

{ Saída:
OpMatematicas::imprimeOperacoes($a, $b);
} As operacoes matemáticas entre 7 e 9 são:
else Soma: 16
{ Subtracao: -2
?> Multiplicacao: 63
<form method="post"> Divisao: 0.77777777777778
1º Número: <input type="text" name="a" /> <br />
2º Número: <input type="text" name="b" /> <br />
<input type="submit" value=" >> Calcular " />
</form>
<?php
}
13/02/2011 73
• 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.
13/02/2011 74
• 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; }
}
class Anuncio2 implements IAnuncioImobiliaria

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

{
public static $dados = 'Sobrado, 5 quartos, 2 salas,
2 cozinhas, 3 garagens, SEPN, Qd. 205, Brasília-DF';
13/02/2011 75
}
• Polimorfismo
// appAnuncios.php
echo '<b>Anúncio imobiliário</b>: <br /><br />';
Anuncio1::imprimeDados();
echo '<br />';
echo '<br />';
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
13/02/2011 76
• 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.
13/02/2011 77
• 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.
13/02/2011 78
• 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.
13/02/2011 79
• 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!');
}
}
}
13/02/2011 80
• 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()} <br />
Linha: {$e->getLine()} <br />
Arquivo: {$e->getFile()} <br />
Codigo: {$e->getCode()}";
}
Saída:
Mensagem: Erro - Divisão por zero!

Linha: 8
Arquivo: D:\Zend\Apache2\htdocs\php5.3-objetos\class\Divisao.php
13/02/2011 Codigo: 0 81
• Simple XML
– O SimpleXML provê um conjunto de ferramentas muito fácil e
simples de usar para converter XML em objetos que podem
ser processados normalmente com seletores de propriedades
e iteradores de arrays.
– A extensão SimpleXML requer PHP 5.
– A extensão SimpleXML é habilitada por padrão.
13/02/2011 82
• Simple XML
– Criando o arquivo XML
// Arquivo biblioteca.xml
<?xml version="1.0" encoding="UTF-8"?>
<biblioteca>
<categoria id="tecnico">
<livro>
<titulo>PHP 5 - Programação Poderosa</titulo>
<autor>Andi Gutmans, Stig Bakken, Derick Rethans</autor>
</livro>
<livro>
<titulo>Zend Framework in Action</titulo>
<autor>Rob Allen</autor>
</livro>
</categoria>
</biblioteca>
13/02/2011 83
• Simple XML
– Criando uma aplicação com a extensão
// appSimpleXml.php
$biblioteca = simplexml_load_file('./inc/biblioteca.xml');
foreach ($biblioteca->categoria as $categoria)
{
echo "Categoria: " . $categoria['id'] . '<br>';
foreach ($categoria->livro as $livro)
{
echo "Titulo: " . $livro->titulo . '<br>';
echo "Autor: " . $livro->autor . '<br>';
}
}
Saída:
Categoria: Técnico
Titulo: PHP 5 - Programação Poderosa
Autor: Andi Gutmans, Stig Bakken, Derick Rethans
13/02/2011 Titulo: Zend Framework in Action 84
Autor: Rob Allen
• Padrões de Projeto
– Os padrões de projeto de software ou padrões de desenho de
software, também muito conhecido pelo termo original em
inglês Design Patterns, descrevem soluções para problemas
recorrentes no desenvolvimento de sistemas de software
orientados a objetos.
13/02/2011 85
– Objetivos
• Reutilização de código
• Melhores práticas de programação
• Solução para problemas do dia a dia
13/02/2011 86
– Singleton
• O Design Pattern Singleton é um dos padrões de projetos mais fáceis
que existe. Ele que garante a existência de uma única instância de
uma determinada classe para um objeto, mantendo um ponto global
de acesso ao seu objeto.
• Este padrão é utilizado consequentemente em implementações que

necessitam de classes que disponibilizam apenas uma instância do
objeto na aplicação.
13/02/2011 87
• Singleton
– Criando a classe
// Classe Singleton.php
class Singleton
{
// instancia da classe
private static $objDaClasse = null;
private function __construct() { /* ... */ }
public static function getObjDaClasse()

{
if (self::$objDaClasse === null)
{
self::$objDaClasse = new Singleton();
}
return self::$objDaClasse;
}
13/02/2011 } 88
• Singleton
– Criando uma aplicação para testar o objeto Singleton
// appSingleton.php Apenas um objeto
$o1 = Singleton::getObjDaClasse(); daclasse é criado em
$o2 = Singleton::getObjDaClasse(); memória
$o3 = Singleton::getObjDaClasse();
echo '<pre>'; Saída:
var_dump($o1);
var_dump($o2); object(Singleton)#1 (0) {
var_dump($o3); }
object(Singleton)#1 (0) {
}
object(Singleton)#1 (0) {
}
13/02/2011 89

PHP 5.3 - Classes e Objetos

Загружено:

Сведения о документе

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

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

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

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

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

PHP 5.3 - Classes e Objetos

Загружено:

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

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

Orientação

Analista de Sistemas – SIGMA / MDIC

– No PHP 5 foi desenvolvido um novo Modelo de Objetos.

– O tratamento de objetos foi completamente reescrito,

– Versão atual: PHP 5.3.

– Uma tentativa a orientação à objetos

– Porém sem muitos conceitos considerados importantes para uma

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

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

– Sua implementação normalmente se encontra dentro do

– $this é uma referência para o objeto que chama o método ou

– PHP 5 permite que os desenvolvedores declarem métodos

public function __construct($a, $b)

– Public podem ser acessados por todo script.

// Visível nas classes e subclasses

// Visível apenas na classe

public function metodoPublico()

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

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

$oPhp4 = new Php4();

– Crie a seguinte classe com nome Funcionario e a manipule através

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

– Em PHP uma classe pode herdar propriedades e métodos de outra classe

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

– Vejamos o diagrama ao lado.

– A classe Dependentes estende a classe

– A classe Dependentes herda as

class Dependentes extends Funcionario

public function __construct($dependentes)

public function imprimeDadosFuncionario()

$dependentes = array('Maria', 'Pedro', 'Lucas'); Nome: George

$funcionario = new Dependentes($dependentes); RG: 1234567

$funcionario->setMatricula('777'); Departamento: Informática

– Correção deste problema convertento para string:

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

– Declarar atributos ou métodos de uma classe

– A palavra reservada STATIC é utilizada na declaração de

– A referência aos atributos estáticos da classe é feita através da

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

– Provê meios dinâmicos para manipular atributos

– Utilizados na manipulação de métodos e propriedades não

– Todos os métodos sobrecarregados devem ser definidos

– Este procedimento é feito através dos métodos mágicos.

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

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

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

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

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

• __callStatic() : acionado ao invocar métodos estáticos inacessíveis em

exemplos anteriores: public function __construct( ) { }

public function __get( $atributo )

public function __set( $atributo, $valor)

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

– PHP 5 fornece uma maneira de definir objetos para que seja

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

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

public $casado = true;

public $idade = 28;

Objeto da classe Atributo da classe Valor do atributo

– PHP 5 implementa indução de tipo.

– Neste conceito, funções e métodos podem forçar que

– Basta especificar o nome da classe no desenvolvimento da

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

Class AssarAves // Classe AssarAves.php