Php 08 Oo

  • 3,171 views
Uploaded on

 

More in: Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
  • Muito boa apresetação sobre php, em especial tratamento de exceções e interceptação.
    Are you sure you want to
    Your message goes here
No Downloads

Views

Total Views
3,171
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
242
Comments
1
Likes
4

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Programação para WEB
      • Regis Pires Magalhães
      • [email_address]
    Programação Orientada a Objetos em PHP
  • 2. Classes e Objetos <?php class Pessoa { private $nome ; function __construct( $nome ) { $this ->nome = $nome ; } function getNome() { return $this ->nome; } function setNome( $nome ) { $this ->nome = $nome ; } } $p = new Pessoa( 'João' ); $q = $p ; $p ->setNome( &quot;Maria&quot; ); echo &quot;{$p->getNome()} < br /> &quot;; echo &quot;{$q->getNome()} < br /> &quot;; ?>
  • 3. Herança <?php require_once ( 'pessoa.php' ); class PessoaFisica extends Pessoa { private $cpf ; function __construct( $nome , $cpf ) { parent ::__construct( $nome ); $this ->cpf = $cpf ; } function getCpf() { return $this ->cpf; } function setCpf( $cpf ) { $this ->cpf = $cpf ; } } $pf = new PessoaFisica( 'Maria' , '123.456.789-00' ); echo &quot;Nome: { $pf ->getNome()} <br/>&quot; ; echo &quot;CPF: { $pf ->getCpf()} <br/>&quot; ; ?>
  • 4. Sobrescrita de Métodos <?php class MinhaClasse { protected function minhaFuncao() { echo &quot;MinhaClasse::minhaFuncao() &quot; ; } } class OutraClasse extends MinhaClasse { public function minhaFuncao() { parent ::minhaFuncao(); echo &quot;OutraClasse::minhaFuncao() &quot; ; } } $classe = new OutraClasse(); $classe ->minhaFuncao(); ?>
  • 5. Sobrecarga de Construtores
    • Em PHP cada classe somente pode ter um único construtor.
    • Assim, não há sobrecarga de construtores:
    <?php class Pessoa { private $nome ; function __construct() { } function __construct( $nome ) { $this ->nome = $nome ; } } ?> Fatal error: Cannot redeclare Pessoa::__construct()
  • 6. include ou require
    • Ambos incluem e avaliam o arquivo informado.
    • A ausência do arquivo especificado no require , interrompe o processamento e produz um Fatal Error .
  • 7. include_once ou require_once
    • Similar a include e require , mas se o arquivo já tiver sido incluído, a inclusão não será feita novamente.
  • 8. autoload
    • Pode-se definir uma função __autoload que é automaticamente chamada caso seja usada uma classe que ainda não foi definida.
    • Isso pode evitar a necessidade de escrever múltiplos includes ou requires.
    <?php function __autoload( $class_name ) { require_once $class_name . '.php' ; } $obj = new MyClass1(); $obj2 = new MyClass2(); ?>
  • 9. autoload <?php class MinhaClasse { function helloWorld() { echo &quot;Hello, World &quot; ; } } ?> <?php function __autoload( $class_name ) { require_once ( $_SERVER [ &quot;DOCUMENT_ROOT&quot; ] . &quot;/classes/ $class_name .php&quot; ); } ?> <?php require_once &quot;autoload.php&quot; ; $obj = new MinhaClasse(); $obj ->helloWorld(); ?> index.php autoload.php MinhaClasse.php
  • 10. Classes e Objetos <?php class A { private $nome ; function __construct( $nome ) { $this ->nome = $nome ; } function oi() { if ( isset ( $this )) { echo 'Oi, ' . $this ->nome. '. Este objeto é instância da classe ' ; echo get_class( $this ). '<br/>' ; } else { echo 'Oi, não sei o seu nome, pois o método está sendo ' ; echo 'executado estaticamente.<br/>' ; } } } class B { function ola() { A::oi(); } } $a = new A( &quot;Maria&quot; ); $a ->oi(); A::oi(); $b = new B(); $b ->ola(); B::ola(); ?>
  • 11. Construtores e Destrutores
    • Construtores pais não são chamados implicitamente pelo construtor da classe filha.
    • Para executar o construtor da classe pai, é necessária uma chamada a parent::__construct() no construtor da classe filha.
    • O método destrutor ou finalizador será chamado assim que todas as referências a um objeto particular forem removidas ou quando o objeto for explicitamente destruído através da função unset() ou ainda quando o programa é finalizado.
    • Destrutores pais não serão chamados implicitamente. Para executar o destrutor pai, deve-se fazer uma chamada explicitamente a parent::__destruct() no corpo do destrutor.
  • 12. Construtores e Destrutores <?php class MinhaClasseDestruivel { function __construct() { print &quot;No construtor<br/>&quot; ; $this ->name = &quot;MinhaClasseDestruivel&quot; ; } function __destruct() { print &quot;Destruindo $this ->name &quot; ; } } $obj = new MinhaClasseDestruivel(); ?>
  • 13. Visibilidade dos membros <?php class MinhaClasse { public $publica = 'Public' ; protected $protegida = 'Protected' ; private $privada = 'Private' ; function imprimeAlo() { echo $this ->publica; echo $this ->protegida; echo $this ->privada; } } $obj = new MinhaClasse(); $obj ->imprimeAlo(); echo $obj ->publica; // Funciona echo $obj ->protegida; // Erro Fatal echo $obj ->privada; // Erro Fatal ?>
  • 14. Visibilidade dos membros <?php class MinhaClasse { public function __construct() { } public function meuPublico() { } protected function meuProtegido() { } private function meuPrivado() { } // Se nada for dito, é public function foo() { $this ->meuPublico(); $this ->meuProtegido(); $this ->meuPrivado(); } } $minhaclasse = new MinhaClasse; $minhaclasse ->foo(); $minhaclasse ->meuPublico(); // Funciona $minhaclasse ->meuProtegido(); // Erro Fatal $minhaclasse ->meuPrivado(); // Erro Fatal ?>
  • 15. :: Operador de Resolução de Escopo
    • Permite acesso a membros estáticos, constantes ou sobrescritos de uma classe.
    <?php class MinhaClasse { const VALOR_CONST = 'Um valor constante' ; } $classname = 'MinhaClasse' ; echo $classname ::VALOR_CONST; echo MinhaClasse::VALOR_CONST; ?>
  • 16. :: Operador de Resolução de Escopo <?php class OutraClasse extends MinhaClasse { public static $meu_estatico = 'variável estática' ; public static function doisPontosDuplo() { echo parent ::VALOR_CONST . &quot; &quot; ; echo self :: $meu_estatico . &quot; &quot; ; } } $classname = 'OutraClasse' ; echo $classname ::doisPontosDuplo(); OutraClasse::doisPontosDuplo(); ?>
    • As palavras reservadas self e parent são usadas para acessar membros de dentro da definição da classe.
  • 17. Inicializações inválidas <?php class SimpleClass { // declarações de membro inválidas public $var1 = 'olá ' . 'mundo' ; public $var2 = <<<FIM olá mundo FIM; public $var3 = 1 + 2 ; public $var4 = self ::myStaticMethod(); public $var5 = $myVar ; } ?>
    • Variáveis , membros de classe ou chamada de função não podem ser usados na inicialização direta de atributos.
  • 18. Inicializações válidas <?php class SimpleClass { // declarações de membro válidas public $var6 = myConstant; public $var7 = self ::classConstant; public $var8 = array ( true , false ); } ?>
  • 19. Membros de Classe <?php error_reporting(E_STRICT); class Foo { public static function umMetodoEstatico() { echo 'oi<br/>' ; } public function umMetodoNaoEstatico() { echo 'olá<br/>' ; } } Foo::umMetodoEstatico(); Foo::umMetodoNaoEstatico(); ?>
    • Chamar métodos não estáticos de maneira estática gera um aviso de nível E_STRICT.
  • 20. Constantes
    • Constantes diferem de variáveis normais no não uso do símbolo $ para declará-las ou usá-las.
    <?php class MinhaClasse { const constante = 'valor constante' ; function mostrarConstante() { echo self ::constante . &quot;<br/>&quot; ; } } echo MinhaClasse::constante . &quot;<br/>&quot; ; $classe = new MinhaClasse(); $classe ->mostrarConstante(); ?>
  • 21. Classes Abstratas <?php abstract class ClasseAbstrata { abstract protected function pegarValor(); abstract protected function valorComPrefixo( $prefixo ); public function imprimir() { print $this ->pegarValor() . '<br/>' ; } } class ClasseConcreta1 extends ClasseAbstrata { protected function pegarValor() { return &quot;ClasseConcreta1&quot; ; } public function valorComPrefixo( $prefixo ) { return &quot; { $prefixo } ClasseConcreta1&quot; ; } } $classe1 = new ClasseConcreta1; $classe1 ->imprimir(); echo $classe1 ->valorComPrefixo( 'FOO_' ) . '<br/>' ; ?>
  • 22. Interfaces <?php interface Animal { public function emiteSom(); } class Gato implements Animal { public function emiteSom() { echo 'Miaaauhh' ; } } class Cachorro implements Animal { public function emiteSom() { echo 'Au, Au' ; } } $a = new Gato(); $b = new Cachorro(); echo &quot; { $a ->emiteSom()} <br/>&quot; ; echo &quot; { $b ->emiteSom()} <br/>&quot; ; ?>
  • 23. final
    • Métodos final NÃO podem ser sobrescritos em classes que o herdem.
    • Classes final não podem ser herdadas por outras classes.
    • O exemplo abaixo não funciona:
    <?php class ClasseBase { protected $id = 0 ; final function getId () { return $this ->id++; } } class ClasseConcreta extends ClasseBase { function getId () { return $this ->id += 2 ; } } ?>
  • 24. final
    • O exemplo abaixo também não funciona:
    <?php final class ClasseBase { // ... } class ClasseConcreta extends ClasseBase { // ... } ?>
  • 25. O método __toString()
    • Retorna a representação de um objeto em forma de string.
    <?php class Pessoa { private $nome ; function __construct( $nome ) { $this ->nome = $nome ; } function __toString() { return $this ->nome; } } $obj = new Pessoa( &quot;Maria&quot; ); echo $obj ; ?>
  • 26. Clonagem de Objetos
    • Uma cópia de objeto é criada usando o comando 'clone'. Isso chama o método __clone() do objeto.
    • O método __clone() de um objeto não pode ser executado diretamente.
  • 27. Clonagem de Objetos <?php class Fone { public $numero , $tipo ; public function __construct( $numero , $tipo ) { $this ->numero = $numero ; $this ->tipo = $tipo ; } } class Pessoa { public $nome , $fone ; public function __construct( $nome , $num_fone , $tipo_fone ) { $this ->nome = $nome ; $this ->fone = new Fone( $num_fone , $tipo_fone ); } public function __clone() { $this ->fone = new Fone( $this ->fone->numero, $this ->fone->tipo); } } $p1 = new Pessoa( 'Maria' , '8633231845' , 'RES' ); $p2 = clone $p1 ; echo ( '<p>Objeto Original:</p>' ); print_r( $p1 ); echo ( '<p>Objeto Clonado:</p>' ); print_r( $p2 ); $p2 ->nome = 'João' ; $p2 ->fone->numero = '8699811234' ; $p2 ->fone->tipo = 'CEL' ; echo ( '<p>Objeto Original:</p>' ); print_r( $p1 ); echo ( '<p>Objeto Clonado:</p>' ); print_r( $p2 ); ?>
  • 28. Interceptação
    • Chamada de métodos e acesso a membros podem ser interceptados pelos métodos __set, __get e __call .
      • __set – intercepta a atribuição de valores a propriedades do objeto (declaradas ou não).
      • __get – intercepta requisições de propriedades do objeto (declaradas ou não).
      • __call – Intercepta chamadas a métodos. Executado automaticamente quando um método inexistente for chamado.
  • 29. Interceptação <?php class Pessoa { private $atributos ; function __set( $nome , $valor ) { $this ->atributos[ $nome ] = $valor ; } function __get( $nome ) { return $this ->atributos[ $nome ]; } function __call( $nome , $params ) { echo &quot;Método chamado: $nome <br/>&quot; ; echo 'Parâmetros: ' ; print_r( $params ); } } $p1 = new Pessoa(); $p1 ->nome = 'Maria' ; $p1 ->fone = '8633231234' ; echo 'Nome: ' . $p1 ->nome . '<br/>' ; echo 'Fone: ' . $p1 ->fone . '<br/>' ; print_r( $p1 ); echo '<br/>' ; $p1 ->meuMetodo( 'PHP' , 123 , 'WEB' ); ?>
  • 30. Instanciação Dinâmica <?php class MinhaClasse { function exibe( $a , $b ) { echo &quot;Parâmetros: $a $b <br/>&quot; ; } } $classe = 'MinhaClasse' ; $metodo = 'exibe' ; $obj = new $classe ; call_user_func( array ( $obj , $metodo ), 'PHP' , 'WEB' ); ?>
  • 31. Tratamento de Erros
    • A forma de manipulação de erro mais simples é abortar a execução da aplicação através da função die() .
    • Controlar erros assim é geralmente ruim, pois abortar a execução do programa normalmente não é o comportamento desejado.
  • 32. Geração e Tratamento de Erros
    • A função trigger_error() gera um erro de um tipo determinado.
    • Tipos de erro:
      • E_USER_ERROR Gera um erro fatal.
      • E_USER_WARNING Gera uma advertência.
      • E_USER_NOTICE Gera uma notificação.
    • A função set_error_handler() define uma função para tratamento de erros.
  • 33. Geração e Tratamento de Erros <?php function trata_erros( $tipo_erro , $msg , $arq , $linha ) { echo $msg . '<br/>' ; if ( $tipo_erro == E_USER_ERROR) { die ; } } set_error_handler( 'trata_erros' ); trigger_error( 'Ocorreu um erro!!!' ,E_USER_WARNING); echo 'Código executado ou não' ; ?>
  • 34. Exceções
    • Uma exceção pode ser disparada (throw), ou capturada (catch).
    • Código rodeado de um bloco try/catch, permite a captura de exceções em potencial.
    • Vários blocos catch podem ser usados para pegar diferentes classes de exceções.
    • A execução normal continuará após o último bloco catch definido na seqüência.
    • Quando uma exceção é lançada, o fluxo normal de execução é interrompido e o PHP tentará achar o primeiro bloco catch correspondente à exceção disparada.
    • Se uma exceção não for capturada, um Erro Fatal será lançado com uma mensagem &quot;Uncaught Exception ...&quot;, a não ser que um tratador tenha sido definido com set_exception_handler() .
  • 35. Exceções
    • Uma exceção é um objeto da classe Exception que contém os seguintes métodos:
    • getMessage() - Retorna a mensagem de erro.
    • getCode() - Retorna o código de erro.
    • getFile() - Retorna o arquivo no qual ocorreu o erro.
    • getLine() - Retorna a linha na qual ocorreu o erro.
    • getTrace() - Retorna um array com as ações até o erro.
    • getTraceAsString() - Retorna as ações em forma de string.
  • 36. Exceções <?php function inverso( $x ) { if ( $x == 0 ) { throw new Exception( 'Divisão por zero.' ); } else return 1 / $x ; } try { echo inverso( 5 ) . '<br/>' ; echo inverso( 0 ) . '<br/>' ; } catch (Exception $e ) { echo $e ->getMessage(), '<br/>' ; } echo 'Fim.' ; ?>
  • 37. Tratador de Exceções
    • A função set_exception_handler() define uma função de tratamento de exceção padrão se uma exceção não for capturada em um bloco try/catch.
    • A execução não parará depois que a função de tratamento for chamada.
    <?php function trata_excecoes ( $ex ) { echo $ex ->getMessage(), '<br/>' ; } set_exception_handler( 'trata_excecoes' ); throw new Exception( 'Exceção ocorreu!!!' ); echo 'Código não executado' ; ?>
  • 38. Comparação de Objetos
    • Operador de comparação (==)
      • Objetos são iguais se possuírem o mesmo conteúdo e forem instâncias da mesma classe.
    • Operador de identidade (===)
      • Objetos são idênticos se referenciam a mesma instância de uma mesma classe.
  • 39. Comparação de Objetos <?php class Pessoa { private $nome ; function __construct( $nome ) { $this ->nome = $nome ; } } $p1 = new Pessoa( 'Maria' ); $p2 = $p1 ; $p3 = new Pessoa( 'Maria' ); echo '$p1 == $p2 - ' . ( $p1 == $p2 ) . '<br/>' ; echo '$p1 == $p3 - ' . ( $p1 == $p3 ) . '<br/>' ; echo '$p1 === $p2 - ' . ( $p1 === $p2 ) . '<br/>' ; echo '$p1 === $p3 - ' . ( $p1 === $p3 ) . '<br/>' ; ?>
  • 40. Comparação de Tipo <?php class Pessoa { } class PessoaFisica extends Pessoa { } $p1 = new PessoaFisica(); var_dump( $p1 instanceof Pessoa); var_dump( $p1 instanceof PessoaFisica); var_dump( $p1 instanceof PessoaJuridica); ?>
    • instanceof é usado para determinar se um objeto é de uma determinada classe: