domingo, 14 de diciembre de 2014

La Clase - Programación Orientada a Objetos en PHP - 3 de 3



11. Las constantes de clase

Una constante de clase es similar a una constante normal, es decir, un valor asignado a un nombre y que no cambia nunca.

Ejemplo de declaración de una constante normal:

define(’PI’,3.1415926535);

Una constante de clase representa una constante pero que está unida a esta clase.

Para crear un animal con el constructor __construct ($color, $peso), escriba:

$perro = new Animal("gris",10);

Si lee el código, no puede saber inmediatamente que el número 10 representa el peso del animal.

Utilice constantes que representen, cada una, un peso distinto:

const PESO_LIGERO = 5;
const PESO_MEDIO = 10;
const PESO_PESADO = 15;

Las constantes siempre están en mayúsculas, sin el símbolo $ y precedidas de la palabra clave const.

La clase Animal.class.php se convierte en:

<?php
class Animal
{
// Declaración de atributos
private $color = "gris";
private $peso = 10;
//constantes de clase
const PESO_LIGERO = 5;
const PESO_MEDIO = 10;
const PESO_PESADO = 15;
etc.
.
.
.
?>

Para llamar a esta constante desde la página uso.php, la sintaxis es algo peculiar. Debe escribir :: entre la clase y su constante:

<?php
//carga de la clase
include(’Animal.class.php’);
//instanciar la clase Animal con su constructor
$pez1 = new Animal("gris",Animal::PESO_MEDIO);
$pez2 = new Animal("rojo",Animal::PESO_LIGERO);
//leer el peso
echo "El peso del pez1 es:".$pez1->getPeso()." kg<br />";
//leer el peso
echo "El peso del pez2 es:".$pez2->getPeso()." kg<br />";
//el pez1 se come al pez2
$pez1->comer_animal($pez2);
//leer el peso
echo "El nuevo peso del pez1 es:".$pez1->getPeso()." kg<br />";
//leer el nuevo peso
echo "El nuevo peso del pez2 es:".$pez2->getPeso()." kg<br />";
?>

Da como resultado:

Llamada al constructor.
Llamada al constructor.
El peso del pez1 es:10 kg
El peso del pez2 es:5 kg
El nuevo peso del pez1 es:15 kg
El nuevo peso del pez2 es:0 kg

Animal::PESO_MEDIO siempre es 10, sea cual sea la instancia. Por lo tanto, la constante no está unida a la instancia, sino a la clase. Por este motivo la sintaxis es peculiar.


12. Los atributos y métodos estáticos

a. Método estático

El método estático está unido a la clase, pero no al objeto. En el ejemplo de la clase Animal, un método estático está unido al Animal, y no a los perros, los gatos o los peces.

Para convertir un método estático, debe añadir la palabra clave static delante de function.

Por ejemplo, modifique el método moverse() para convertirlo en estático y muestre "El animal se mueve.".

La clase Animal.class.php se convierte en:

<?php
class Animal
{
// Declaración de atributos
private $color = "gris";
private $peso = 10;
//constantes de clase
const PESO_LIGERO = 5;
const PESO_MEDIO = 10;
const PESO_PESADO = 15;
public function __construct ($color, $peso)
// Constructor que solicita 2 argumentos.
{
echo ’Llamada al constructor.<br />’;
$this->color = $color; // Inicialización del color.
$this->peso = $peso; // Inicialización del peso.
}
//accesos
public function getColor()
{
return $this->color; //devuelve el color
}
public function setColor($color)
{
$this->color = $color; //escrito en el atributo color
}
public function getPeso()
{
return $this->peso; //devuelve el peso
}
public function setPeso($peso)
{
$this->peso = $peso; //escrito en el atributo peso
}
//métodos
public function comer_animal(Animal $animal_comido)
{
//el animal que come aumenta su peso tanto como
//el del animal comido
$this->peso = $this->peso + $animal_comido->peso;
//el peso del animal comido y su color se restablecen a 0
$animal_comido->peso = 0;
$animal_comido->color = "";
}
public static function moverse()
{
echo "El animal se mueve.";
}
public function añadir_un_kilo()
{
$this->peso = $this->peso + 1;
}
}
?>

Es imposible escribir en un método estático la palabra clave $this, ya que representa el objeto, y el método estático está unido a la clase.

Para llamar a este método desde la página uso.php, debe utilizar la misma sintaxis que en las constantes (también unidas a la clase), es decir, introducir :: entre la clase y su método estático:

<?php
//carga de la clase
include(’Animal.class.php’);
//llamada al método estático
Animal::moverse()
?>

Da como resultado:

El animal se mueve.

Puede llamar al método estático desde un objeto, pero el método estático no puede cambiar nada de este objeto:

<?php
//carga de la clase
include(’Animal.class.php’);
//instanciar la clase Animal con su constructor
$perro1 = new Animal("gris",Animal::PESO_MEDIO);
//llamada al método estático
$perro1->moverse();
?>

Da como resultado:

Llamada al constructor
El animal se mueve.


b. Atributo estático

Un atributo estático es un atributo propio de la clase y no del objeto, al igual que en los métodos estáticos. Es el mismo principio que en una constante, salvo que el atributo está en una variable y puede cambiar su valor.

Un atributo estático se escribe añadiendo la palabra clave static delante de su nombre.

Por ejemplo, para añadir un atributo estático que representa a un contador que indica el número de veces que se instancia la clase:

La clase Animal.class.php se convierte en:

<?php
class Animal
{
// Declaración de atributos
private $color = "gris";
private $peso = 10;
//constantes de clase
const PESO_LIGERO = 5;
const PESO_MEDIO = 10;
const PESO_PESADO = 15;
// Declaración de la variable estática $contador
private static $contador = 0;
etc.
.
.
.
?>

Para cambiar el valor de este contador, no puede utilizar $this. De hecho, $this representa un objeto (perro, gato), y no la clase Animal. El contador es de tipo estático y por lo tanto está unido a la clase. Para llamar a este atributo en la clase, debe utilizar la palabra clave self, que representa la clase.

Para añadir 1 al contador cada vez que vaya a instanciar la clase Animal, debe modificar el constructor. A continuación debe añadir un método que permita leer este atributo privado con ayuda de un método de tipo public static y getContador().

La clase Animal.class.php se convierte en:

<?php
class Animal
{
// Declaración de atributos
private $color = "gris";
private $peso = 10;
//constantes de clase
const PESO_LIGERO = 5;
const PESO_MEDIO = 10;
const PESO_PESADO = 15;
// Declaración de la variable estática $contador
private static $contador = 0;
public function __construct ($color, $peso) // Constructor
//que solicita 2 argumentos.
{
echo ’Llamada al constructor.<br />’;
$this->color = $color; // Inicialización del color.
$this->peso = $peso; // Inicialización del peso.
self::$contador = self::$contador + 1;
}
// método estático que devuelve el valor del contador
public static function getContador()
{
return self::$contador;
}
...
?>

La página uso.php:

<?php
//carga de la clase
include(’Animal.class.php’);
//instanciar la clase Animal
$perro1 = new Animal("rojo",10);
//instanciar la clase Animal
$perro2 = new Animal("gris",5);
//instanciar la clase Animal
$perro3 = new Animal("negro",15);
//instanciar la clase Animal
$perro4 = new Animal("blanco",8);
//llamada al método estático
echo "Número de animales que se han instanciado:".Animal::
getContador();
?>

Da como resultado:

Llamada al constructor.
Llamada al constructor.
Llamada al constructor.
Llamada al constructor.
Número de animales que se han instanciado:4



Espero haber ayudado en algo. Hasta la próxima oportunidad!








No hay comentarios:

Publicar un comentario en la entrada