Es un principio por el cual, toda persona que use una clase (mediante la instanciación) no va a tener la oportunidad de cambiar los atributos de la clase. Esto significa, por tanto, que las propiedades de la misma estarán ocultas. Cuando un programador no puede cambiar directamente un atributo de una clase se dice que se cumple la encapsulación que se requiere en la Programación Orientada a Objeto.
¿Cómo se consigue encapsular una clase?
A través de las opciones de visibilidad de atributos y métodos. Para que se pueda cumplir el principio que estudiamos, los atributos tendrán la visibilidad privada (private). Es importante entender que se habla del cambio directo de los atributos porque el acceso y el deseo de quien programa una clase se manifiesta a través de los métodos que sí que serán públicos. Por tanto, el acceso a un atributo se hará a través de los métodos que tendrán que estar previstos y habilitados.
Ejemplo:
Se crea una clase llamada Animal. Esta clase tiene dos propiedades: color y peso; seis métodos: modificar el color, leer el color, modificar el peso, leer el peso, moverse y comer. Esta clase se guarda en un fichero dentro de un subdirectorio llamado ‘class’ y con el nombre Animal.Encapsulacion.class.php
<?php
//Creación de la clase
class Animal {
//Declaración de atributos
private $tipo;
private $color = "gris"; //valor por defecto
private $peso = 10; //valor por defecto
//Declaración de métodos
public function comer () {
//método posible para acceder a las propiedades
//color y peso
if ($this->peso > 8) {
echo "Este $this->tipo con color $this->color y peso $this->peso kilos, debe comer Pienso<br>";
}else {
echo "Este $this->tipo con color $this->color y peso $this->peso kilos, debe comer sano<br>";
}
}
public function moverse () {
//método posible para acceder a las propiedades
//color y peso
if ($this->peso > 8) {
echo "Este $this->tipo con color $this->color y peso $this->peso kilos, debe moverse diariamente<br>";
}else {
echo "Este $this->tipo con color $this->color y peso $this->peso kilos, debe moverse moderadamente<br>";
}
}
public function leerColor () {
echo "El color es: $this->color <br>";
}
public function modificarColor($valor_color) {
$this->color = $valor_color;
echo "Cambiamos el color a $this->color <br>";
}
public function leerPeso () {
echo "El peso es: $this->peso Kilos <br>";
}
public function modificarPeso ($valor_peso) {
$this->peso = $valor_peso;
echo "Cambiamos el peso a $this->peso Kilos<br>";
}
public function __construct ($tipo_animal) {
$this->tipo = $tipo_animal;
echo "Se instancia el objeto tipo $this->tipo<br>";
}
public function __destruct () {
echo "Se destruye el objeto tipo $this->tipo<br>";
}
}
?>
En este ejemplo podemos observar que directamente no es posible modificar los atributos de la clase, toda modificación que se quiera hacer será a través de los métodos públicos que el propietario de la clase habrá previsto para su uso a través de la instanciación del objeto. Precisamente la visibilidad privada (private) de $color y $peso manifiesta que se está cumpliendo el principio de encapsulación y toda posibilidad de acceso a estos atributos es a través de métodos públicos habilitados en la clase.
Para el uso de esta clase, se programa el siguiente fichero que denominamos uso.Encapsulacion.php. Incluye los siguientes scripts.
<?php
include ('class/Cabecera.class.php');
$cabecera = new Cabecera ("https://altruistas.org/la-encapsulacion-en-la-programacion-orientada-a-objeto-poo/");
?>
Este script corresponde a una cabecera general que hace volver a la página de este post. Puede omitirse en cuanto al entendimiento del concepto de encapsulación.
<?php
include ('class/Animal.Encapsulacion.class.php');
?>
Incluimos la clase desarrollada al fichero de uso mediante la instrucción include.
<?php
$perro = new Animal ("Perro"); //pasamos tipo de animal al constructor
print_r ($perro); //vemos la estructura del objeto
echo"<br>"; //salto de línea
$perro->leerColor();
$perro->modificarColor ("Blanco y Marrón"); //modificamos el color
$perro->leerColor();
$perro->leerPeso ();
$perro->modificarPeso(12); // modificamos el peso
$perro->leerPeso ();
$perro->comer();
$perro->moverse();
print_r ($perro); //vemos la estructura del objeto
echo"<br>";
unset ($perro); //destructor del objeto
echo"<hr>"; //pinta una línea horizontal
?>
Instanciamos el objeto $perro a la clase Animal. Pasamos al constructor el tipo de animal: «Perro»
<?php
$gato = new Animal ("Gato"); //pasamos tipo de animal al constructor
print_r ($gato); //vemos la estructura del objeto
echo"<br>"; //salto de línea
$gato->leerColor();
$gato->modificarColor ("Negro y Blanco"); //modificamos el color
$gato->leerColor();
$gato->leerPeso ();
$gato->modificarPeso(5); // modificamos el peso
$gato->leerPeso ();
$gato->comer();
$gato->moverse();
print_r ($gato); //vemos la estructura del objeto
echo"<br>";
unset ($gato); //destructor del objeto
echo"<hr>"; //pinta una línea horizontal
?>
Nueva instanciación a la clase Animal del objeto $gato. Mediante estos dos últimos script lo que hacemos es llamar a los métodos de la clase para particularizar los objetos instanciados. La utilización de la función print_r únicamente nos permite conocer el contenido de los atributos de los objetos en el instante en que son ejecutados. Su utilización puede servir cuando tratamos de depurar el programa ya que el uso de print_r y var_dump son utilizados en entes sentido.
Ejecución y verificación del ejemplo con todos los script unidos en el mismo fichero, aquí
