Os objetos no PHP5 foram ajustados de forma mais sistemática e abrangente, e sua aparência atual pode ser um pouco semelhante à do Java. Esta seção foca no novo modo de objeto no PHP5 e dá alguns exemplos mais simples para ilustrar. Deixe esta seção ser um novo ponto de partida para sua jornada no PHP5. :)
* Construtor e destruidor
* Referência de objeto
*Clone do objeto
* Modos privados, públicos e protegidos em objetos
* Interfaces
* Aula abstrata
* __chamar
* __set e __get
* Membros estáticos
Construtor e destruidor
No PHP4, quando uma função tem o mesmo nome de um objeto, esta função se tornará o construtor do objeto, e não existe conceito de destruidor no PHP4.
No PHP5, o construtor é denominado uniformemente __construct, e o conceito de destruidor é introduzido, que é denominado uniformemente __destruct.
Exemplo 1: Construtor e destruidor
classe foo {
var$x;
função __construir($x) {
$isto->x = $x;
}
função exibição() {
imprimir($isto->x);
}
função __destruir() {
imprimir("Tchau, tchau");
}
}
$o1 = novo foo(4);
$o1->exibição();
?>
No exemplo acima, quando você encerra a chamada para a classe foo, seu destruidor será chamado e "bye bye" será exibido no exemplo acima.
referências a objetos
, no PHP4, passar uma variável para uma função ou método na verdade faz uma cópia da variável, o que significa que o que você passa para a função ou método é uma cópia da variável, a menos que você use uma referência . O símbolo "&" é usado para declarar que deve ser feita uma referência, não uma cópia. No PHP5, os objetos sempre existem na forma de referências, e as operações de atribuição em objetos também são operações de referência.
Exemplo 2: referência de objeto
classe foo {
var$x;
conjunto de funçõesX($x) {
$isto->x = $x;
}
função getX() {
retorne $isto->x;
}
}
$o1 = novo foo;
$o1->setX(4);
$o2 = $o1;
$o1->setX(5);
if($o1->getX() == $o2->getX()) print("Oh meu Deus!");
?>
Clone de Objeto
Como mencionado acima, quando um objeto é sempre chamado na forma de uma referência, o que devo fazer se quiser obter uma cópia do objeto? PHP5 fornece uma nova função, que é a clonagem de objetos, e a sintaxe é __clone.
Exemplo 3: Clonagem de objetos
classe foo {
var$x;
conjunto de funçõesX($x) {
$isto->x = $x;
}
função getX() {
retorne $isto->x;
}
}
$o1 = novo foo;
$o1->setX(4);
$o2 = $o1->__clone();
$o1->setX(5); if($o1->getX() != $o2->getX()) print（"As cópias são independentes"）;
?>
Existem métodos de clonagem de objetos em muitas outras linguagens de aplicação, portanto você não precisa se preocupar com sua estabilidade. :)
Modos privado, público e protegido em objetos
No PHP4, todos os métodos e variáveis de um objeto são públicos, o que significa que você pode operar qualquer uma das variáveis e métodos fora de um objeto. PHP5 introduz três novos modos para controlar esta permissão de acesso: Público, Protegido e Privado.
Modo público (Public): permite o controle da operação fora do objeto.
Modo privado (Privado): Somente métodos dentro deste objeto têm permissão para operá-lo e controlá-lo.
Modo protegido (Protegido): Permite que este objeto e seu objeto pai o operem e controlem.
Exemplo 4: Modos privado, público e protegido em objetos
classe foo {
privado $x;
função pública public_foo() {
print("Sou público");
}
função protegida protected_foo() {
$this->private_foo(); //Ok porque estamos na mesma classe podemos chamar métodos privados
print("Estou protegido");
}
função privada private_foo() {
$isto->x = 3;
print("Sou privado");
}
}
classe foo2 estende foo {
exibição de função pública() {
$this->protected_foo();
$this->public_foo();
// $this->private_foo(); // Inválido! a função é privada na classe base
}
} $x = novo foo();
$x->public_foo();
//$x->protected_foo(); //Inválido não pode chamar métodos protegidos fora da classe e classes derivadas
//$x->private_foo(); //Métodos privados inválidos só podem ser usados dentro da classe $x2 = new foo2();
$x2->exibição();
?>
Dica: Variáveis em objetos sempre existem em formato privado. Operar diretamente variáveis em um objeto não é um bom hábito de programação orientada a objetos. A melhor maneira é entregar as variáveis que você deseja ao método de um objeto para processamento.
Interfaces
Como todos sabemos, objetos no PHP4 suportam herança. Para tornar um objeto uma classe derivada de outro objeto, você precisa usar um código semelhante a "class foo extends parent" para controlá-lo. No PHP4 e no PHP5, um objeto só pode ser herdado uma vez e a herança múltipla não é suportada. Porém, um novo termo nasceu no PHP5: interface Uma interface é um objeto especial sem código de processamento específico. Ela apenas define os nomes e parâmetros de alguns métodos. As interfaces necessárias são integradas e, em seguida, o código de execução específico é adicionado.
Exemplo 5: Interface
interface exibível {
função exibição();
}
interface imprimível {
função doprint();
}
class foo implementa displayable,printable {
função exibição() {
//código
} função doprint() {
//código
}
}
?>
Isso é muito útil para melhorar a legibilidade e a popularidade do código. A partir do exemplo acima, podemos ver que o objeto foo contém duas interfaces, exibíveis e imprimíveis. Neste momento, podemos saber claramente que o objeto foo deve ter um display. () e um método print(), você só precisa entender a parte da interface, você pode operar facilmente o objeto sem ter que se preocupar com como o objeto funciona internamente.
Classes abstratas
Classes abstratas não podem ser instanciadas.
Classes abstratas, como outras classes, permitem a definição de variáveis e métodos.
Uma classe abstrata também pode definir um método abstrato. O método da classe abstrata não será executado, mas pode ser executado em sua classe derivada.
Exemplo 6: classe abstrata
classe abstrata foo {
protegido $x;
função abstrata display();
conjunto de funçõesX($x) {
$isto->x = $x;
}
}
classe foo2 estende foo {
função exibição() {
// Código
}
}
?>
__call
Objetos PHP5 possuem um novo método dedicado __call(), que é usado para monitorar outros métodos em um objeto. Se você tentar chamar um método que não existe no objeto, o método __call será chamado automaticamente.
Exemplo 7: __call
classe foo {
function __call($nome,$argumentos) {
print("Você me ligou? Meu nome é $!");
}
} $x = novo foo();
$x->doStuff();
$x->fancy_stuff();
?>
Este método especial pode ser usado para implementar ações de "sobrecarga", para que você possa verificar seus parâmetros e passá-los chamando um método privado.
Exemplo 8: Usando __call para implementar ação de “sobrecarga”
classe Magia {
function __call($nome,$argumentos) {
if($nome=='foo') {
if(is_int($argumentos[0])) $this->foo_for_int($argumentos[0]);
if(is_string($argumentos[0])) $this->foo_for_string($argumentos[0]);
}
} função privada foo_for_int($x) {
print("ah, um int!");
} função privada foo_for_string($x) {
print("ah, que string!");
}
} $x = new Magia();
$x->foo(3);
$x->foo("3");
?>
__set e __get
Este é um ótimo método. Os métodos __set e __get podem ser usados para capturar variáveis e métodos que não existem em um objeto.
Exemplo 9: __set e __get
classe foo {
função __set($nome,$val) {
print("Olá, você tentou colocar $val em $name");
}
função __get($nome) {
print("Ei, você pediu $nome");
}
}
$x = novo foo();
$x->barra = 3;
imprimir($x->winky_winky);
?>
Indicação de tipo
No PHP5, você pode especificar no método de um objeto que seu parâmetro deve ser uma instância de outro objeto.
Exemplo 10: Indicação de tipo
classe foo {
//código...
}
barra de classe {
função pública process_a_foo(foo $foo) {
//Algum código
}
}
$b = nova barra();
$f = novo foo();
$b->process_a_foo($f);
?>
Como pode ser visto, podemos especificar explicitamente o nome de um objeto antes do parâmetro, e o PHP5 reconhecerá que o parâmetro será uma instância do objeto.
Membros estáticos
Membros estáticos e métodos estáticos são chamados de "métodos de objeto (métodos de classe)" e "variáveis de objeto (variáveis de classe)" na terminologia de programação orientada a objetos.
"Métodos de objeto" podem ser chamados antes de um objeto ser instanciado. Da mesma forma, "variáveis de objeto" podem ser controladas independentemente antes de um objeto ser instanciado (sem usar os métodos de um objeto para controlá-lo).
Exemplo 11: Métodos de objeto e variáveis de objeto
calculadora de classe {
público estático $pi = 3,14151692;
função pública estática add($x,$y) {
retornar $x + $y;
}
}
$s = calculadora::$pi;
$resultado = calculadora::adicionar(3,7);
imprimir("$resultado");
?>
Tratamento de exceções
O tratamento de exceções é reconhecido como um método ideal para tratar erros de programa. Este conceito está disponível em Java e C++. Estamos satisfeitos em ver que esta aplicação foi adicionada ao PHP5. Você pode tentar usar “try” e “catch” para controlar erros do programa.
Exemplo 12: Tratamento de exceções
classe foo {
função dividir($x,$y) {
if($y==0) throw new Exception("não é possível dividir por zero");
retornar $x/$y;
}
}
$x = novo foo();
tentar {
$x->dividir(3,0);
} catch (Exceção $e) {
echo $e->getMessage();
eco "n
n";
// Algumas medidas catastróficas aqui
}
?>
No exemplo acima, usamos "try" para executar a instrução entre chaves. Quando ocorre um erro, o código entregará o erro para a cláusula "catch" para processamento. Na cláusula "catch", você precisa especificar. O tratamento de erros em um objeto pode tornar a estrutura do código mais clara, porque agora podemos entregar todas as informações de erro a um objeto para tratamento.
Tratamento de erros personalizado
Você pode controlar facilmente acidentes em seu programa com código de tratamento de erros personalizado. Você só precisa derivar sua própria classe de controle de erros da classe de exceção. Em sua própria classe de controle de erros, você precisa ter um construtor e um método getMessage.
Exemplo 13: Tratamento de erros personalizado
class WeirdProblem estende Exceção {
$dados privados;
function Problema estranho($dados) {
pai::exceção();
$este->dados = $dados;
}
function getMessage() {
return $this->data . "causou uma exceção estranha!";
}
}
?>
Agora podemos usar "throw new WeirdProblem($foo)" para lançar um manipulador de erros. Se o erro ocorrer no bloco de código "try", o PHP5 entregará automaticamente o erro para a parte "catch" para processamento.
Namespaces
Namespaces são úteis para agrupamento de classes ou agrupamento de funções. Ele pode agrupar algumas classes ou funções relacionadas para facilitar a chamada posterior.
Exemplo 14: Namespace
espaço para nome Matemática {
classe Complexo {
//...código...
função __construir() {
imprimir("Ei");
}
}
} $m = new Math::Complex();
?>
Preste atenção às circunstâncias sob as quais você precisa usar namespaces. Em aplicações práticas, você pode precisar declarar dois ou mais objetos com o mesmo nome para fazer coisas diferentes, então você pode colocá-los em namespaces diferentes (mas a interface deve ser. o mesmo).