PHP: Objetos III (Encapsulamiento)

Hola, en el siguiente post abordaremos lo que es el Encapsulamiento en php. Aunque este lenguaje de programación no es muy estricto en cuanto a POO, se pueden emular la mayoría de cosas que son necesarias en Objetos, en este caso Encapsulamiento. Para comenzar es bueno tener en cuenta la ocultación de información(encapsulamiento). Muchos dicen que PHP rompe el encapsulamiento debido a que nos permite acceder a cualquier atributo de una clase directamente, pero en si hay una forma de hacer que no se pueda y así generar el encapsulamiento. Para ello tenemos el concepto de visibilidad en php.

El concepto de visibilidad nos dice que hay tres palabras claves/reservadas: public, protected y private que anteponiendolas a cualquier método o atributo/propiedad se podrán modificar o implementar su visibilidad, haciendo posible el encapsulamiento.

Public: Se podrá acceder a ella de cualquier forma, directamente o por métodos de la misma o de otras clases. Ejemplo:

 1 class Persona{
 2     public $nombre;
 3     public $apellido;
 4     public $edad; // Es public por lo que se accede desde 
 5     cualquier parte
 6     public function __construct($nom, $ape, $e){
 7          $this->nombre = $nom;
 8          $this->apellido= $ape;
 9          $this->edad = $e;
10     }
11     public function imprimir(){
12         return $this->edad;
13     }
14 }
15 $persona = new Persona('Pepito','Perez',24);
16  echo $persona->edad;
17  echo $persona->imprimir();

Como vemos es la misma clase persona que se viene trabajando. Creamos el objeto y hacemos echo a la edad directamente, lo que nos imprimira un 24, despues por medio del metodo imprimir() tambien nos pondra en pantalla el mismo dato, teniendo en cuenta el return en la linea 12.

Protected: Si cambiamos el public por el protected y dejamos lo demas igual, nos saldra un fatal error, ya que con protected no nos dejara acceder a la propiedad a menos que sea por métodos de la misma clase, herencia o con el parent.

 1 class Persona{
 2     public $nombre;
 3     public $apellido;
 4     protected $edad; 
 5     public function __construct($nom, $ape, $e){
 6           $this->nombre = $nom;
 7           $this->apellido= $ape;
 8           $this->edad = $e;
 9     }
10     public function imprimir(){
11         return $this->edad;
12     }
13 }
14 $persona = new Persona('Pepito','Perez',24);
15 echo $persona->edad;
16 echo $persona->imprimir();

Si comentamos la linea donde imprimimos directamente la propiedad, nos imprimira el resultado del metodo imprimir().

 1 //echo $persona->edad;
 2 echo $persona->imprimir();

Private: Al poner la propiedad edad en private solo nos dejara acceder desde la misma clase, entonces si hacemos el ejercicio anterior

 1 class Persona{
 2     public $nombre;
 3     public $apellido;
 4     private $edad; 
 5     public function __construct($nom, $ape, $e){
 6           $this->nombre = $nom;
 7           $this->apellido= $ape;
 8           $this->edad = $e;
 9     }
10     public function imprimir(){
11         return $this->edad;
12     }
13 }
14 class trabajo extends Persona{
15     public $trabajos;
16     public $pruebas;
17     public function trabajar($job){
18         $this->trabajos = $job;
19     }
20     public function imprimir(){
21         return 'Mi nombre es '.$this->nombre.' '.$this->
           apellido.' y tengo '.$this->edad.' Años y trabajo 
           en  '.$this->trabajos;
22     }  
23  }
24 $persona = new Persona('Pepito','Perez',24);
25 echo $persona->imprimir();

Si corremos php con el siguiente código, no nos dejara acceder a la propiedad edad de la clase Persona desde trabajo porque es privada, si fuera protected si nos dejaria pero solo por metodos o parent.

Esto es encapsulamiento en PHP.

PHP: Objetos

Hola, ahora vamos a ver como php trabaja con objetos, este manual es muy basico, vamos a crear lo que es una clase junto con sus metodos, definiremos un metodo contructor, iremos dandole forma a lo que son los conceptos de la programacion orientada a objetos explicando despues como crear una conexion a base de datos con mysql.

Creamos un archivo php con el nombre que quieran, ahora el ejercicio es simple, vamos a hacer una clase llamada persona que tendra ciertos atributos y a su vez metodos. Creamos la clase persona:

01 class Persona{
02 
03 }

Como vemos en el anterior codigo, una clase se define por la palabra reservada class, seguido del nombre que se quiera dar, se crean las llaves que encerraran las intrucciones para esta clase. Cabe decir que esto es una clase normal, no estamos hablando de clases abstractas ni interfaces, es una clase normalita.

Vamos a crear atributos, que no son mas que variables predefinidas que utilizaremos en los metodos, en este caso crearemos los atributos: nombre, apellido, edad y nuestra clase quedara asi:

01 class Persona{
02  private $nombre;
03  private $apellido;
04  private $edad;
05 }

Hay que resaltar que segun la programacion orientada a objetos, los atributos tienen que ser private, bueno en realidad no tienen, pero es mucho mejor que sean de este tipo, si queremos cambiarlos de valor o asiganerles uno simplemente lo haremos por medio de un metodo publico(public). Ahora vamos a crear el constructor, que en si es el metodo con el cual podemos inicializar nuestra clase a la hora de instanciarla. Vamos a utilizar constructor para que en un futuro podamos hacer el ejemplo de polimorfismo.

01 class Persona{
02  private $nombre;
03  private $apellido;
04  private $edad;
05 
06  public function __construct($nom, $ape, $e){
07       $this->nombre = $nom;
08       $this->apellido= $ape;
09       $this->edad = $e;
10  } 
11 }

Ahora explicaremos las lineas donde se creo el metodo o como pueden ver una funcion publica con un nombre prederminado. PHP utiliza el nombre __construct para indicarle a la clase que se inicializa por este metodo, no es necesario crear un constructor o al menos definirlo, ya que en muchos lenguajes el contructor se llama como la misma clase, pero es mejor comenzar a utilizarlos, este constructor nos dice que va a recibir tres parametros que son $nom, $ape y $e. Dentro de la funcion esta una serie de asiganciones, estas asignaciones lo que estan diciendo es que lo que contenga  $nom, lo asignamos al atributo previamente definido, esto para controlar los datos que ingresan, las asignaciones a atributos se hacen siempre con la variable $this seguida de guion(-) y el signo mayor que(>) dejando por ultimo el nombre del atributo sin el signo $. Esto se hace para poder trabajar dentro de otros metodos ya que tenemos los datos asignados en el objeto en sus atributos propios. Ahora ya que tenemos los tres datos, vamos a hacer algo con ellos y es imprimirlos.

01 class Persona{
02  private $nombre;
03  private $apellido;
04  private $edad;
05 
06  public function __construct($nom, $ape, $e){
07   $this->nombre = $nom;
08   $this->apellido= $ape;
09   $this->edad = $e;
10  } 
11 }

En las lineas anteriores vemos como escribimos un nuevo metodo llamado imprimir, este es publico, pero a diferencia del constructor, no recibe datos en cambio hace un return para que nos retorne una respuesta de una cadena o string de datos que llevan consigo los atributos definidos y asignados anteriormente. Ya tenemos nuestra clase persona, pero ahora necesitamos crear el objeto, es decir instanciar la clase y crear el objeto. Para ello hacemos lo siguiente, puede ser despues del cierre de la clase, es solo una prueba.

01 class Persona{
02     private $nombre;
03     private $apellido;
04     private $edad;
05    
06  public function __construct($nom, $ape, $e){
07     $this->nombre = $nom;
08     $this->apellido= $ape;
09     $this->edad = $e;
10  }
11  public function imprimir(){
12     return 'Mi nombre es '.$this->nombre.' '.$this->apellido.' y tengo '.$this->edad.' Años'
13     $this->edad.' Años';
14  }
15 }
16 $persona1 = new Persona('Fulanito', 'de tal', '24');
17 echo $presona1->imprimir();

En las lineas nuevas creadas despues de nuestra clase, estamos instanciando la clase para crear un objeto, es decir creamos un objeto de tipo persona, este se creó debido a la instruccion new de PHP  seguido del nombre de la clase. Ahora vamos a ver la funcion del constructor, como tenemos un metodo constructor, podemos de una vez enviar ciertos datos a la clase, sin necesidad de despues llamar el metodo por separado, asi que simplemente como el contructor recibe 3 atributos, esos mismos le enviamos. Con esto, ya en la variable $persona1 se crea el objeto, por lo que podemos acceder a los metodos de la clase Persona, para ello llamamos los metodos de la sigueinte manera $persona->imprimir(), es decir, el nombre del objeto que se creo al instanciar la clase seguido de guion(-) y mayor que(>), y despues viene el nombre del metodo en nuestro caso imprimir(). Le anteponemos a todos un echo, para que imprima lo que retorne este metodo y listo. Para el siguiente post, sabiendo algo ya de POO, haremos la conexion a la base de datos y en otro explicaremos con mas detalle mas tecnicas, como lo son la herencia, encapsulamiento, polimorfismo y mucho mas.