En programación orientada a objetos (inglés: programación orientada a objetos, abreviatura: OOP), un objeto es un todo compuesto de información y una descripción de cómo procesar la información, y es una abstracción del mundo real.
En el mundo real, las cosas a las que nos enfrentamos son objetos, como ordenadores, televisores, bicicletas, etc.
Hay tres características principales de los objetos:
El comportamiento del objeto: Qué operaciones se pueden aplicar al objeto, encender la luz y apagar la luz son comportamientos.
La forma del objeto: cómo responde el objeto cuando se aplican esos métodos, color, tamaño, apariencia.
Representación de objetos: La representación de objetos equivale a un documento de identidad, distinguiendo específicamente las diferencias en un mismo comportamiento y estatus.
Por ejemplo, Animal es una clase abstracta. Podemos especificar un perro y una oveja, y los perros y las ovejas son objetos concretos. Tienen atributos de color, se pueden escribir, ejecutar y otros estados de comportamiento.
Clase : define las características abstractas de una cosa. La definición de una clase incluye la forma de los datos y las operaciones sobre los datos.
Objeto : es una instancia de una clase.
Variables miembro : variables definidas dentro de una clase. El valor de esta variable es invisible para el mundo exterior, pero se puede acceder a él a través de funciones miembro. Una vez que se crea una instancia de la clase como un objeto, la variable se puede llamar un atributo del objeto.
Funciones miembro : se definen dentro de la clase y se pueden usar para acceder a los datos del objeto.
Herencia : la herencia es un mecanismo mediante el cual las subclases comparten automáticamente las estructuras de datos y los métodos de su clase principal. Esta es una relación entre clases. Al definir e implementar una clase, puede hacerlo sobre la base de una clase existente, tomar el contenido definido por la clase existente como su propio contenido y agregar contenido nuevo.
Clase principal : una clase heredada por otras clases puede denominarse clase principal, clase base o superclase.
Subclase : una clase que hereda de otras clases se llama subclase o también se puede llamar clase derivada.
Polimorfismo : el polimorfismo significa que la misma función o método puede operar en múltiples tipos de objetos y obtener resultados diferentes. Diferentes objetos pueden producir resultados diferentes al recibir el mismo mensaje. Este fenómeno se llama polimorfismo.
Sobrecarga : en pocas palabras, es una situación en la que funciones o métodos tienen el mismo nombre pero diferentes listas de parámetros. Estas funciones o métodos con el mismo nombre y diferentes parámetros se denominan funciones o métodos sobrecargados.
Abstracción : la abstracción se refiere a abstraer objetos con estructuras de datos (propiedades) y comportamientos (operaciones) consistentes en clases. Una clase es una abstracción que refleja propiedades importantes relacionadas con una aplicación ignorando otro contenido irrelevante. La división de cualquier clase es subjetiva, pero debe estar relacionada con la aplicación específica.
Encapsulación : la encapsulación se refiere a unir las propiedades y el comportamiento de un objeto que existe en el mundo real y colocarlo dentro de una unidad lógica.
Constructor : se usa principalmente para inicializar el objeto al crear el objeto, es decir, asignar valores iniciales a las variables miembro del objeto. Siempre se usa junto con el nuevo operador en la declaración para crear el objeto.
Destructor − Destructor (destructor) A diferencia del constructor, cuando el objeto finaliza su ciclo de vida (por ejemplo, se ha llamado a la función en la que se encuentra el objeto), el sistema ejecuta automáticamente el destructor. Los destructores se utilizan a menudo para realizar trabajos de "limpieza" (por ejemplo, al crear un objeto, use new para abrir un espacio de memoria, que debe liberarse con eliminar en el destructor antes de salir).
En la siguiente figura, hemos creado tres objetos a través de la clase Car: Mercedes, BMW y Audi.
$mercedes = coche nuevo ();$bmw = coche nuevo ();$audi = coche nuevo ();
El formato de sintaxis habitual para definir clases en PHP es el siguiente:
<?phpclass phpClass { var $var1; var $var2 = "cadena constante"; función myfunc ($arg1, $arg2) { [..] } [..]}?>El análisis es el siguiente:
Las clases se definen utilizando la palabra clave class seguida del nombre de la clase.
Las variables y los métodos se pueden definir dentro de un par de llaves ({}) después del nombre de la clase.
Las variables de clase se declaran usando var y las variables también se pueden inicializar con valores.
Las definiciones de funciones son similares a las definiciones de funciones de PHP, pero solo se puede acceder a las funciones a través de la clase y los objetos que crea instancias.
<?phpclass Sitio { /* Variables miembro*/ var $url; var $título; funciones miembro*/ function setUrl($par){ $this->url = $par; ->url . PHP_EOL; } función setTitle($par){ $this->title = $par } función getTitle(){ echo $this->title . }}?>La variable $this representa su propio objeto.
PHP_EOL es el carácter de nueva línea.
Después de crear una clase, podemos usar el nuevo operador para crear instancias de objetos de esa clase:
$codercto = nuevo sitio;$taobao = nuevo sitio;$google = nuevo sitio;
En el código anterior, creamos tres objetos. Cada uno de los tres objetos es independiente. A continuación, echemos un vistazo a cómo acceder a los métodos miembro y a las variables miembro.
Después de crear una instancia de un objeto, podemos usar el objeto para llamar a métodos miembros. Los métodos miembros del objeto solo pueden operar en las variables miembro del objeto:
// Llame a la función miembro para establecer el título y la URL $codercto->setTitle( "Coder Tutorial" );$taobao->setTitle( "Taobao" );$google->setTitle( "Google Search" );$codercto- > setUrl( 'www.codercto.com' );$taobao->setUrl( 'www.taobao.com' );$google->setUrl( 'www.google.com' );// Llame a la función miembro para obtener el título y la URL $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao-> getUrl();$google->getUrl();
El código completo es el siguiente:
<?php class Sitio { / * Variables miembro */ var $url ; var $título ; * funciones miembro */ function setUrl ( $par ){ $ this -> url = $par ; esto -> url . PHP_EOL } función setTitle ( $par ){ $this - > título = $par } función getTitle (){ echo $this - > título ; }} $codercto = nuevo sitio ; $taobao = nuevo sitio ; $google = nuevo sitio ; // Llamar a la función miembro , establecer título y URL $ codercto -> setTitle ( "Tutorial del codificador" ) ; " ); $google -> setTitle ( "Búsqueda de Google" ); $codercto -> setUrl ( 'www.codercto.com' ); $taobao -> setUrl ( 'www.taobao.com' ) ; $google -> setUrl ( ' www.google.com ' ); // Llame a la función miembro para obtener el título y la URL $ codercto -> getTitle (); ); $ google -> obtenerTítulo (); $codercto -> obtenerUrl ( ); $ taobao - > obtenerUrl ( ) ;Al ejecutar el código anterior, el resultado de salida es:
Tutorial de granjero de código Taobao Búsqueda de Google www.codercto.comwww.taobao.comwww.google.com
El constructor es un tipo especial de método. Se utiliza principalmente para inicializar el objeto al crear el objeto, es decir, asignar valores iniciales a las variables miembro del objeto y usarlo con new operador en la declaración para crear el objeto.
PHP 5 permite a los desarrolladores definir un método como constructor en una clase, con la siguiente sintaxis:
void __construct ([ $args mixtos [, $... ]] )
En el ejemplo anterior, podemos inicializar las variables $url y $title a través del constructor:
función __construct( $par1, $par2 ) { $this->url = $par1 $this->título = $par2;}Ahora ya no necesitamos llamar a los métodos setTitle y setUrl:
$codercto = nuevo sitio('www.codercto.com', 'Coder Tutorial');$taobao = nuevo sitio('www.taobao.com', 'Taobao');$google = nuevo sitio('www.google . es', 'Búsqueda de Google');// Llame a la función miembro para obtener el título y la URL $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao->getUrl(); $google ->getUrl();Destructor (destructor) A diferencia del constructor, cuando el objeto finaliza su ciclo de vida (por ejemplo, se ha llamado a la función en la que se encuentra el objeto), el sistema ejecuta automáticamente el destructor.
PHP 5 introdujo el concepto de destructores, que es similar a otros lenguajes orientados a objetos. Su sintaxis es la siguiente:
vacío __destruct (vacío)
<?phpclass MyDestructableClass { function __construct() { print "constructorn"; $this->name = "MyDestructableClass"; } function __destruct() { print "destruir" $this->name . }$obj = nueva MiClaseDestructable();?>Al ejecutar el código anterior, el resultado de salida es:
El constructor destruye MyDestructableClass
PHP usa la palabra clave extends para heredar una clase. PHP no admite herencia múltiple. El formato es el siguiente:
clase Niño extiende Padre { // Parte del código}En el ejemplo, la clase Child_Site hereda la clase Site y extiende sus funciones:
<?php // Child_Site extiende el sitio { var $categoría; función setCate($par){ $esta->categoría = $par } función getCate(){ echo $esta->categoría }}Si el método heredado de la clase principal no puede satisfacer las necesidades de la subclase, se puede reescribir. Este proceso se denomina anulación de método, también conocido como reescritura de método.
Los métodos getUrl y getTitle se anulan en el ejemplo:
función getUrl() { echo $this->url . PHP_EOL; return $this->url;} function getTitle(){ echo $this->title .El control de acceso de PHP a propiedades o métodos se logra agregando las palabras clave pública, protegida o privada al frente.
público: se puede acceder a los miembros de la clase pública desde cualquier lugar.
protected: Puede acceder a los miembros de la clase protegida por sí mismo y sus subclases y clases principales.
Privado: Solo la clase en la que están definidos puede acceder a los miembros de la clase privada.
Los atributos de clase deben definirse como públicos, protegidos o privados. Si se define con var, se considera público.
<?php/** * Definir MiClase */class MiClase{ público $público = 'Público'; protegido $protegido = 'Protegido' privado $privado = 'Privado' función printHello() { echo $this->public; echo $this->protected; echo $this->private; }}$obj = new MyClass();echo $obj->public // Esta línea se puede ejecutar normalmente echo $obj->protected; // Esta línea generará un error fatal echo $obj->private; // Esta línea también generará un error fatal $obj->printHello() // Salida Pública, Protegida y Privada/** * Definir MyClass2 */ class MyClass2 extiende MyClass{ // Público y protegido se pueden redefinir, pero privado pero no protegido $protected = 'Protected2' function printHello() { echo $this->public; $this->protected; echo $this->private; }}$obj2 = new MyClass2();echo $obj2->public // Esta línea se puede ejecutar normalmente echo $obj2->private; definido $obj2->protected; // Esta línea generará un error fatal $obj2->printHello() // Salida Pública, Protegida2 e Indefinida?>Los métodos de una clase se pueden definir como públicos, privados o protegidos. Si estas palabras clave no están configuradas, el método predeterminado es público.
<?php/** * Definir MiClase */class MiClase{ // Declarar un constructor público función pública __construct() { } // Declarar un método público función pública MyPublic() { } // Declarar un método protegido función protegida MyProtected( ) { } // Declarar un método privado función privada MyPrivate() { } // Este método es una función pública Foo() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); }}$myclass = new MyClass;$myclass->MyPublic() // Esta línea se puede ejecutar normalmente $myclass->MyProtected(); Esta línea generará un error fatal $myclass->MyPrivate(); // Esta línea generará un error fatal $myclass->Foo() // Se pueden ejecutar públicos, protegidos y privados/** * Definir MyClass2 */class MyClass2 extends MyClass{ // Este método es una función pública Foo2() { $this->MyPublic(); $this->MyProtected() $this->MyPrivate(); generar Un error fatal}}$myclass2 = new MyClass2;$myclass2->MyPublic() // Esta línea se puede ejecutar normalmente $myclass2->Foo2(); Se pueden ejecutar tanto los públicos como los protegidos, pero los privados no. class Bar { public function test() { $this->testPrivate(); $this->testPublic() } public function testPublic() { echo "Bar: :testPublicn"; } función privada testPrivate() { echo "Bar::testPrivaten"; }}clase Foo extiende Bar { función pública testPublic() { echo "Foo::testPublicn"; } función privada testPrivate() { echo "Foo::testPrivaten" }}$myFoo = new foo();$myFoo->test(); // Foo::pruebaPública?>Al utilizar una interfaz, puede especificar qué métodos debe implementar una clase, pero no es necesario definir el contenido específico de estos métodos.
Una interfaz se define mediante la palabra clave interfaz , al igual que definir una clase estándar, pero todos los métodos definidos en ella están vacíos.
Todos los métodos definidos en una interfaz deben ser públicos. Esta es una característica de las interfaces.
Para implementar una interfaz, utilice el operador de implementos . La clase debe implementar todos los métodos definidos en la interfaz; de lo contrario, se informará un error fatal. Una clase puede implementar múltiples interfaces. Utilice comas para separar los nombres de múltiples interfaces.
<?php// Declarar una interfaz 'iTemplate' interfaz iTemplate{ public function setVariable($name, $var); public function getHtml($template);}// Implementar la clase de interfaz Template implements iTemplate{ private $vars = array( ) ; función pública setVariable($nombre, $var) { $this->vars[$nombre] = $var } función pública getHtml($plantilla) { foreach($this->vars as $nombre => $valor) { $plantilla = str_replace('{' . $nombre . '}', $valor, $plantilla } return $plantilla }}Los valores que permanecen sin cambios en una clase se pueden definir como constantes. No es necesario utilizar el símbolo $ al definir y utilizar constantes.
El valor de una constante debe ser un valor fijo y no puede ser una variable, un atributo de clase, el resultado de una operación matemática o una llamada a una función.
Desde PHP 5.3.0, las clases se pueden llamar dinámicamente usando una variable. Pero el valor de esta variable no puede ser una palabra clave (como self, parent o static).
<?phpclass MiClase{ constante constante = 'valor constante'; función showConstant() { echo self::constante . PHP_EOL }}echo MiClase::constante . PHP_EOL; // Desde 5.3.0 $clase = nuevo MyClass();$class->showConstant();echo $class::constant . // ¿Desde PHP 5.3.0?>Cualquier clase debe declararse abstracta si al menos un método de ella se declara abstracto.
No se pueden crear instancias de clases definidas como abstractas.
Un método definido como abstracto solo declara su método de llamada (parámetros) y no puede definir la implementación de su función específica.
Al heredar una clase abstracta, la subclase debe definir todos los métodos abstractos en la clase principal; además, el control de acceso de estos métodos debe ser el mismo (o más relajado) que en la clase principal; Por ejemplo, si un método abstracto se declara protegido, entonces el método implementado en la subclase debe declararse protegido o público, y no puede definirse como privado.
<?phpabstract class AbstractClass{ // Obligatorio para las subclases definir estos métodos abstract protected function getValue(); abstract protected function prefixValue($prefix); // Método ordinario (método no abstracto) public function printOut() { print $this); - >getValue() . PHP_EOL; }}clase ConcreteClass1 extiende AbstractClass{ función protegida getValue() { return "ConcreteClass1" } prefixValue($prefix) { return "{$prefix}ConcreteClass1" }}clase ConcreteClass2 extiende AbstractClass{ public function getValue() { return "ConcreteClass2" } public function prefixValue($prefix) { return "{$prefix}ConcreteClass2"; }}$clase1 = nueva ClaseConcreto1;$clase1->printOut();echo $class1->prefixValue('FOO_') . PHP_EOL;$class2 = new ConcreteClass2;$class2->printOut();echo $class2->prefixValue('FOO_') .Al ejecutar el código anterior, el resultado de salida es:
ConcreteClass1FOO_ConcreteClass1ConcreteClass2FOO_ConcreteClass2
Además, los métodos de la clase secundaria pueden contener parámetros opcionales que no están presentes en el método abstracto de la clase principal.
Por ejemplo, si una subclase define un parámetro opcional que no está incluido en la declaración del método abstracto de la clase principal, aún puede ejecutarse normalmente.
<?phpabstract class AbstractClass{ // Nuestro método abstracto solo necesita definir los parámetros requeridos abstract protected function prefixName($name);}class ConcreteClass extends AbstractClass{ // Nuestra subclase puede definir opciones opcionales que no existen en la firma de la clase principal Parámetros función pública nombreprefijo($nombre, $separador = ".") { if ($nombre == "Pacman") { $prefijo = "Señor" } elseif ($nombre == "Pacwoman") { $prefix = "Señora"; } else { $prefix = ""; return "{$prefix}{$separator} {$name}"; $class = new ConcreteClass;echo $class->prefixName("Pacman "), "n";echo $clase->prefixName("Pacwoman"), "n";?>La salida es:
Sr. Pacman Sra. Pacwoman
Declarar un atributo o método de clase como estático le permite acceder a él directamente sin crear una instancia de la clase.
No se puede acceder a las propiedades estáticas a través de un objeto de una clase de la que se ha creado una instancia (pero sí a los métodos estáticos).
Dado que los métodos estáticos no requieren que se llame a un objeto, la pseudovariable $this no está disponible en los métodos estáticos.
Los objetos no pueden acceder a las propiedades estáticas a través del operador ->.
Desde PHP 5.3.0, las clases se pueden llamar dinámicamente usando una variable. Pero el valor de esta variable no puede ser las palabras clave self, parent o static.
<?phpclass Foo { public static $my_static = 'foo'; public function staticValue() { return self::$my_static }}print Foo::$my_static . >valor estático() .PHP_EOL;?>Al ejecutar el programa anterior, el resultado de salida es:
foofoo
PHP 5 agrega una nueva palabra clave final. Si un método de la clase principal se declara final, la clase secundaria no puede anular el método. Si una clase se declara final, no se puede heredar.
Se informará un error al ejecutar el siguiente código:
<?phpclass BaseClass { prueba de función pública() { echo "BaseClass::test() llamado" } función pública final moreTesting() { echo "BaseClass::moreTesting() llamado" }}clase ChildClass se extiende. BaseClass {función pública moreTesting() { echo "ChildClass::moreTesting() llamado" PHP_EOL; Mensaje de error Error grave: ¿No se puede anular el método final BaseClass::moreTesting()?>PHP no llamará automáticamente al constructor de la clase principal en el constructor de la clase secundaria. Para ejecutar el constructor de la clase principal, debe llamar a parent::__construct() en el constructor de la clase secundaria.
<?phpclass BaseClass { function __construct() { print "Método constructor en la clase BaseClass" }}class SubClass extends BaseClass { function __construct() { parent::__construct() // El constructor de la subclase no puede llamar automáticamente al padre. El método constructor de la clase print "Método constructor en la clase SubClass" PHP_EOL; }}class OtherSubClass extends BaseClass { // Hereda el método constructor de BaseClass}// Llamar al constructor BaseClass $obj = new BaseClass(); // Llamar a los constructores BaseClass y SubClass $obj = new SubClass() // Llamar al constructor BaseClass $obj = new OtherSubClass();?>Al ejecutar el programa anterior, el resultado de salida es:
Método constructor en la clase BaseClass Método constructor en la clase SubClass Método constructor en la clase BaseClass