Desde la versión de PHP 5.0 se ha ido mejorando progresivamente la implementación del uso de Clases y Objetos con el fin de permitir el desarrollo de páginas y aplicaciones web mediante Programación Orientada a Objetos (OOP en español).
El crear una página o aplicación web haciendo uso de una correcta Programación Orientada a Objetos nos facilitará en gran medida la organización y reutilizacion del código y la depuración de errores, con lo cual nuestros proyectos web podrán ser mantenidos y ampliados de forma mucho más sencilla.
En el presente curso de PHP nos limitaremos a explicarte el manejo de Clases y Objetos en PHP. Para aprender conceptos básicos sobre Programación Orientada a Objetos haz clic en los enlaces relacionados, al final de cada sección.
Vea también: [ Clases y Objetos en PHP ] - [ Objetos y referencias ] - [ Cambios en POO/OOP ] - [ Métodos mágicos ]
Relacionado: [ Programación Orientada a Objetos ]
A continuación te mostraremos un sencillo ejemplo de cómo crear una Clase en PHP.
Persona.php:
<?php
class Persona
{
// Propiedades
private $nombre = null;
private $apellidos = null;
// Constantes:
const PERSONA_HOMBRE = "HOMBRE";
const PERSONA_MUJER = "MUJER";
// Constructor:
function __construct() {
echo "<p>En el Constructor de la Clase</p>";
}
/*
// El constructor también puede hacerse así (con el mismo nombre del Clase):
function Persona() {
echo "<p>En el Constructor de la Clase</p>";
}
*/
// Destructor:
function __destruct() {
echo "<p>En el Destructor de la Clase</p>";
}
// Métodos:
public function getNombre() {
return $this->nombre;
}
public function setNombre( $nombre ) {
$this->nombre = $nombre;
}
public function getApellidos() {
return $this->apellidos;
}
public function setApellidos( $apellidos ) {
$this->apellidos = $apellidos;
}
}
?>
01_crear_clase_objeto.php:
<?php
require_once("Persona.php");
// Crear un Objeto (una instancia de la Clase):
$objPersona = new Persona();
$objPersona->setNombre("MARTINA");
$objPersona->setApellidos("MARRERO MEDINA");
echo "Nombre: [".$objPersona->getNombre()."]<br/>"; // Devuelve: "Nombre: [MARTINA]"
echo "Apellidos: [".$objPersona->getApellidos()."]<br/>"; // Devuelve: "Apellidos: [MARRERO MEDINA]"
echo "Sexo: [".Persona::PERSONA_MUJER."]<br/>"; // Devuelve: 2
?>
Observa que antes de poder crear un Objeto es necesario incluir el archivo con la definición de la Clase, y que el Constructor de la Clase puede crearse de dos formas: usando el mismo nombre de la Clase o bien usando el método mágico __construct() (si creamos ambos métodos sólo se procesará éste último).
En el ejemplo anterior hemos creado también un Destructor de la Clase cuyo uso es opcional, y que se ejecutará al destruir un Objeto (si no lo hacemos manualmente, se destruirán al finalizar el script).
Fíjate también en que para obtener el valor de una constante escribimos el nombre de la Clase seguido del operador :: y finalmente el nombre de la constante.
Vea también: [ Clases y Objetos en PHP ] - [ Class ] - [ Constructores y Destructores ] - [ Propiedades ] - [ Constantes en Clases ]
Vea también: [ Métodos mágicos ] - [ Funciones de Clases y Objetos ]
Vea también: [ Incluir código de un archivo PHP en otro ] - [ require_once() ]
Relacionado: [ Clases y Objetos en Programación Orientada a Objetos ]
Si al definir una Clase no se especifica la visibilidad de alguno de sus miembros (public, private, protected), será tratado como public.
PHP no soporta sobrecarga de funciones, así pues una Clase no puede tener dos constructores o métodos con el mismo nombre.
Para aprender qué es la Herencia en Programación Orientada a Objetos, consulta el enlace al final de la sección.
Persona.php:
<?php
class Persona
{
// Propiedades
private $nombre = null;
private $apellidos = null;
private $sexo = null;
protected $caminando = false;
// Constructor:
function Persona() {
}
// Métodos:
function getNombre() {
return $this->nombre;
}
public function setNombre( $nombre ) {
$this->nombre = $nombre;
}
public function getApellidos() {
return $this->apellidos;
}
public function setApellidos( $apellidos ) {
$this->apellidos = $apellidos;
}
public function getSexo() {
return $this->sexo;
}
public function setSexo( $sexo ) {
$this->sexo = $sexo;
}
public function caminar()
{
if( $this->caminando == true )
{
echo "Ya está caminando...<br />";
}
else
{
$this->caminando = true;
echo "Comienza a caminar...<br />";
}
}
public function detenerse()
{
if( $this->caminando == true )
{
$this->caminando = false;
echo "Se detiene...<br />";
}
else
{
echo "No está caminando...<br />";
}
}
}
?>
Usuario.php:
<?php
// Incluimos el archivo con la definición de la Clase de la que heredamos
require_once("Persona.php");
class Usuario extends Persona
{
// Propiedades
private $nombreUsuario = null;
private $password = null;
// Constructor:
function Usuario() {
}
// Métodos:
public function getNombreUsuario() {
return $this->nombreUsuario;
}
public function setNombreUsuario( $nombreUsuario ) {
return $this->nombreUsuario = $nombreUsuario;
}
public function getPassword() {
return $this->password;
}
public function setPassword( $password ) {
return $this->password = $password;
}
// Redefinimos este método que existe también en la Clase padre:
public function detenerse()
{
/* Si quisiéramos que se procese también el método de la Clase padre
descomentaríamos la siguiente línea: */
// parent::detenerse();
if( $this->caminando == true )
{
$this->caminando = false;
echo "El usuario se detiene...<br />";
}
else
{
echo "El usuario no está caminando...<br />";
}
}
}
?>
02_objetos_herencia.php:
<?php
// Incluimos el archivo con la definición de la Clase usada
require_once("Usuario.php");
// Crear un Objeto (una instancia de la Clase):
$objUsuario = new Usuario();
$objUsuario->setNombre("MARTINA");
$objUsuario->setApellidos("MARRERO MEDINA");
$objUsuario->setNombreUsuario("MMMedina");
$objUsuario->setPassword("1234");
echo "Nombre: [".$objUsuario->getNombre()."]<br/>"; // Devuelve: "Nombre: [MARTINA]"
echo "Apellidos: [".$objUsuario->getApellidos()."]<br/>"; // Devuelve: "Apellidos: [MARRERO MEDINA]"
echo "Usuario: [".$objUsuario->getNombreUsuario()."]<br/>"; // Devuelve: "Usuario: [MMMedina]"
echo "Contraseña: [".$objUsuario->getPassword()."]<p/>"; // Devuelve: "Contraseña: [1234]"
$objUsuario->caminar();
$objUsuario->detenerse();
$objUsuario->detenerse();
?>
Observa que para poder acceder a una propiedad de la Clase padre desde la Clase hija, debe estar definida como protected.
Observa también que al redefinir un método en una Clase hija en ocasiones nos puede interesar se procese también, el mismo método de la Clase padre: para ello, usaremos la palabra reservada parent que explicaremos en el siguiente punto.
Vea también: [ Herencia en PHP ] - [ extends ]
Relacionado: [ Herencia en Programación Orientada a Objetos ]
A día de hoy, hasta la versión 5.3 de PHP no se soporta la herencia múltiple, aunque como en otros lenguajes de Programación Orientada a Objetos se puede simular mediante el uso de interfaces (los explicamos en el siguiente apartado).
Por ejemplo:
- En primer lugar creamos una Clase Persona que contenga las propiedades nombre, apellido1, apellido2, y sexo, así como los métodos necesarios para acceder a ellas.
- A continuación creamos una Interface de nombre Localizacion que defina los métodos setxxx() y getxxx() necesarios para acceder a unas propiedades llamadas direccion, cpostal, poblacion, provincia, pais, así como los métodos correspondientes (las propiedades no hay que definirlas en la interface, como veremos en el siguiente apartado).
- Finalmente, creamos otra Clase Profesor que extienda o herede de Persona e implemente la interface Localizacion (con lo cual deberán crearse los métodos definidas en ella).
Para aprender qué son las Interfaces en Programación Orientada a Objetos, consulta el enlace al final de la sección.
A continuación te mostramos un ejemplo de cómo crear una interface en PHP:
iGenero.php:
<?php
Interface iGenero
{
public function getGenero();
public function setGenero($genero);
}
?>
Persona.php:
<?php
// Incluimos el archivo con la definición de la Interface usada:
require_once("iGenero.php");
class Persona implements iGenero
{
// Propiedades
private $nombre = null;
private $apellidos = null;
private $genero = null;
// Constructor:
function Persona() {
}
// Métodos:
function getNombre() {
return $this->nombre;
}
public function setNombre( $nombre ) {
$this->nombre = $nombre;
}
public function getApellidos() {
return $this->apellidos;
}
public function setApellidos( $apellidos ) {
$this->apellidos = $apellidos;
}
// Métodos obligatorios según la interface (si se elimina alguno se generará un error):
public function getGenero() {
return $this->genero;
}
public function setGenero( $genero ) {
$this->genero = $genero;
}
}
?>
03_objetos_interfaces.php:
<?php
// Incluimos el archivo con la definición de la Clase usada:
require_once("Persona.php");
// Crear un Objeto (una instancia de la Clase):
$objPersona = new Persona();
$objPersona->setNombre("MARTINA");
$objPersona->setApellidos("MARRERO MEDINA");
$objPersona->setGenero("FEMENINO");
echo "Nombre: [".$objPersona->getNombre()."]<br/>"; // Devuelve: "Nombre: [MARTINA]"
echo "Apellidos: [".$objPersona->getApellidos()."]<br/>"; // Devuelve: "Apellidos: [MARRERO MEDINA]"
echo "Usuario: [".$objPersona->getGenero()."]<br/>"; // Devuelve: "Usuario: [FEMENINO]"
?>
Ten en cuenta que si no existieran los dos métodos definidos en la interface iGenero se generaría un error.
Vea también: [ Interfaces en PHP ]
Relacionado: [ Clases y Objetos en Programación Orientada a Objetos ]
