En sus inicios, PHP no era un lenguaje de programación Orientado a Objetos o bien OOP que son sus siglas en inglés, con el avance de las tecnologías y con las nuevas versiones PHP fue agregando varias funcionalidades propias de la metodología OOP.
Dividiremos este tutorial en las siguientes secciones, que son las que definen si un lenguaje es orientado a objetos o no:
· Clases y Objetos
· Métodos y atributos
· Herencia de clases
· Constructores y destructores
· Encapsulamiento
Clases y Objetos:
A diferencia de la programación tradicional, la programación orientada a objetos se base en clases y objetos.
Una clase contiene atributos o propiedades y métodos que son las funciones. Esto es muy importante tenerlo claro. Método es sinónimo de Función. Atributo es sinónimo de Propiedad.
La Clase sería algo así como un molde y a partir de ese molde se crean objetos.
En PHP definimos una clase de la siguiente manera:
class Cliente
{
// Aquí va el código de nuestra clase
}
Mediante las líneas de código de arriba se define la clase “Cliente” la cual utilizaremos para nuestro tutorial.
Si bien este tutorial no está enfocado a definir los conceptos de la Programación Orientada a Objetos, es bueno aclarar que el nombre de la clase no debe ser en plural, por este motivo nombramos “Cliente” en lugar de “Clientes”.
Métodos y Atributos
Los métodos y los atributos se definen “codifican” dentro de la clase. El atributo de una clase es una propiedad.
Atributos:
El orden y la prolijidad en programación son muy importantes. Por lo tanto, comenzaremos analizar nuestra clase de “arriba” hacia “abajo”. Lo primero que se define en una clase son los atributos.
Por ejemplo: en nuestra clase de ejemplo “Cliente” un atributo seria “Nombre”, “Apellido”, “Edad” etc.
Si nuestro ejemplo fuera una clase “Automovil”, los atributos serian: “rueda”,”marca”,”modelo” etc. ¿Más claro ahora?
Muy bien, sigamos adelante definiendo los atributos de nuestra clase, para lo cual utilizaremos la palabra reservada “private” o si trabajas con versiones de PHP inferiores a 5.0 deberás usar “var”, por lo tango nuestra clase se vera de la siguiente manera:
class Cliente
{
// estos valores de abajo son los atributos o propiedades de nuestra clase
private $mNombre;
private $mApellido;
private $mDireccion;
private $mPais;
private $mTelefono;
private $mEdad;
private $mFechaNacimiento;
}
En otras palabras, los atributos son visibles o accesibles dentro la propia clase.
Si seguimos los estándares de Programación Orientada a Objetos debemos definir los atributos como privados. Es decir, que sean accesibles solamente desde dentro de la clase misma, por lo tango utilizamos “private”. En otras palabras, ninguna otra clase y en ninguna otra parte de código se podrá cambiar un atributo perteneciente a
Métodos o Funciones:
Un método es lo mismo que una función, es una porción de código dentro de la clase que realiza una tarea y puede devolver un valor o no.
Los primeros métodos que definiremos en nuestra clase serán los que asignan valores a nuestros atributos. En este punto siempre hay discrepancia en la comunidad de programadores. La discusión está en si es mejor crear un método para cada atributo o bien crear atributos públicos y de esa manera evitamos la definición de métodos individuales. Esto puede sonar confuso, lo veremos con un ejemplo:
Para que puedas ver la diferencia es necesario ver primero la forma que insume más código para que luego las puedas comparar. Entonces, volviendo a los métodos, definiremos dos que se encargaran de asignar y retornar un valor a la propiedad nombre.
Métodos que controlan nuestros atributos.
Agregamos el siguiente código inmediatamente después de nuestras propiedades.
function setNombre($val)
{
$this->mNombre = $val;
}
function getNombre()
{
return $this->mNombre ;
}
La clase “Cliente” con los métodos quedaría de la siguiente manera:
class Cliente
{
// esto de abajo son los atributos o propiedades de nuestra clase
private $mNombre;
private $mApellido;
private $mDireccion;
private $mPais;
private $mTelefono;
private $mEdad;
private $mFechaNacimiento;
function setNombre($val) //método que asigna una valor a la propiedad nombre
{
$this->mNombre = $val;
}
function getNombre() //método que retorna el valor asignado a la propiedad nombre
{
return $this->mNombre ;
}
}
El método “setNombre” recibe un valor por parámetro y mediante la utilización de “$this” lo asignamos. Recuerda, “$this” se usa solo dentro de las clases.
El método “getNombre” funciona de forma inversa y retorna el valor de la propiedad, utilizamos “return” para devolverlo.
El ejemplo de arriba es el más recomendado, pero requiere más líneas de código, lo que se traduce en más tiempo.
Recién ahora estaríamos en condiciones de realizar pruebas con nuestra clase. Luego, veremos la segunda manera de asignar valores a los atributos de la clase.
Probando nuestra clase:
Para probar lo que hemos venido aprendiendo hasta ahora créate una página php llamada prueba.php y agrega el código siguiente:
require("classes/Cliente.php");
//creamos objeto para nuestro primer cliente
$auxCliente = new Cliente();
//asignamos un nombre a nuestro objeto Cliente
$auxCliente->setNombre("Ariel") ;
//creamos objeto para nuestro segundo cliente
$auxCliente2 = new Cliente();
//asignamos un nombre a nuestro segundo objeto Cliente
$auxCliente2->setNombre("Pedro") ;
//recuperamos el nombre que asignamos mediante el metodo getNombre
echo "El nombre del primer cliente es: ".$auxCliente->getNombre()."<br>";
echo "El nombre del segundo cliente es: ".$auxCliente2->getNombre()."<br>";
Analizando un poco el código, la primera línea lo que hace es incluir el archivo que tiene la clase “Cliente”, una vez incluida en “prueba.php” ya podemos utilizarla.
Paso 1 para utilizar la clase:
Lo primero que hay que hacer para usar la clase es “crear una instancia” de la misma. Lo que nos da un objeto o modelo de esa clase, por lo tanto: “$auxCliente = new Cliente();” nos crea un objeto llamado ““$auxCliente” de la clase “Cliente”. Recuerden que es un objeto y esta “vacío” en lenguaje cotidiano. Es un molde.
Usando un término más humano, el cliente no tiene nombre, apellido, teléfono etc por el momento.
Paso 2, asignar valores a los atributos:
Al tener ya nuestro objeto podemos asignarle un nombre al cliente, lo hacemos utilizando el método correspondiente de la siguiente manera:
//asignamos un nombre a nuestro objeto Cliente
$auxCliente->setNombre("Ariel") ;
Ya tenemos un cliente, ahora creamos otro de la siguiente manera.
//creamos objeto para nuestro segundo cliente
$auxCliente2 = new Cliente();
//asignamos un nombre a nuestro segundo objeto Cliente
$auxCliente2->setNombre("Pedro") ;
La forma en al creamos nuestro segundo cliente es similar al primero, solo que ahora utilizaremos un nuevo objeto “$auxCliente2”. Recuerda, siempre que quieras obtener un nuevo objeto tienes que utilizar “new Objeto()” en nuestro ejemplo “new Cliente()”.
Paso 3, verificar funcionamiento de la clase:
Una vez asignado el nombre a los dos clientes comprobamos que realmente cada cliente tenga su nombre y que cada cliente es un objeto distinto.
Lo verificamos de la siguiente forma:
//recuperamos el nombre que asignamos mediante el método getNombre echo "El nombre del primer cliente es: ".$auxCliente->getNombre()."<br>"; echo "El nombre del segundo cliente es: ".$auxCliente2->getNombre()."<br>";
El resultado será:
//El nombre del primer cliente es: Ariel //El nombre del segundo cliente es: Pedro
Retomando el asunto relacionado a si debemos usar métodos para controlar las propiedades de nuestra clase o no, debemos recurrir algunas modificaciones en nuestra clase.
Como habrás observado la forma de asignar un valor a la propiedad “mNombre” fue utilizando el método “setNombre” y para recuperar el valor utilizamos el método “getNombre” que no son otra cosas que funciones públicas definidas dentro de la clase.
Existe una forma no siempre recomendada de controlar los atributos sin utilizar métodos, esto es definiendo las propiedades como públicas, para lo cual podemos utilizar “var” o “public” en vez de “private”.
La definición de las propiedades quedaría así:
class Cliente
{
// esto de abajo son los atributos o propiedades de nuestra clase
public $mNombre;
public $mApellido;
public $mDireccion;
public $mPais;
public $mTelefono;
public $mEdad;
public $mFechaNacimiento;
}
Como habrás podido observar nuestra clase ya no tiene los métodos “set” y “get” que se encargaban de las propiedades.
¿Cómo controlamos las propiedades sin los métodos?
Dado que las propiedades se definieron como públicas es posible acceder a ellas desde cualquier parte del código. Es decir, desde dentro de la clase mediante la utilización de “$this” y desde afuera.
Probaremos nuestro segundo ejemplo con las siguientes líneas de código:
require("classes2/Cliente.php");
//creamos objeto para nuestro primer cliente
$auxCliente = new Cliente();
//asignamos un nombre a nuestro objeto Cliente
$auxCliente->mNombre = "Ariel" ;
//creamos objeto para nuestro segundo cliente
$auxCliente2 = new Cliente();
//asignamos un nombre a nuestro segundo objeto Cliente
$auxCliente2->mNombre = "Pedro" ;
//recuperamos el nombre que asignamos mediante el metodo getNombre
echo "El nombre del primer cliente es: ".$auxCliente->mNombre."<br>";
echo "El nombre del segundo cliente es: ".$auxCliente2->mNombre."<br>";
Dado que las propiedades son públicas asignamos un nombre de la misma manera que asignamos un valor a una variable común en PHP.
$auxCliente->mNombre = "Ariel" ;
Lo mismo para recuperar el valor de la propiedad, accedemos directamente así “$auxCliente->mNombre”
Todo muy bien. Ahora, ¿cuál es la mejor forma?
Esto es muy relativo y depende de la aplicación que estés desarrollando. Lo que si es cierto es que si utilizas el método más sencillo te estarías saliendo de los estándares de desarrollo de aplicaciones orientadas a objetos. Existen empresas que son muy rigurosas en estas metodologías y exigen a sus programadores la aplicación de estas reglas para que el código fuente final sea uniforme.
Este tutorial pretende ser lo más profesional posible, por lo tanto mostramos las dos formas. Depende del programador cual usar.
¿Qué otro uso tienen los Métodos?
Los métodos no son solo útiles para manejar las propiedades. De hecho esta es una de las tareas menos importante que realizan los métodos.
Podemos utilizar un método para calcular la edad de la persona basada en la fecha de nacimiento.
Agregamos lo siguiente a nuestra clase:
function setFechaNacimiento($val) //método que asigna una valor a la propiedad Fecha de Nacimiento
{
$this->mFechaNacimiento = $val;
}
function getEdad() //método que retorna el valor asignado a la propiedad edad
{
return $this->mEdad ;
}
function calcularEdad()
{
$fecha_nacimiento = $this->mFechaNacimiento;
list($y, $m, $d) = explode("-", $fecha_nacimiento);
$y_dif = date("Y") - $y;
$m_dif = date("m") - $m;
$d_dif = date("d") - $d;
if ((($d_dif < 0) && ($m_dif == 0)) || ($m_dif < 0))
$y_dif--;
$this->mEdad = $y_dif;
return $y_dif;
}
La función “calcularEdad” tiene el cometido de darnos la edad de un cliente basado en la fecha de nacimiento. Es sin duda un claro ejemplo de cómo podemos utilizar los métodos.
Vamos a probar el método agregando el siguiente código en una página PHP en blanco:
require("classes/Cliente.php");
//creamos objeto para nuestro primer cliente
$auxCliente = new Cliente();
//asignamos un nombre a nuestro objeto Cliente
$auxCliente->setNombre("Ariel") ;
//asignamos fecha de nacimiento
$auxCliente->setFechaNacimiento("1979-11-19") ;
//calculamos edad
$auxCliente->calcularEdad() ;
//recuperamos el nombre que asignamos mediante el metodo getNombre
echo "El Cliente: ".$auxCliente->getNombre().", tiene ".$auxCliente->getEdad()." años<br>";
Con esto último terminamos el capítulo relacionado a Métodos y Propiedades.
Herencia de Clases
Sin duda es una de las características más destacadas en los lenguajes orientados a objetos, y PHP cuenta con esta característica.
Cuando hablamos de herencia nos referimos a métodos y propiedades que se “importan” de otra clase. Como la palabra lo dice, heredamos funciones que ya están hechas.
La herencia nos sirve para ahorrarnos trabajo y reutilizar cosas que ya están hechas.
Por ejemplo: si en nuestra empresa tenemos clientes, proveedores y empleados. Todos tienen cosas en común, todos tienen nombre, apellidos, teléfonos, país etc.
Llevándolo al plano analítico, todos son personas. Por lo tanto, podemos definir una clase “Persona”, la cual contenga todos los atributos y métodos comunes al cliente, proveedor y empleado.
Podemos decir que estas clases heredaran de Persona los atributos en común.
Para comenzar definimos la clase Persona:
class Persona
{
// esto de abajo son los atributos o propiedades de nuestra clase
private $mNombre;
private $mApellido;
private $mDireccion;
private $mPais;
private $mTelefono;
private $mEdad;
private $mFechaNacimiento;
function setNombre($val) //método que asigna una valor a la propiedad nombre
{
$this->mNombre = $val;
}
function getNombre() //método que retorna el valor asignado a la propiedad nombre
{
return $this->mNombre ;
}
}
Y nuestra clase “Cliente” quedara así:
require("Persona.php");
class Cliente extends Persona
{
}
A primera vista parece vacía, sin métodos ni propiedades. Pero, si prestamos atención, vemos la palabra usada para heredar “extends” y a continuación “Persona”. Esto, en otras palabras quiere decir que la clase Cliente hereda todas las propiedades y métodos de Persona.
Para demostrar la utilidad de la herencia utilizaremos otra clase llamada “”Empleado”.
require("Persona.php");
class Empleado extends Persona
{
}
Al heredar nos evitamos tener que definir los métodos y propiedades para cada una de las clases por separado, evitando así el código duplicado y aprovechamos al máximo la reutilización, uno de los principios básicos de esta metodología.
Para probar que Cliente y Empleado heredaron utiliza los ejemplos de la sección anterior.
Constructores y Destructores
Siempre que ejecutamos “$auxCliente = new Cliente();” decimos que construimos el objeto Cliente. Se puede dar el caso que podríamos querer ejecutar determinadas acciones en el mismo momento de creación o construcción del objeto. Para esto usamos el constructor, que no es más que un función que se ejecuta automáticamente.
En PHP5 el constructor se define con “__construct” en versiones anteriores el constructor se define con una función con el mismo nombre de la clase. Por ejemplo en nuestra clase “Cliente” el constructor se definiría de la siguiente manera:
//constructor de la clase
function __construct($val)
{
$this->mFechaNacimiento = $val;
$this->calcularEdad();
}
En el ejemplo utilizamos el constructor para calcular la edad automáticamente después de instanciar el objeto.
//creamos objeto para nuestro primer cliente
$auxCliente = new Cliente("1979-11-19");
echo "Edad del cliente:”.$auxCliente->getEdad()." años<br>";
El destructor de una clase se utiliza para realizar operaciones cuando se destruye el objeto, es decir cuando se elimina de la memoria. Esta funcionalidad es muy utilizada en sistemas de chat. Donde necesitamos actualizar la base de datos ni bien el visitante cierra la página.
Encapsulamiento
Es la capacidad de los objetos de tener otros objetos dentro de sí mismo. Un buen ejemplo podría ser que una empresa tiene clientes. Por lo tanto, un objeto cliente podría estar dentro del objeto empresa.
Creamos nuestra clase “Empresa”
class Empresa
{
private $mCliente;
function agregarCliente($unCliente) //método que agrega el cliente
{
$this->mCliente = $unCliente;
}
function getCliente() //método que retorna el cliente
{
return $this->mCliente ;
}
}
En un archivo de prueba agregamos el siguiente código:
require("classes/Cliente.php");
require("classes/Empresa.php");
$auxEmpresa = new Empresa();
//creamos objeto para nuestro primer cliente
$auxCliente = new Cliente();
//asignamos un nombre a nuestro objeto Cliente
$auxCliente->setNombre("Ariel") ;
//asignamos fecha de nacimiento
$auxCliente->setFechaNacimiento("1979-11-19") ;
//calculamos edad
$auxCliente->calcularEdad() ;
//agregamos el cliente dentro de la empresa
$auxEmpresa->agregarCliente($auxCliente) ;
//recuperamos el nombre que asignamos mediante el metodo getNombre
echo "El Cliente: ".$auxEmpresa->getCliente()->getNombre().", tiene ".$auxEmpresa->getCliente()->getEdad()." años<br>";
El método “agregarCliente” introduce el objeto Cliente dentro del objeto Empresa y “getCliente” nos lo devuelve.
Por lo tanto lo siguiente:
$auxEmpresa->getCliente()->getNombre()
Sería algo así en pseudocódigo: Empresa->Cliente->Nombre.
Saludos para todos y espero que el tutorial les sea útil.
http://programacionya.com/curso-de-programacion-orientada-a-objetos-en-php/#more-113
