Php 08 Oo

Programação para WEB Regis Pires Magalhães [email_address] Programação Orientada a Objetos em PHP

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( "Maria" ); echo "{$p->getNome()} "; echo "{$q->getNome()} "; ?>

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 "Nome: { $pf ->getNome()} " ; echo "CPF: { $pf ->getCpf()} " ; ?>

Sobrescrita de Métodos <?php class MinhaClasse { protected function minhaFuncao() { echo "MinhaClasse::minhaFuncao()\n" ; } } class OutraClasse extends MinhaClasse { public function minhaFuncao() { parent ::minhaFuncao(); echo "OutraClasse::minhaFuncao()\n" ; } } $classe = new OutraClasse(); $classe ->minhaFuncao(); ?>

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()

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 .

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.

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(); ?>

autoload <?php class MinhaClasse { function helloWorld() { echo "Hello, World\n" ; } } ?> <?php function __autoload( $class_name ) { require_once ( $_SERVER [ "DOCUMENT_ROOT" ] . "/classes/ $class_name .php" ); } ?> <?php require_once "autoload.php" ; $obj = new MinhaClasse(); $obj ->helloWorld(); ?> index.php autoload.php MinhaClasse.php

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 ). ' ' ; } else { echo 'Oi, não sei o seu nome, pois o método está sendo ' ; echo 'executado estaticamente. ' ; } } } class B { function ola() { A::oi(); } } $a = new A( "Maria" ); $a ->oi(); A::oi(); $b = new B(); $b ->ola(); B::ola(); ?>

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.

Construtores e Destrutores <?php class MinhaClasseDestruivel { function __construct() { print "No construtor " ; $this ->name = "MinhaClasseDestruivel" ; } function __destruct() { print "Destruindo $this ->name " ; } } $obj = new MinhaClasseDestruivel(); ?>

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 ?>

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 ?>

:: 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; ?>

:: 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 . "\n" ; echo self :: $meu_estatico . "\n" ; } } $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.

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.

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 ); } ?>

Membros de Classe <?php error_reporting(E_STRICT); class Foo { public static function umMetodoEstatico() { echo 'oi ' ; } public function umMetodoNaoEstatico() { echo 'olá ' ; } } Foo::umMetodoEstatico(); Foo::umMetodoNaoEstatico(); ?> Chamar métodos não estáticos de maneira estática gera um aviso de nível E_STRICT.

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 . " " ; } } echo MinhaClasse::constante . " " ; $classe = new MinhaClasse(); $classe ->mostrarConstante(); ?>

Classes Abstratas <?php abstract class ClasseAbstrata { abstract protected function pegarValor(); abstract protected function valorComPrefixo( $prefixo ); public function imprimir() { print $this ->pegarValor() . ' ' ; } } class ClasseConcreta1 extends ClasseAbstrata { protected function pegarValor() { return "ClasseConcreta1" ; } public function valorComPrefixo( $prefixo ) { return " { $prefixo } ClasseConcreta1" ; } } $classe1 = new ClasseConcreta1; $classe1 ->imprimir(); echo $classe1 ->valorComPrefixo( 'FOO_' ) . ' ' ; ?>

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 " { $a ->emiteSom()} " ; echo " { $b ->emiteSom()} " ; ?>

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 ; } } ?>

final O exemplo abaixo também não funciona: <?php final class ClasseBase { // ... } class ClasseConcreta extends ClasseBase { // ... } ?>

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( "Maria" ); echo $obj ; ?>

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.

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 ( 'Objeto Original:' ); print_r( $p1 ); echo ( 'Objeto Clonado:' ); print_r( $p2 ); $p2 ->nome = 'João' ; $p2 ->fone->numero = '8699811234' ; $p2 ->fone->tipo = 'CEL' ; echo ( 'Objeto Original:' ); print_r( $p1 ); echo ( 'Objeto Clonado:' ); print_r( $p2 ); ?>

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.

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 "Método chamado: $nome " ; echo 'Parâmetros: ' ; print_r( $params ); } } $p1 = new Pessoa(); $p1 ->nome = 'Maria' ; $p1 ->fone = '8633231234' ; echo 'Nome: ' . $p1 ->nome . ' ' ; echo 'Fone: ' . $p1 ->fone . ' ' ; print_r( $p1 ); echo ' ' ; $p1 ->meuMetodo( 'PHP' , 123 , 'WEB' ); ?>

Instanciação Dinâmica <?php class MinhaClasse { function exibe( $a , $b ) { echo "Parâmetros: $a $b " ; } } $classe = 'MinhaClasse' ; $metodo = 'exibe' ; $obj = new $classe ; call_user_func( array ( $obj , $metodo ), 'PHP' , 'WEB' ); ?>

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.

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.

Geração e Tratamento de Erros <?php function trata_erros( $tipo_erro , $msg , $arq , $linha ) { echo $msg . ' ' ; 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' ; ?>

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 "Uncaught Exception ...", a não ser que um tratador tenha sido definido com set_exception_handler() .

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.

Exceções <?php function inverso( $x ) { if ( $x == 0 ) { throw new Exception( 'Divisão por zero.' ); } else return 1 / $x ; } try { echo inverso( 5 ) . ' ' ; echo inverso( 0 ) . ' ' ; } catch (Exception $e ) { echo $e ->getMessage(), ' ' ; } echo 'Fim.' ; ?>

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(), ' ' ; } set_exception_handler( 'trata_excecoes' ); throw new Exception( 'Exceção ocorreu!!!' ); echo 'Código não executado' ; ?>

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.

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 ) . ' ' ; echo '$p1 == $p3 - ' . ( $p1 == $p3 ) . ' ' ; echo '$p1 === $p2 - ' . ( $p1 === $p2 ) . ' ' ; echo '$p1 === $p3 - ' . ( $p1 === $p3 ) . ' ' ; ?>

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:

Php 08 Oo

Mais conteúdo relacionado

Mais procurados

Semelhante a Php 08 Oo

Mais de Regis Magalhães

Php 08 Oo