1 - PHP 5 - Programación Orientada a Objetos

Porque Objetos?
________________________________________
A medida que las secuencias de comandos se hacen cada vez mas complejas, la dificultad de mantenerlas aumenta extraordinariamente, especialmente si estamos programando con estilos de procedimientos. El concepto de programación orientada a objetos OOP, sirve para proporcionar una estructura organizativa real a nuestras secuencias de comandos a través del encapsulado.
Aunque PHP 4 introdujo la noción de OOP en PHP, no se puede considerar realmente una verdadera implantación orientada a objetos. Debido a las significativas limitaciones en PHP 4 a este respecto, el modelo de objetos de PHP 5 se ha rediseñado completamente para reflejar con precisión la definición académica de OOP.


Creación de clases básicas
________________________________________
Aunque denominemos programación orientada a objetos a este estilo de programación, la gran mayoría de la programación se realiza desarrollando clases. Una clase puede definirse como el diseño de un objeto y define todas las acciones que el objeto puede realzar. Por tanto, las definiciones de clase contienen variables, funciones (denominadas métodos) e incluso constantes que son especificadas solo para dicha clase o sus instancias.
Ejemplo:

class myEjemplo
{
public $Myvar
public function MiMetodo($parametro)
{
$this->Myvar = $parametro;
echo $this->Myvar;
}
}


Cuando se ha definido una clase se puede crear una instancia de dicha clase, una instancia de una clase es un objeto y representa una copia de la clase definida previamente. Para crear una instancia de myEjemplo utilizamos la sentencia new:

incluye_once(‘MiArchivo.php’);
$miInstancia = new myEjemplo();
$otraInstancia = new myEjemplo();

En este caso las dos variables representan objetos del tipo myEjemplo. Aunque se han creado de la misma definición de clase, son completamente diferentes entre si.

incluye_once(‘MiArchivo.php’);
$miInstancia = new myEjemplo();
$miInstancia -> MiMetodo(“Hola soy un parámetro recibido”);

Cuando se ejecute este comando en la pantalla se vera impreso lo que le pasamos por parámetros.


Métodos private, protected y public
________________________________________
En PHP 5 la definición y el uso de clases no ha cambiado mucho. De hecho, en PHP si definiéramos una clase al estilo PHP 4 trabajaría igual, pero en sintaxis 5, nos ofrece las diferencias arriba mencionadas.
Esta diferencia nos ofrece una nueva e importante opción en el modelo de orientación a objetos de PHP 5: los controles de acceso. En PHP 4 no había ningún concepto de control de acceso dentro de los objetos. Como desarrollador externo que utiliza la clase myEjemplo, no hay nada que me impida cambiar el valor de la variable $Myvar. Sin embargo en PHP 5 el modelo de objetos proporciona ahora tres niveles de acceso para los miembros de clase, que restringen los datos a los que se puede acceder y desde donde se pueden acceder a ellos en nuestras secuencias de comandos. Estos tres modelos de acceso son public(publico), private(privado) y protected(protegido) y se pueden aplicar tanto a métodos como a propiedades de la clase.
A los miembros de la clase declarados como públicos se puede acceder desde cualquier parte de una secuencia de comandos. Pueden modificarse o llamarse internamente por el objeto o desde fuera del objeto, algo que no se aplica a los miembros de clase solo desde dentro de una instancia de dicha clase a través de la variable $this.
El tercer y último nivel de acceso que proporciona PHP es el nivel protected. Este nivel es similar a la private, ya que evita el acceso a miembros de clase externamente. Sin embargo, al contrario de private que restringe el acceso solo a la clase especifica donde se ha definido, protected permite el acceso desde la misma clase o desde cualquier clase hija.

Indicaciones de tipo.
________________________________________

Otra mejora en PHP 5 para el modelo de objetos es el concepto de indicaciones de tipo. PHP es, por diseño, un lenguaje sin tipos, es decir, las variables no se restringen al tipo de datos que contienen. De hecho, algunas variables pueden tratarse en un momento como enteros y en otro como cadenas. Sin embargo, como los métodos dentro de los objetos normalmente aceptan parámetros que son instancias de otros objetos, PHP 5 nos permite restringir los tipos de datos de los parámetros de método.
Por ejemplo consideremos el siguiente ejemplo:

class entero
{
private $numero
public function getInt()
{
return (int) $this->numero;
}
public function setInt($num)
{
$this->numero = (int) $num;
}
}

class flotante
{
private $numero;
public function getFloat()
{
return (float) $this->numero;
}
public function setFloat($num)
{
$this->numero = (float) $num;
}
}


Estas clases definen entero y flotante, que aplican un envolvente simple para los tipos de datos enteros y de punto flotante dentro de php. Y que hay si necesitamos aplicar una clase de forma que se añadan solo los puntos flotantes? Con los conocimientos que ustedes tienen podríamos resolverlos de esta manera:

class math
{
public function add($op1, $op2)
{
return $op1->getFloar() + $op2->getFloat();
}
}


Sin embargo, debido a la naturaleza de PHP, no hay seguridad de que los parámetros $op1 y $op2 serán instancias de la clase flotante. Incluso aunque estuviésemos seguros de que fuesen objetos, no habría ningún método conveniente para saber si son del tipo correcto. Una posible solución es utilizar el nuevo operador instanceof en PHP 5, que devuelve un valor booleano que indica si una variable es una instancia de una determinada clase:

class math
{
public function add($op1, $op2)
{
if(($op1 instanceof flotante) && ($op2 intanceof flotante))
{
return $op1->getFloat() + $op2->getFloat();
}
else
{
echo ‘Deben pasar dos flotantes como instancias en los parámetros’;
}
}
}


Nuestra clase math tiene un método para asegurarse de que los parámetros que se pasan son objetos del tipo correcto. Sin embargo dicha técnica puede conseguir que nuestro código sea propenso a error y confuso en su lectura. Una mejor solución que consigue el mismo objetivo es especificar el tipo exacto que necesitamos en el prototipo de la función.

class math
{
public function add(flotante $op1, flotante $op2)
{
return $op1->getFloat() + $op2->getFloat();
}
}

De este modo podemos indicar claramente el tipo especifico requerido por el método add() y podemos suponer con seguridad de que va a existir el método getFloat().


Constructores y Destructores
________________________________________
Los constructores y destructores son funciones a las que llamamos cuando creamos una nueva instancia de un objeto(contructores), y/o la destruimos(destructores). Su proposito principal es permitir inicializar y limpiar después un objeto, por ejemplo:

class BaseClass
{
function __construct()
{
print ‘contructor en clase base\n’;
}
}

class SubClass extendí BaseClass
{
function __construct()
{
parent::__construct();
print ‘Constructor en subclase\n’;
}
}

$obj = new BaseClass();
$obj = new SubClass();


Los constructores padres no son llamados implícitamente si la clase hijo define un constructor. Para poder ejecutar el constructor de la clase padre, se debe hacer una llamada a parent::__construct() dentro del constructor de la clase hijo.
Este es un ejemplo de destructor:

class MyDestructableClass
{
function __construct()
{
print ‘In constructor\n’;
$this->name = ‘MyDestructableClass’;
}
function __destruct()
{
print ‘Destroying ‘ . $this->name – “\n”;
}
}
$obj = new MyDestructableClass();


Aunque los constructores son útiles para inicializar propiedades de clase, la combinación de constructores y destructores es igualmente útil de otras formas. Un ejemplo clásico es una clase para acceder a la conexión de una base de datos, donde un constructor crea la conexión y el destructor la cierra.


Constantes de Clase.
________________________________________

Las constantes de clase son una nueva caracteristica de PHP 5 que proporcionan, como su nombre implica, una opcion para definir valores constantes dentro de una definición de clase. Por ejemplo:

class MyClass
{
const constant = ‘Valor Constante’;
function showConstant()
{
echo self::constant . “\n”;
}
}
echo MyClass::constant . “\n”;

$class = new MyClass();
$class -> showConstant();
// echo $class::constant; NO ESTA PERMITIDO


El ejemplo ilustra el usa de las constantes de clase tanto en la propia clase como fuera de ella. Para acceder desde fuera de la clase tendríamos que usar el operador de resolución (también llamado Paamayim Nekudotayim) o en términos simples, dobles dos puntos (::), es un símbolo que permite acceso a los miembros o métodos estáticos, constantes y eliminados de una clase.


Métodos Estáticos
________________________________________

Los metodos estaticos son metodos que forman parte de una clase, pero que se han diseñado para llamarse desde fuera del contexto de la instancia de un objeto. Se comprotan de forma identica a los metodos normales en una clase desde todos los puntos de vista excepto en un detalle importante: los metodos estaticos no pueden utilizar la varibles $this para hacer referencia a la instancia actual del objeto.
Ejemplo de un metodo estatico:

class Foo
{
public static $my_Static = ‘foo’;
public function staticValue()
{
return self::$my_static;
}
}

class Bar extends Foo
{
public function fooStatic()
{
return parent::$my_static;
}
}

print Foo::$my_static . “\n”;
$foo = new Foo();
print $foo -> staticValue() . “\n”;
print $foo -> my_static . “\n”;
// Propiedad indefinida my_static
//$foo::my_static no es possible

print Bar::$my_static . “\n”;
$bar = new Bar();
print $bar -> fooStatic() . “\n”;



Herencia de Clases
________________________________________

La herencia es por definición, la capacidad de una definición de clase extender otra funcionalidad de definición de clase.
Cuando se hereda una clase de otra, todos los métodos, propiedades y constantes de la clase padre se encuentra n disponibles también desde la clase hija. Así mismo, las clases hijas también pueden volver a implantar algunos o todos los métodos, propiedades y constantes de una clase padre para proporcionar una funcionalidad adicional o diferente. Las clases se heredan de otra utilizando la palabra clave extends en la definición de clase.


Clases y Métodos abstractos
________________________________________

Como su nombre implica, las clases abstractas se utilizan en OOP para definir objetos abstractos. Para entender lo que define a un objeto abstracto consideremos el concepto de la comida. Todos sabemos lo que es la comida, pero, lo hemos visto?. Hemos visto varios tipos de comida, carne, pollo, verdura, etc, pero el concepto de comida es en si un concepto abstracto. Ese concepto también se aplica a las clases abstractas. En OOP, las clases abstractas se diseñan para proporcionar una súper clase que define las características abstractas de las clases heredadas. Las clases abstractas pueden o no tener código en ellas, y nunca pueden crear instancias de ellas directamente.

Ejemplo de una clase abstracta y su herencia correspondiente:

abstract class AbstractClass
{
//Forza a las clases extendidas a implementar estos metodos
abstract protected function getValue();
abstract protected function prefixValue($prefix);

//metodo comun
public function printOut()
{
print $this -> getValue() . “\n”;
}
}

class ConcreteClass1 extends AbstractClass
{
protected function getValue()
{
return ‘concreteClass1’;
}
public function prefixValue($prefix)
{
return ‘{prefix]}ConcreteClass1’;
}
}


class ConcreteClass2 extends AbstractClass
{
protected function getValue()
{
return ‘concreteClass2’;
}
public function prefixValue($prefix)
{
return ‘{prefix]}ConcreteClass2’;
}
}

$class1 = new ConcreteClass1();
$class1 -> printout();
echo $class1 -> prefixValue(‘FOO_’) . “\n”

$class2 = new ConcreteClass2();
$class2 -> printout();
echo $class2 -> prefixValue(‘FOO_’) . “\n”



El resultado del ejemplo seria:

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2