Clases y objetos en PHP

En este tutorial, aprenderás a escribir código de manera orientada a objetos en PHP.

¿Qué es la programación orientada a objetos

La programación orientada a objetos (OOP) es un modelo de programación basado en conceptos de clase y objeto. A diferencia de la programación procedural, donde el enfoque es escribir procesos o funciones que realizan operaciones en los datos, en la programación orientada a objetos, el enfoque es crear objetos que contienen tanto datos como funciones.

En comparación con la programación procedural o convencional, la programación orientada a objetos tiene varias ventajas. Las más importantes se enumeran a continuación:

• Proporciona una estructura modular clara al programa.

• Ayuda a cumplir con el principio 'No Repetirte a Ti Mismo' (DRY), haciendo que tu código sea más fácil de mantener, modificar y depurar.

• Permite crear comportamientos más complejos con menos código, menos tiempo de desarrollo y una alta reutilización.

Las siguientes secciones describirán cómo funcionan las clases y los objetos en PHP.

Entender clases y objetos

Las clases y los objetos son dos de los aspectos principales de la programación orientada a objetos. Una clase es una colección de variables y funciones independientes que trabajan juntas para ejecutar una o más tareas específicas, mientras que un objeto es una instancia única de una clase.

Una clase actúa como un patrón o plano, a partir del cual se pueden crear muchos objetos individuales. Al crear un solo objeto, aunque ciertas propiedades de cada objeto pueden tener valores diferentes, heredan las propiedades y comportamientos comunes.

Por ejemplo, considera a la clase como el plano de un hogar. El plano en sí no es la casa, sino el plan detallado de la casa. Y los objetos son como las casas reales construidas según ese plano. Podemos construir varias casas idénticas según el mismo plano, pero cada casa puede tener diferentes pinturas, interiores y familias, como se muestra en la imagen siguiente.

Se puede declarar una clase utilizando la palabra clave class, seguida del nombre de la clase y un par de corchetes ({}), como se muestra en el siguiente ejemplo.

Vamos a crear un archivo PHP llamado Recangle.php y colocamos el siguiente código de ejemplo en él, para separar nuestro código de clase del resto del programa. Luego, solo necesitamos incluir el archivo Recangle.php para poder usarlo en cualquier lugar necesario.

<?php
class Rectangle
{
　　　　//声明属性
　　　　public $longitud = 0;
　　　　public $ancho = 0;
　　　　
　　　　//método para calcular el perímetro
　　　　public function getPerimeter(){
　　　　　　　　devolver (2　*　($this->longitud　+　$this->ancho));
　　　　}
　　　　
　　　　//método para calcular el área
　　　　public function getArea(){
　　　　　　　　devolver ($this->longitud　*　$this->ancho);
　　　　}
}
?>

El modificador de acceso public en el ejemplo anterior antes de las propiedades y métodos es unModificadores de accesoindicando que la propiedad o método puede ser accedido desde cualquier lugar. Vamos a aprender más sobre esto más adelante en este capítulo.

Crear otro archivo PHP llamado test.php y coloque el siguiente código en él.

<?php
//contiene la definición de clase
class Rectangle
{
　　　　//声明属性
　　　　public $longitud = 0;
　　　　public $ancho = 0;
　　　　
　　　　//método para calcular el perímetro
　　　　public function getPerimeter(){
　　　　　　　　devolver (2　*　($this->longitud　+　$this->ancho));
　　　　}
　　　　
　　　　//método para calcular el área
　　　　public function getArea(){
　　　　　　　　devolver ($this->longitud　*　$this->ancho);
　　　　}
}
　
//Crear un nuevo objeto desde la clase Rectangle
$obj = new Rectangle;
　
//Obtener el valor de la propiedad del objeto
echo　$obj->longitud;　//　Salida: 0
echo　$obj->ancho;　//　Salida: 0
　
//设置对象属性值
$obj->length　=　30;
$obj->width　=　20;
　
//Lectura nuevamente de los valores de las propiedades del objeto para mostrar los cambios
echo　$obj->longitud;　//　Salida:　30
echo "<br>";
echo　$obj->ancho;　//　Salida:　20
　
　
//调用对象方法
echo　$obj->getPerimeter();　//　Salida:　100
echo "<br>";
echo　$obj->getArea();　//　Salida:　600
?>

El símbolo de flecha (-)> es una construcción de OOP, utilizada para acceder a las propiedades y métodos que contiene el objeto dado. Mientras que el pseudovariable $this proporciona una referencia al objeto que llama (es decir, el objeto al que pertenece el método).

Cuando se utilizan múltiples instancias de la misma clase, la verdadera fuerza de la programación orientada a objetos se vuelve evidente, como se muestra en el siguiente ejemplo:

<?php
//contiene la definición de clase
class Rectangle
{
　　　　//声明属性
　　　　public $longitud = 0;
　　　　public $ancho = 0;
　　　　
　　　　//método para calcular el perímetro
　　　　public function getPerimeter(){
　　　　　　　　devolver (2　*　($this->longitud　+　$this->ancho));
　　　　}
　　　　
　　　　//método para calcular el área
　　　　public function getArea(){
　　　　　　　　devolver ($this->longitud　*　$this->ancho);
　　　　}
}
　
//Crear múltiples objetos desde la clase Rectangle
$obj1　= new Rectangle;
$obj2　= new Rectangle;
　
//Llamar a los métodos de dos objetos
echo　$obj1->getArea();　//Salida: 0
echo　$obj2->getArea();　//Salida: 0
　
//Configurar $obj1Valor de la propiedad
$obj1->length　=　30;
$obj1->width　=　20;
　
//Configurar $obj2Valor de la propiedad
$obj2->length　=　35;
$obj2->width　=　50;
　
//Llamar nuevamente los métodos de dos objetos
echo　$obj1->getArea();　//Salida:600
echo "<br>";
echo　$obj2->getArea();　//Salida:1750
?>

Como se muestra en el ejemplo anterior, llamar al método getArea() en diferentes objetos realiza operaciones en conjuntos de datos diferentes. Cada instancia de objeto es completamente independiente, con sus propias propiedades y métodos, por lo que incluso si pertenecen a la misma clase, se puede operar con ellas independientemente.

Usar constructor y destructor

Para simplificar la programación orientada a objetos, PHP proporciona algunas funciones mágicas que se ejecutan automáticamente cuando ocurren ciertas operaciones en el objeto.

Por ejemplo, cada vez que se crea un nuevo objeto, se ejecuta automáticamente el método mágico __construct() (llamado constructor). Del mismo modo, el método mágico __destruct() (llamado función destrucción) se ejecuta automáticamente cuando se destruye el objeto. Después de destruir el objeto, la función destrucción borrará todos los recursos asignados al objeto.

<?php
class MyClass
{
　　　　//　构造函数
　　　　public　function　__construct(){
　　　　　　　　echo　'　类　"'　.　__CLASS__　.　'"　已启动<br>';
　　　　}
　　　　
　　　　//　función destrucción
　　　　public function __destruct(){
　　　　　　　　echo 'clase "' . __CLASS__ . '" se ha destruido<br>';
　　　　}
}
　
//crear un nuevo objeto
$obj = new MyClass;
　
//escribir un mensaje al final del archivo
echo "se ha alcanzado el final del archivo.";
?>

上面示例中的PHP代码将产生以下输出：

la clase "MyClass" se ha iniciado
se ha alcanzado el final del archivo.
la clase "MyClass" se ha destruido

Se llama automáticamente a la función destrucción al final del script. Pero, para activar explícitamente la función destrucción, se puede usar la función unset() de PHP para destruir el objeto, como se muestra a continuación:

<?php
class MyClass
{
　　　　//　构造函数
　　　　public　function　__construct(){
　　　　　　　　echo　'　类　"'　.　__CLASS__　.　'"　已启动<br>';
　　　　}
　　　　
　　　　//　función destrucción
　　　　public function __destruct(){
　　　　　　　　echo 'clase "' . __CLASS__ . '" se ha destruido<br>';
　　　　}
}
　
//crear un nuevo objeto
$obj = new MyClass;
　
//　destruir el objeto
unset($obj);
　
//escribir un mensaje al final del archivo
echo "se ha alcanzado el final del archivo.";
?>

Ahora, el código PHP del siguiente ejemplo producirá la siguiente salida:

la clase "MyClass" se ha iniciado
la clase "MyClass" se ha destruido
se ha alcanzado el final del archivo.

extender la clase a través de la herencia

La clase puede usar la palabra clave extends para heredar las propiedades y métodos de otra clase. El proceso de extensibilidad se llama herencia. Esto puede ser una de las razones más poderosas detrás del modelo de programación orientado a objetos.

<?php
//contiene la definición de clase
class Rectangle
{
　　　　//声明属性
　　　　public $longitud = 0;
　　　　public $ancho = 0;
　　　　
　　　　//método para calcular el perímetro
　　　　public function getPerimeter(){
　　　　　　　　devolver (2　*　($this->longitud　+　$this->ancho));
　　　　}
　　　　
　　　　//método para calcular el área
　　　　public function getArea(){
　　　　　　　　devolver ($this->longitud　*　$this->ancho);
　　　　}
}
　
//definir una nueva clase basada en la definición de clase existente
class Square extends Rectangle
{　　　
　　　　//método para probar si el rectángulo también es un cuadrado
　　　　public function isSquare(){
　　　　　　　　if($this->longitud == $this->ancho){
　　　　　　　　　　　　devolver true;　//　正方形
　　　　　　　　}　else{
　　　　　　　　　　　　return　false;　//不是正方形
　　　　　　　　}
　　　　}
}
　
//从Square类创建一个新对象
$obj　=　new　Square;
　
//　设置对象属性值
$obj->length　=　20;
$obj->width　=　20;
　
//　调用对象方法
if($obj->isSquare()){
　　　　echo　"正方形的面积是";
}　else{
　　　　echo　"矩形的面积是";
};
echo　$obj->getArea();
?>

上面示例中的PHP代码将产生以下输出：

正方形的面积是　400

正如您在上面的示例中看到的，尽管Square的类定义既没有显式包含getArea()方法，也没有显式包含$length和$width属性，但是Square类的实例可以使用它们，因为它们继承自父Rectangle类。

控制属性和方法的可见性

在使用类时，您甚至可以使用可见性关键字来限制对其属性和方法的访问，以实现更好的控制。 有三个可见性关键字（从最可见到最不可见）：public，protected，private，它们确定如何以及从何处访问和修改属性和方法。

• public - 可以从类内部和外部的任何位置访问公共属性或方法。 这是PHP中所有类成员的默认可见性。
  

• protected - 受保护的属性或方法只能从类本身或子类或继承类（即扩展该类的类）中访问。
  

• private - 私有属性或方法只能从定义它的类中访问。甚至子类或继承的类也无法访问私有属性或方法。

以下示例将向您展示这种可见性实际上是如何工作的：

<?php
//Definición de clase
class　Automobile
{
　　　　//声明属性
　　　　public　$fuel;
　　　　protected　$engine;
　　　　private　$transmission;
}
class　Car　extends　Automobile
{
　　　　//　构造函数
　　　　public　function　__construct(){
　　　　　　　　echo　'　类　"'　.　__CLASS__　.　'"　已启动<br>';
　　　　}
}
　
//从Automobile类创建对象
$automobile　=　new　Automobile;
　
//尝试设置$automobile对象属性
$automobile->fuel　=　'Petrol';　//　ok
$automobile->motor = ''1500 cc';　//　error fatal
$automobile->transmission = 'Manual';　//　error fatal
　
//Crear objeto desde la clase Car
$car = new Car;
　
//Intente establecer propiedades del objeto $car
$car->combustible = 'Diésel';　//　ok
$car->motor = ''2200 cc';　//　error fatal
$car->transmission = 'Automático';　//　undefined
?>

Propiedades y métodos estáticos

Además de la visibilidad, las propiedades y métodos también se pueden declarar como estáticos (estáticos), lo que permite acceder a ellos sin necesidad de una instancia de la clase. Se puede acceder a propiedades y métodos estáticos utilizando el operador de resolución de ámbito (::), como se muestra a continuación: ClassName::$property y ClassName::method().

A pesar de que se pueden usar métodos estáticos, no se puede acceder a propiedades declaradas como estáticas a través de un objeto de la clase, como se muestra en el siguiente ejemplo:

<?php
//Definición de clase
class HelloClass
{
　　　　//Declarar propiedad estática
　　　　public static $greeting = "¡Hola Mundo!";
　　　　
　　　　//Declarar método estático
　　　　public static function sayHello(){
　　　　　　　　echo self::$greeting;
　　　　}
}
//Intente acceder directamente a propiedades y métodos estáticos
echo HelloClass::$greeting;　//Salida: ¡Hola Mundo!
HelloClass::sayHello();　//Salida: ¡Hola Mundo!
　
//Intente acceder a propiedades y métodos estáticos a través de un objeto
$hello = new HelloClass;
echo $hello->greeting;　//　Advertencia estricta
$hello->sayHello();　//Salida: ¡Hola Mundo!
?>

En el ejemplo anterior, la palabra clave self representa 'la clase actual'. Nunca puede comenzar con el símbolo de dólar ($) y siempre comienza con el operador de resolución de ámbito (::), por ejemplo self :: $ name.

La palabra clave self es diferente a la palabra clave this, ya que representa 'el objeto actual' o 'la instancia actual de la clase'. Esta palabra clave siempre comienza con el símbolo de dólar ($) seguido de-> operadores (por ejemplo $ this-> nombre）。

Esperamos que ya haya entendido los conceptos básicos de programación orientada a objetos. En la sección de PHP y base de datos MySQL encontrará más ejemplos de OOP.