PHP orientado a objetos 1: encapsulación

Introducción a la POO en PHP (I). En esta entrada veremos qué son los métodos y propiedades de una clase.

hiroshige

archivado en: PHP/AJAX / 12 noviembre, 2012 / taller:

En esta entrada vamos a empezar a conocer cómo funciona la programación orientada a objetos en PHP,  una manera de desarrollar en este lenguaje de forma mucho más ordenada y eficaz, pero antes es importante que hablemos de Platón. En La República, este filósofo griego planteó la teoría de las ideas, que viene a decir que los objetos del mundo material no son sino copias imperfectas del modelos ideales que sí son perfectos. Por ejemplo, en la idea de dinosaurio, en la dinosauriez, está comprendido todo lo que puede ser un dinosaurio: un bicho que come, se reproduce, pone huevos, es muy grande, tiene un color... Luego están, o estaban, cada uno de los dinosaurios en concreto, con sus características particulares. Unos tienen cuernos, otros escamas, otros plumas, algunos son verdes, otros grises, unos muy grandes, otros más pequeños...

Las clases son lo mismo que las ideas platónicas, entidades que reúnen todas las propiedades y métodos que pueden tener los objetos concretos. Por ejemplo, en la clase dinosaurio podrían estar definidas las propiedades de color, peso, altura y los métodos de correr, comer, reproducirse... o si eso de atributos y métodos nos lía, podemos hablar de variables (y constantes) y funciones, que para el caso es lo mismo.

Dicho de otra forma, una clase es un conjunto de funciones, llamadas métodos, y de variables, denominadas propiedades, que se puede «invocar» desde cualquier parte del código... como una superfunción, para aclararnos.

Esto se entiende mejor si empezamos a ver un poco de sintaxis.

Declaración de clase

Para declarar una clase se utiliza la expresión class:

  • class dinosaurios {
  • // aquí una montonera de funciones (métodos) y variables (propiedades).
  • }

Y para acceder a sus propiedades es necesario «invocarla» creando una instancia, una copia de la original, mediante la palabra clave new.

  • $triceratops = new dinosaurio();

Esta copia de la clase, que tendrá a partir de ahora sus propias características, se denomina objeto. En el caso anterior hemos declarado un nuevo objeto llamado $triceratops, pero si necesitamos más bichos grandes y voraces en nuestro script podemos declarar nuevos objetos de la clase dinosaurio.

  • $triceratops = new dinosaurio();
  • $velocirraptor = new dinosaurio();

Aunque $triceratops y $velocirraptor son de la misma clase (dinosaurio), cada uno es distinto y ya veremos para qué sirve esto  🙂

Acceder a los métodos (->)

Los objetos pueden usar los métodos de su clase, sus funciones, mediante el operador ->.  Por ejemplo, vamos a añadir una función a la clase dinosaurios que devuelva la cadena de texto "soy un dinosaurio":

  • class dinosaurios {
  • function cadena_de_texto_dinosaurio () {
  • return "soy un dinosaurio";
  • }
  • }

Y ahora accedemos a esa función mediante el operador ->

  • $triceratops = new dinosaurios ();
  • echo "¿Qué es $triceratops?";
  • echo $triceratops-> cadena_de_texto_dinosaurio ();
  • ?>

Un script formidable que daría como resultado en pantalla:

¿Qué es $triceratops? soy un dinosaurio

Acceder a las propiedades

Las clases pueden incluir variables, que reciben el nombre de propiedades o atributos, y para declararlas antes era obligatorio anteponer la palabra reservada $var, aunque ya no es necesario.

Al igual que sucede con los métodos, las propiedades pueden ser:

  • Públicas (public): Los elementos son accesibles desde dentro y desde fuera de la clase.
  • Protegidas (protected): Los elementos son accesibles desde la misma clase y en sus subclases.
  • Privadas (private): Los elementos solo son accesibles dentro de la clase.

Por integridad de la aplicación, en general, lo más recomendable es declararlas como protegidas o privadas. Esto es lo que se conoce en la programación orientada a objetos como encapsulamiento: se aíslan determinados métodos y propiedades para que solo funcionen dentro de la clase, de tal manera que no puedan ser alterados de forma accidental en alguna parte del código.

Seguimos, para referirse a las propiedades que están dentro de la clase es necesario emplear la pseudovariable $this:

  • $this->variable

Por ejemplo, esto daría error:

  • class dinosaurios {
  • protected $nombre ="triceratops";
  • function nombre_dinosaurio () {
  • return $nombre; // se vuelve idiota: Undefined variable
  • }
  • }

Pero esto devolvería "triceratops":

  • class dinosaurios {
  • protected $nombre ="triceratops";
  • function nombre_dinosaurio () {
  • return $this->nombre;
  • }
  • }

El método __construct()

Las clases suelen seguir esta estructura:
  1. Primero se declaran las propiedades
  2. Luego la función constructora
  3. Las funciones que trabajan algo
  4. Las que devuelven algo

La función constructora sirve para inicializar el objeto que se ha creado y con PHP5 se declara escribiendo dos guiones bajos seguidos de la palabra construct

__construct()

Antes, en vez de __construct(), se denominaba a la función de la misma forma que la clase.

Bueno, ya volveremos sobre este método y su opuesto (__destruct()), ahora veamos un ejemplo pequeño que recoge todo lo expuesto hasta aquí: una microaplicación para calcular cuánto dinero hay que quitar de IRPF en una factura.

El código es sencillo, con la función constructora recogemos los parámetros que se declaran al inicializar la clase, es decir, al crear un nuevo objeto. Estos dos parámetros son el dinero total de la factura (bruto) y el IRPF a descontar.

Una vez inicializado el objeto (líneas 6 a 9), calculamos el tanto por ciento y devolvemos la miseria resultante.

  1. class Facturometro {
  2. private $irpf; // La cantidad a descontar
  3. private $bruto; // El total a pagar
  4. private $limpio; // La miseria que te queda
  5. // Recogemos los datos inicializando el nuevo objeto
  6. public function __construct ($rec_irpf, $rec_bruto) {
  7. $this->irpf = $rec_irpf;
  8. $this->bruto = $rec_bruto;
  9. }
  10. // Procesamos y devolvemos los datos
  11. public function devuelve_factura () {
  12. $irpf_a_descontar = ($this->bruto*$this->irpf)/100;
  13. $this->limpio = $this->bruto-$irpf_a_descontar;
  14. return $this->limpio;
  15. }
  16. }
  17. //Creamos el objeto $nueva_factura enviándole el IRPF y la cantidad bruta
  18. $nueva_factura = new Facturometro (21, 1000);
  19. // Llamamos al método devuelve_factura
  20. echo $nueva_factura ->devuelve_factura ();

Otro día seguimos, de momento vamos a dejarlo aquí.

Abrazos++;

|| Tags: ,

valoración de los lectores sobre PHP orientado a objetos 1: encapsulación

  • estrellica valoración positiva
  • estrellica valoración positiva
  • estrellica valoración positiva
  • estrellica valoración positiva
  • estrellica valoración positiva
  • 4.8 sobre 5 (38 votos)

¿Te ha parecido útil o interesante esta entrada?
dormido, valoración 1 nadapensativo, valoración 2 un poco sonrisa, valoración 3 a medias guiño, valoración 4 bastante aplauso, valoración 5 mucho

Tú opinión es muy importante, gracias por compartirla!

2 respuestas a “PHP orientado a objetos 1: encapsulación

  1. Hola. Muy bueno el blog, me gustan estas explicaciones claras.
    Tengo una pregunta que es que convención de mayúsculas/minúsculas usar con los nombres de clases, archivos y métodos.
    Muchas gracias

  2. Hola Fabio, las clases en mayúsculas, lo demás en minúsculas y con guiones bajos si quieres separar palabras.