Los objetos en PHP5 se han ajustado de manera más sistemática y completa, y su apariencia actual puede parecerse algo a Java. Esta sección se centra en el nuevo modo de objeto en PHP5 y ofrece algunos ejemplos más simples para ilustrar. Deje que esta sección sea un nuevo punto de partida para su viaje PHP5. :)
* Constructor y destructor
* Referencia de objeto
*Clon de objeto
* Modos privado, público y protegido en objetos.
* Interfaces
* Clase abstracta
* __llamar
* __establecer y __obtener
* Miembros estáticos
Constructor y destructor
En PHP4, cuando una función tiene el mismo nombre que un objeto, esta función se convertirá en el constructor del objeto y no existe el concepto de destructor en PHP4.
En PHP5, el constructor se denomina uniformemente __construct y se introduce el concepto de destructor, que se denomina uniformemente __destruct.
Ejemplo 1: constructor y destructor
clase foo {
var$x;
función __construct ($x) {
$esto->x = $x;
}
visualización de funciones() {
imprimir($esto->x);
}
función __destruct() {
imprimir("adiós");
}
}
$o1 = nuevo foo(4);
$o1->mostrar();
?>
En el ejemplo anterior, cuando finaliza la llamada a la clase foo, se llamará a su destructor y se generará "adiós" en el ejemplo anterior.
las referencias a objetos
, en PHP4, pasar una variable a una función o método en realidad hace una copia de la variable, lo que significa que lo que pasas a la función o método es una copia de la variable, a menos que uses una referencia. El símbolo "&" se utiliza para declarar que se va a hacer una referencia, no una copia. En PHP5, los objetos siempre existen en forma de referencias, y las operaciones de asignación en objetos también son operaciones de referencia.
Ejemplo 2: referencia de objeto
clase foo {
var$x;
función conjuntoX($x) {
$esto->x = $x;
}
función obtenerX() {
devolver $this->x;
}
}
$o1 = nuevo foo;
$o1->setX(4);
$o2 = $o1;
$o1->setX(5);
if($o1->getX() == $o2->getX()) print("¡Dios mío!");
?>
Clonar objeto
Como se mencionó anteriormente, cuando un objeto siempre se llama en forma de referencia, ¿qué debo hacer si quiero obtener una copia del objeto? PHP5 proporciona una nueva función, que es la clonación de objetos, y la sintaxis es __clone.
Ejemplo 3: Clonación de objetos
clase foo {
var$x;
función conjuntoX($x) {
$esto->x = $x;
}
función obtenerX() {
devolver $this->x;
}
}
$o1 = nuevo foo;
$o1->setX(4);
$o2 = $o1->__clon();
$o1->setX(5); if($o1->getX() != $o2->getX()) print（"Las copias son independientes"）;
?>
Los métodos de clonación de objetos existen en muchos otros lenguajes de aplicaciones, por lo que no tienes que preocuparte por su estabilidad. :)
Modos privado, público y protegido en objetos
En PHP4, todos los métodos y variables de un objeto son públicos, lo que significa que puedes operar cualquiera de las variables y métodos fuera de un objeto. PHP5 introduce tres nuevos modos para controlar este permiso de acceso: Público, Protegido y Privado.
Modo público (Public): permite el control de la operación fuera del objeto.
Modo privado (Privado): solo los métodos dentro de este objeto pueden operarlo y controlarlo.
Modo protegido (Protegido): permite que este objeto y su objeto principal lo operen y controlen.
Ejemplo 4: modos privado, público y protegido en objetos
clase foo {
privado $x;
función pública public_foo() {
print("Soy público");
}
función protegida protected_foo() {
$this->private_foo(); //Ok, como estamos en la misma clase, podemos llamar a métodos privados
print("Estoy protegido");
}
función privada private_foo() {
$esto->x = 3;
print("Soy privado");
}
}
clase foo2 extiende foo {
visualización de función pública() {
$this->protected_foo();
$this->public_foo();
// $this->private_foo(); // ¡No es válida! La función es privada en la clase base.
}
} $x = nuevo foo();
$x->public_foo();
//$x->protected_foo(); //No válido no puede llamar a métodos protegidos fuera de la clase y las clases derivadas
//$x->private_foo(); //Los métodos privados no válidos solo se pueden usar dentro de la clase $x2 = new foo2();
$x2->mostrar();
?>
Consejo: las variables en los objetos siempre existen en forma privada. Operar directamente las variables en un objeto no es un buen hábito de programación orientada a objetos. Una mejor manera es entregar las variables que desea al método de un objeto para su procesamiento.
Interfaces
Como todos sabemos, los objetos en PHP4 admiten herencia. Para convertir un objeto en una clase derivada de otro objeto, es necesario utilizar un código similar a "clase foo extiende padre" para controlarlo. En PHP4 y PHP5, un objeto solo se puede heredar una vez y no se admite la herencia múltiple. Sin embargo, nació un nuevo término en PHP5: interfaz. Una interfaz es un objeto especial sin código de procesamiento específico. Solo define los nombres y parámetros de algunos métodos. Después de eso, el objeto se puede usar convenientemente con la palabra clave 'implementar'. Se integran las interfaces requeridas y luego se agrega el código de ejecución específico.
Ejemplo 5: interfaz
interfaz visualizable {
visualización de función();
}
interfaz imprimible {
función doprint();
}
clase foo implementa visualizable, imprimible {
visualización de funciones() {
// código
} función imprimir() {
// código
}
}
?>
Esto es muy útil para mejorar la legibilidad y popularidad del código. En el ejemplo anterior, podemos ver que el objeto foo contiene dos interfaces, visualizable e imprimible. En este momento, podemos saber claramente que el objeto foo debe tener una pantalla. () y un método print(), solo necesita comprender la parte de la interfaz, puede operar fácilmente el objeto sin tener que preocuparse por cómo funciona el objeto internamente.
Clases abstractas
No se pueden crear instancias de clases abstractas.
Las clases abstractas, al igual que otras clases, permiten definir variables y métodos.
Una clase abstracta también puede definir un método abstracto. El método de la clase abstracta no se ejecutará, pero puede ejecutarse en su clase derivada.
Ejemplo 6: clase abstracta
clase abstracta foo {
protegido $x;
visualización de función abstracta();
función conjuntoX($x) {
$esto->x = $x;
}
}
clase foo2 extiende foo {
visualización de funciones() {
// código
}
}
?>
__call
Los objetos PHP5 tienen un nuevo método dedicado __call(), que se utiliza para monitorear otros métodos en un objeto. Si intenta llamar a un método que no existe en el objeto, el método __call se llamará automáticamente.
Ejemplo 7: __llamar
clase foo {
función __call($nombre,$argumentos) {
print("¿Me llamaste? ¡Soy $nombre!");
}
} $x = nuevo foo();
$x->hacerCosas();
$x->cosas_elegantes();
?>
Este método especial se puede utilizar para implementar acciones de "sobrecarga", de modo que pueda verificar sus parámetros y pasarlos llamando a un método privado.
Ejemplo 8: uso de __call para implementar la acción de "sobrecarga"
clase mágica {
función __call($nombre,$argumentos) {
si($nombre=='foo') {
if(is_int($argumentos[0])) $this->foo_for_int($argumentos[0]);
if(is_string($argumentos[0])) $this->foo_for_string($argumentos[0]);
}
} función privada foo_for_int($x) {
print("¡Oh, un int!");
} función privada foo_for_string($x) {
print("¡Oh, una cadena!");
}
} $x = nueva Magia();
$x->foo(3);
$x->foo("3");
?>
__set y __get
Este es un gran método. Los métodos __set y __get se pueden usar para capturar variables y métodos que no existen en un objeto.
Ejemplo 9: __set y __get
clase foo {
función __set($nombre,$val) {
print("Hola, intentaste poner $val en $nombre");
}
función __get($nombre) {
print("Oye, pediste $nombre");
}
}
$x = nuevo foo();
$x->barra = 3;
imprimir($x->winky_winky);
?>
Indicación de tipo
En PHP5, puedes especificar en el método de un objeto que su parámetro debe ser una instancia de otro objeto.
Ejemplo 10: Indicación de tipo
clase foo {
// código...
}
barra de clase {
función pública proceso_a_foo(foo $foo) {
// Algún código
}
}
$b = nueva barra();
$f = nuevo foo();
$b->proceso_a_foo($f);
?>
Como puede verse, podemos especificar explícitamente el nombre de un objeto antes del parámetro, y PHP5 reconocerá que el parámetro será una instancia de objeto.
Miembros estáticos
Los miembros estáticos y los métodos estáticos se denominan "métodos de objeto (métodos de clase)" y "variables de objeto (variables de clase)" en la terminología de programación orientada a objetos.
Se permite llamar a "métodos de objeto" antes de crear una instancia de un objeto. De manera similar, las "variables de objeto" se pueden controlar de forma independiente antes de crear una instancia de un objeto (sin utilizar los métodos de un objeto para controlarlo).
Ejemplo 11: métodos de objeto y variables de objeto
calculadora de clase {
público estático $pi = 3.14151692;
función pública estática agregar($x,$y) {
devolver $x + $y;
}
}
$s = calculadora::$pi;
$resultado = calculadora::add(3,7);
imprimir("$resultado");
?>
Manejo de excepciones
El manejo de excepciones se reconoce como un método ideal para manejar errores de programa. Este concepto está disponible en Java y C++. Nos complace ver que esta aplicación se ha agregado a PHP5. Puedes intentar usar "try" y "catch" para controlar los errores del programa.
Ejemplo 12: Manejo de excepciones
clase foo {
función dividir($x,$y) {
if($y==0) throw new Exception("no se puede dividir por cero");
devolver $x/$y;
}
}
$x = nuevo foo();
intentar {
$x->dividir(3,0);
} captura (Excepción $e) {
echo $e->getMessage();
eco "n
norte";
// Algunas medidas catastróficas aquí
}
?>
En el ejemplo anterior, usamos "try" para ejecutar la declaración entre llaves. Cuando ocurre un error, el código entregará el error a la cláusula "catch" para su procesamiento. Manejar errores en un objeto puede hacer que la estructura del código parezca más clara, porque ahora podemos entregar toda la información de error a un objeto para su manejo.
Manejo de errores personalizado
Puede controlar fácilmente los accidentes en su programa con un código de manejo de errores personalizado. Sólo necesita derivar su propia clase de control de errores a partir de la clase de excepción. En su propia clase de control de errores, necesita tener un constructor y un método getMessage.
Ejemplo 13: Manejo de errores personalizado
clase WeirdProblem extiende la excepción {
datos privados $;
función Problema extraño($datos) {
padre::excepción();
$this->datos = $datos;
}
función obtener mensaje() {
return $this->data "¡causó una excepción extraña!";
}
}
?>
Ahora podemos usar "throw new WeirdProblem($foo)" para generar un controlador de errores. Si el error ocurre en el bloque de código "try", PHP5 entregará automáticamente el error a la parte "catch" para su procesamiento.
Espacios de nombres
Los espacios de nombres son útiles para agrupar clases o agrupar funciones. Puede agrupar algunas clases o funciones relacionadas para poder llamarlas fácilmente más adelante.
Ejemplo 14: espacio de nombres
espacio de nombres Matemáticas {
clase compleja {
//...código...
función __construct() {
imprimir("hola");
}
}
} $m = nuevo Math::Complex();
?>
Preste atención a las circunstancias en las que necesita usar espacios de nombres. En aplicaciones prácticas, es posible que necesite declarar dos o más objetos con el mismo nombre para hacer cosas diferentes, luego puede colocarlos en espacios de nombres diferentes (pero la interfaz debe ser. lo mismo).