Introducción - PROGRAMACION ORIENTADA A OBJETOS

PHP comenzó su andadura como un simple lenguaje de scripts. A medida
que las versiones avanzaban, se fueron incluyendo algunas características
que permitían programar con orientación a objetos. Con la
aparición de PHP 5, los desabolladores tenemos una verdadera plataforma
de programación orientada a objetos, gracias a la potencia del
nuevo engine Zend 2.0, que permite ejecutar más rápido y eficientemente
este tipo de programas.

La programación orientada a objetos utiliza los elementos c l a s e y obj
e t o con punto de inicio. Actualmente, en las carreras técnicas, es posible
encontrar enseñanzas sobre lenguajes orientados a objetos como Java
o C++.

La programación orientada a objetos en PHP 5 no necesita una sintaxis
muy diferente, sino que es una aproximación a la realidad en otro camino
diferente al acostumbrado. Por ejemplo, si piensa en un programa que
tenga que averiguar la letra del DNI de un cliente, lo normal es que cree
una función con un parámetro al que le pase el número de DNI y le devuelva
la letra buscada.

Un desarrollo orientado a objetos pensaría en cada problema como una identidad
única, como un objeto. Puesto que el DNI siempre va asociado a una
persona, puede crear un objeto que identifique a personas, y dentro de ese
objeto programar una función (método en este caso) que calcule la letra. La
aproximación procedural (crear una función) no asocia esa función a personas
directamente y le podría pasar cualquier número entero, recibiendo una
respuesta válida. En cambio, la aproximación de objetos crea la función
dentro del objeto c l i e n t e y sólo permite, mediante técnicas que veremos
más adelante, recuperar la letra del DNI de una persona.

La programación orientada a objetos desarrolla nuevos conceptos y terminologías
que deben aprenderse correctamente para generar buen código.


Definición de clases
Una clase es un tipo de dato que contiene, en una misma estructura, variables
y funciones. Una clase es una especie de plantilla desde la que los
objetos son instanciados y toman su valor. Desde una clase se pueden construir
varios objetos del mismo tipo. La definición es la siguiente:

class pagina_Web
{
var $titulo;
function getTitulo()
{
return $this->titulo;
}
}

Mediante la palabra reservada c l a s s definimos una clase completa. Utilizando
var podemos definir las variables que utilizaremos en el desarrollo
del programa. La palabra reservada var desaparecerá en versiones
siguientes de PHP, a favor de las palabras publ ic , p r í v a t e y p r o t e c -
ted. Las funciones se definen como en el capítulo 5, siempre que estén
dentro de la construcción de la clase. En este capítulo vamos a definir una
clase completa cuya misión será mostrar una página Web. Podemos seguir
con el ejemplo ampliando las funciones:

<?php
class pagina_Web
{
var $titulo;
function setTitulo($titulo = "Titulo por defecto")
{
$this->titulo = $titulo;
}
function getTitulo()
{
return $this->titulo;
}
function cabecera()
{
echo ("<htmlxheadxtitle>") ;
echo $this->titulo;
echo (" </titlex/headxbody>") ,•
}
function cuerpo()
{
echo("Este es el cuerpo de la página Web");
function pie ( )
{
echo ("</bodyx/html>") ;
}
function mostrar_pagina()
{
echo $thís->cabecera () ;
echo $this->cuerpo() ;
echo $this->pie();
}
}

Como puede ver, la clase se divide en varias funciones y en una sola variable.
La variable $ ti t u l o guardará el título déla página Web. Las funciones
c a b e c e r a ( ) , c u e r p o () y p i e () son las encargadas de mostrar
las distintas partes de una Web.

Estas funciones se llaman desde la funciónmostrar_pagina (). Es interesante
observar que, en unas pocas líneas de código, hemos definido un
objeto que podría utilizarse como base de muchas aplicaciones.
El operador $ t h i s es una variable que contiene el objeto actual desde el
que la invocamos. Para acceder dentro de un objeto a funciones o variables
propias, debe anteponerse al nombre de éstas la expresión $ t h i s - >.

Para acceder desde la función m o s t r a r _ p a g i n a () a cualquiera de las
funciones de la clase tendrá que escribir:
$this->cabecera () ;
$this->cuerpo ( ) ;
$this->pie () ;

Instancia de clase
Para que el código funcione, necesita crear el objeto. Esto se hace utilizando
el operador new seguido del nombre de la clase:
$pagina = new pagina_Web() ;

Con el código anterior hemos creado un objeto que contiene todas las variables
y funciones de la clase pagina_Web ( ) . La variable que contiene
ese objeto es $pagina.

Para acceder a las funciones desde el nuevo objeto creado tenemos que
utilizar la variable que contiene al objeto, en este caso $pagina seguido
del operador - > y el nombre de la función. Para mostrar la Web tenemos
que seguir estos sencillos pasos:

$pagina = new pagina_Web();

$pagina->setTitulo("Página Web nueva");
$pagina- >mostrar__pagina ( ) ;

Función constructor
Existen algunas funciones especiales en la definición de una clase. La más
importante es el constructor. Esta se ejecuta cada vez que se crea un nuevo
objeto y permite crear las variables iniciales que se necesitan, como el
título de la Web o el autor. El nombre de la función debe ser const
r u c t () . Nuestro constructor se encargará de crear el título de la página
Web que estamos creando:
function construct($titulo)
{
$this->setTitulo($titulo);
}

Herencia
La programación orientada a objetos permite heredar de otras clases. Con
esta técnica puede ahorrar mucho tiempo de trabajo. La clase hija (clase
que hereda de otra) adquiere estas propiedades:

• Automáticamente obtiene todas las variables miembro de la clase padre.

• También obtiene todas las funciones miembro de la clase padre, que
funcionarán exactamente de la misma forma.

• La clase hija puede a su vez definir nuevas variables y funciones.
La sintaxis es la siguiente:

class pagina_Web_formulario extends pagina_Web
{
function formulario_inicio()
{
//Escribir el código necesario
}
}

La palabra reservada e x t e n d s indica que la nueva clase creada será una
extensión (heredará) de la clase que se escribe justo a la derecha de la definición.
Puede crear un objeto formulario a partir de la clase pagina_Web
de la siguiente forma:

class pagina_Web_formulario extends pagina_Web

function formularío_inicio($accion)
{
echo ("<form action=\"$accion\">");
}
function formulario_fin()
{
echo ("</form>");
}
function formulario_caj a_texto($nombre)
{
echo ("$nombre <input type=\"text\" name=\"$nombre\">");
}
function formulario_boton()
{
echo ("<input type=\"submit\" name=\"Submit\"
valúe = \"Enviar\">" ) ;
}
function mostrar_pagina ()
{
$this->cabecera () ;
$this- >f ormulario__inicio (" Índex . php") ;
$this- >f ormulario__caj a_texto ("Nombre") ;
$this->formulario_boton();
$this->formulario_fin();
$this- >pie () ;
}
}

Si ahora ejecuta el código instanciando la clase que hemos creado, puede
ver que las funciones c a b e c e r a () , p i e ( ) , incluso el constructor pueden
ser utilizadas aún no perteneciendo a la clase pagina_Web_f o r -
m u l a r i o .
$formulario = new pagina_Web_formulario{"Pagina con
formulario");
$formulario->mostrar_pagina ( ) ;

Métodos o funciones de objeto
Cuando definimos una clase hija, las funciones de la clase padre son automáticamente
heredadas. Se llama redefinición de métodos a la creación
de funciones en la clase hija, con el mismo nombre que en la clase padre.
En el ejemplo anterior, la función m o s t r a r _ p a g i n a ( ) de la clase
pagina_Web_f o r m u l a r i o está redefinida, ya que existe una función con el mismo nombre en la clase pagina_Web. Al instanciar el objeto y ejecutar
el método m o s t r a r _ p a g i n a ( ) , el método que se ha definido es la
clase hija.

PHP 5, con su nuevo motor Zend Engine 2, introduce la palabra reservada
f i n a l .
Si en la clase padre ponemos delante de cualquier función la palabra
f i n a l , ésta función no podrá ser sobrecargada en las clases que la hereden.
También podemos declarar clases completas como f i n a l , lo que significará
que no podrán ser heredadas.
final function mostrar_pagina()
{
echo $this->cabecera();
echo $this->cuerpo();
echo $this->pie();
}

Si definimos la función anterior como f i n a l en la clase pagina_Web, la
clase pagina_Web_f o r m u l a r i o no podrá tener una función con este
mismo nombre y mostrará un error en pantalla.
La figura 9.2 muestra el error que se produce al intentar sobrecargar un
método que está marcado como f i n a l .

Herencia encadenada
Algunos lenguajes de programación permiten heredar de varias clases a
la vez; esto es conocido como herencia múltiple. PHP 5 no permite herencia
múltiple, pero sí herencia encadenada, es decir, permite heredar de
varias clases padres correlativamente. Un ejemplo es:
class A
class B extends A
class C extends B
class D extends C

Valores y alcance de variables
En versiones anteriores de PHP, los objetos eran pasados por valor a otras
funciones, por lo tanto, el estado de los objetos no se conservaba. En PHP 5
los objetos son pasados por defecto por referencia, gracias al Zend Engine 2.

<?php
class Nombre
i
var $nombre;
function setNombre($nombre)
{
$this->nombre = $nombre;
}
function getNombre()
{
return $this->nombre;
}
}
function cambiaNombre($obj eto,$nombre)
{
$objeto->setNombre($nombre);
}
$luis = new Nombre;
$luis->setNombre("Luis Miguel");
echo "El nombre del objeto es " . $luis->getNombre() . "<br>";
cambiaNombre($luis,"Pedro");
eche "El nombre del objeto es " . $luis->getNombre() . "<br>";
?>

El código muestra cómo cambiar las propiedades de un objeto desde una
función con PHP 5.

Dentro de los objetos debe tener también cuidado con el alcance de las
variables. Las variables definidas fuera del entorno del objeto no son accesibles
desde los métodos de las clases, a menos que anteponga la palabra
g l o b a l .

Miembros públicos, privados y protegidos
Mientras no se especifique otra cosa, los métodos y propiedades de una
clase son siempre públicos, es decir, son accesibles desde fuera del objeto
de la forma: o b j e t o - >f u n c i ó n . Pero existe un camino para que las variables
y los métodos no puedan ser accedidos desde fuera del objeto. Eche
un vistazo ahora al objetopagina_Web. Su variable $ t i t u l o es público
porque no lo hemos definido de alguna forma especial. Para cambiar el
valor de esta variable podría utilizar la función asociada o directamente
haciendo $ o b j e t o - > t i t u l o = "nuevo v a l o r " . Esta forma de actuar
rompe con la filosofía de la programación orientada a objetos. Como norma
general, las propiedades de los objetos deben estar ocultas al entorno
exterior y tomar sus valores desde funciones definidas dentro del objeto.

Métodos privados
Si declaramos un método o propiedad como privada, sólo se podrá acceder
a él desde la clase que lo define. Las clases que hereden de una clase
con métodos privados, no tendrán acceso a éstos métodos y tampoco será
posible desde fuera del objeto hacer llamadas. Para hacer un método o
propiedad privado, sólo hay que anteponer la palabra p r í v a t e delante
de la declaración.

class pagina_Web
{
prívate $titulo;
function construct($titulo)
{
$this->setTitulo($titulo);
}
prívate function setTitulo($titulo = "Titulo por defecto")
{
$this->titulo = $titulo;
}

De esta manera, la clase p a g i n a _ W e b _ f o r m u l a r i o , que hereda de
pagina_Web, no puede acceder directamente a la función s e t T i t u l o () de la siguiente forma $ t h i s - > s e t T i t u l o ( " T i t u l o nuevo") porque
obtenemos un error de acceso ilegal. Después de esta modificación sólo es
posible dar un título a la página Web a través del constructor que, como sí
está dentro de la clase, tiene potestad para utilizarla.

Métodos protegidos
Los métodos protegidos son menos restrictivos que los privados. Cuando
declaramos un método como protegido, su visibilidad es en la clase que lo
declara y en todas las clases que lo heredan. El ejemplo anterior puede
modificarse de la siguiente forma:

c l a s s pagina_Web
{
protected $titulo;
function construct($titulo)
{
$this->setTitulo($titulo);
}
protected function setTitulo($titulo = "Titulo por defecto")
{
$this->titulo = $titulo;
}

Métodos públicos
Por defecto, todos los métodos y propiedades que se declaren en un objeto
son públicos, a menos que lleven asociados la palabra p r o t e c t e d o
p r í v a t e . Como buena práctica de programación, las variables deben definirse
como privadas o protegidas, para que no puedan modificarse desde
fuera del objeto. Además, deben llevar dos métodos públicos asociados:
s e t V a r i a b l e () para dar un nuevo valor a la variable y g e t V a r i a b l e ()
para recibir el valor actual de la propiedad. Veamos el ejemplo:

class pagina_Web
{
private $titulo;
function construct($titulo)
{
$this->setTitulo($titulo);
}
public function setTitulo($titulo = "Titulo por defecto")
{
$this->titulo = $titulo;
}

public function getTitulo()
{
return $this->titulo;
}

Interfaces
En proyectos profesionales a veces es necesario que un equipo de varias
personas trabajen juntas. En este caso se hace imprescindible definir unas
pautas generales de trabajo para que el resultado final sea el esperado. Si
el desarrollo consiste en programar varios objetos, el analista de la aplicación
puede definir la estructura básica en papel o crear una pequeña plantilla
con métodos que el objeto final debería tener obligatoriamente. Esta
plantilla es un i n t e r f a c e y permite definir una clase con funciones definidas,
pero sin desarrollar, que obliga a todas las clases que lo implementen
a declarar estos métodos como mínimo.

i n t e r f a c e Web
{
public function setTitulo($titulo = "Titulo por defecto");
public function getTitulo();
}
La interface anterior define la estructura básica que queremos para el objeto,
declarando las funciones setTitulo y getTitulo. Para que una clase haga
uso de la i n t e r f a c e se declara de la siguiente forma:
class pagina_Web implements Web

Clases abstractas
Un i n t e r f a c e no permite crear el cuerpo de ninguna función, dejando
esta tarea a las clases que la implementen. Las clases abstractas permiten
definir funciones que deben implementarse obligatoriamente en los objetos
que hereden y, además, permiten definir funciones completas que pueden
heredarse. Las clases abstractas deben llevar la palabra reservadaabstract
en la declaración de la clase y en todos los métodos que sólo definan su
nombre.

abstract class Web
{
protected $titulo;
public function setTitulo($titulo = "Titulo por defecto")
{
$this->titulo = $titulo;
}
abstract public function getTitulo() ;
}

En lugar de un i n t e r f a c e , hemos optado por utilizar una clase abstracta,
porque tenemos claro que el método s e t T i t u l o () tiene que funcionar
así. También se define el método abstracto g e t T i t u l o () , que
obligatoriamente debe ser declarado en la clase que herede de ésta. En
realidad, un i n t e r f a c e es una clase que tiene todos sus métodos abstractos.

Clases con métodos estáticos
En PHP 5 puede declarar funciones dentro de una clase que no utilicen
propiedades o métodos de la misma. Estos métodos pueden calcular valores
numéricos, hacer una conexión a una base de datos o comprobar que
un correo electrónico esté bien definido. Aunque no existe ninguna palabra
reservada para definirlo, son conocidos como métodos estáticos y pueden
ser utilizados sin necesidad de instanciar un objeto.

<?php
class Nombre
{
protected $nombre;
public function getNombre(}
return $this->nombre;
public function setNombre($nombre)
$this->nombre = $nombre;
public function NombreDefecto()
return "Luis Miguel<br>";
}
$luis = new Nombre;
echo $luis->NombreDefecto();
//También se puede acceder al nombre por defecto
echo Nombre::NombreDefecto();
?>

Para acceder a un método estático desde el cuerpo del programa se escribe
el nombre de la clase que lo implementa seguido del operador ( :: ) y el
nombre del método. En el ejemplo vemos que se puede acceder al método
NombreDef e c t o () creando un objeto o mediante la construcción
Nombre: : NombreDef e c t o . Si intenta llamar a un método que no es
estático de esta forma se imprimirá un error en pantalla. La figura 9.4
muestra el error que recibe si intenta llamar a un método no estático desde
fuera de un objeto.

Llamadas a funciones padre
El operador ( :: ) se puede utilizar también dentro de una clase para
hacer llamadas a funciones de la clase padre que estén sobrecargadas.
Si define un constructor para la clase padre y otro para la clase hijo,
cuando cree el objeto, el constructor que se ejecuta es el de nivel inferior,
el constructor hijo. Para llamar al constructor padre debe utilizarse
la nomenclatura Nombre_clase_padre : : c o n s t r u c t () .

<?php
class Nombre
{
protected $nombre;
f unet ion construct ( $nombre)
{
$this->nombre = $nombre;
}
publie function getNombre()
{
return $this->nombre;
}
publie function setNombre($nombre)
{
$this->nombre = $nombre;
}
publie function NombreDefecto()
{
return "Luis Miguel<br>";
}
}
class Apellido extends Nombre
{
protected $apellidos;
function construct($nombre,$apellidos)
{
$this->apellidos = $apellidos;
Nombre: : construct(Snombre) ;
}
publie function getApellidos ()
{
return $this->apellidos;
}
}

$luis = new Apellido("Luis Miguel","Cabezas Granado");
echo $luis->getNombre() . "<br>";
echo $luis->getApellidos();
?>

Puede ver que el constructor de la clase Apellido inicializa la variable $apell idos y, seguidamente, llama al constructor de la clase padre Nombre.
Esta forma de actuar puede resultar complicada si no conoce el nombre
de la clase padre. La solución a este pequeño inconveniente la tenemos en
la palabra parent, que hace alusión a la clase de la que heredamos. El
código anterior puede quedar de esta forma:

class Apellido extends Nombre
{
protected $apellidos;
function construct($nombre,$apellidos)
{
$this->apellidos = $apellidos;

p a r e n t : : construct($nombre);
}
public function getApellidos()
{
return $this->apellidos;
}
}

Sobrecarga de métodos
Algunos lenguajes de programación orientados a objetos permiten declarar
más de un método con el mismo nombre. La definición de estos métodos
varía en el número de parámetros o en los tipos de datos de los
argumentos. PHP 5 no permite sobrecarga de métodos, pero puede simular
esta actuación empleando la técnica de las funciones con un número
variable de parámetros. El constructor de la clase A p e l l i d o puede quedar
de la siguiente forma:

class Apellido extends Nombre
{
protected $apellidos;
function construct($nombre)
{
if (func_num_args()= = 2 ) {
$apellidos = func_get_arg(1);
$this->nombre = $nombre;
$this->apellidos = $apellidos;
parent:: construct($nombre);
} else {
$this->nombre = $nombre;
$this->apellidos = $apellidos;
parent:: construct($nombre);
}
}
public function getApellidos()
{
return $this->apellidos;
}
}

Señalización
Los objetos son, en realidad, un conjunto de datos y funciones que guardan
una serie de estados de ejecución. Este conjunto de bits se pueden almacenar, en un momento dado, y recuperar justo en el mismo estado en
el que se encontraba cuando lo guardamos. Esta técnica se llama señalización
y permite almacenar y recuperar el conjunto de bits que forman un
objeto.

PHP 5 ofrece dos funciones, s e r i a l i ze () y u n s e r i a l i z e ( ) , que toman
como parámetro un objeto y devuelven una cadena de caracteres. Los
objetos serializados los podemos almacenar en base de datos, ficheros, etcétera.

$luis = new Apellido("Luis Miguel");
echo $luis->getNombre() . "<br>";
echo $luis- >getApellidos () ,-
$manuel = serialize($luis);
$pedro = unserialize($manuel);
echo $pedro->getNombre () ;

El código anterior crea el objeto $ l u i s y utiliza los métodos propios de la
clase y los heredados. Después, utilizamos la función s e r i a l i z e () para
grabar el estado del objeto como un conjunto de caracteres en la variable
$manuel. La variable $pedro contiene el resultado de aplicar u n s e r i a l
i z e () a $manuel.

De esta forma, conseguimos recuperar el objeto $ l u i s con los datos que
ya habíamos almacenado.

Funciones de manejo de clases
Las funciones siguientes son útiles para recuperar información sobre la
herencia de las clases, sobre métodos o variables miembro o llamadas a
las funciones.

Puede ver el funcionamiento de la función g e t _ c l a s s () en el ejemplo
siguiente y el resultado en la figura 9.5.
$luis = new Nombre;
echo $luis->NombreDefecto();
echo 'La variable $luis es un objeto del tipo: '
get_class($luis);

Resumen
Existe, en el mundo de los desabolladores de PHP, una antigua disputa
sobre la mejor forma de afrontar un proyecto Web. Unos opinan que la
forma más rápida de crear una Web es realizar funciones separadas en
ficheros y, desde las páginas del proyecto, hacer las llamadas necesarias.
La otra vertiente opina que merece la pena dedicar un poco más de tiempo
al desarrollo de objetos, porque después redundará en un gran beneficio
en futuros programas. En realidad depende del proyecto. Si sólo
necesita crear un formulario para recibir datos de un usuario, quizá no
merezca la pena crear un objeto y sí algunas funciones de control. Si su
proyecto va a ser muy extenso, la recomendación es que prepare un compendio
de objetos que se interrelacionen para llevar a buen término el
programa.
Puesto que el libro versa sobre PHP 5 y sus mejoras con respecto a las versiones
anteriores, intentaremos en los capítulos siguientes realizar la mayoría
de los ejemplos en metodología orientada a objetos.