El método de acceso de PHP5 permite restringir el acceso a los miembros de la clase. Esta es una característica nueva en PHP5, pero existe desde hace mucho tiempo en muchos lenguajes orientados a objetos. Con los métodos de acceso, puede desarrollar una aplicación orientada a objetos confiable y crear una biblioteca de clases orientada a objetos reutilizable.
Al igual que C++ y Java, PHP tiene tres métodos de acceso: público, privado y protegido. El método de acceso para un miembro de la clase puede ser uno de ellos. Si no especifica el método de acceso, el método de acceso predeterminado también puede proporcionarlo. Los miembros estáticos especifican un método de acceso. Coloque el método de acceso antes de la palabra clave estática (como
se puede acceder a los miembros públicos sin restricciones). Cualquier código fuera de la clase puede leer y escribir propiedades públicas. el script. Llame a un método público en cualquier lugar. En versiones anteriores de PHP, todos los métodos y propiedades eran públicos, lo que hacía que los objetos parecieran matrices muy bien estructuradas.
Los miembros privados sólo son visibles dentro de la clase. No puede cambiar ni leer el valor de una propiedad privada fuera del método de clase donde reside. De manera similar, solo los métodos de la misma clase pueden llamar a un método privado y las subclases heredadas no pueden acceder a miembros privados en la clase principal.
Tenga en cuenta que cualquier miembro de la clase y las instancias de la clase pueden acceder a los miembros privados. Mirando el ejemplo 6.8, el método igual compara dos widgets. El operador == compara dos objetos de la misma clase, pero en este ejemplo cada instancia de objeto tiene una ID única. El método igual solo compara el nombre y el precio. Observe cómo el método igual accede a la propiedad privada de otra instancia de widget. Tanto Java como C lo permiten.
Listado 6.8
Widget de clase
de miembros privados
{
nombre $ privado;
precio privado $;
privado $id;
función pública __construct($nombre, $precio)
{
$this->nombre = $nombre;
$this->precio = floatval($precio);
$this->id = uniqid();
}
//comprueba si dos widgets son iguales función pública igual($widget)
{
return(($this->nombre == $widget->nombre)AND ($this->precio == $widget->precio));
}
}
$w1 = nuevo widget('Cog', 5.00);
$w2 = nuevo widget('Cog', 5.00);
$w3 = nuevo widget('Engranaje', 7.00);
//VERDADERO;
si($w1->es igual($w2))
{
print("w1 y w2 son iguales n");
}
//FALSO
si($w1->es igual($w3))
{
print("w1 y w3 son iguales n");
}
//FALSE, == incluye id en comparación
if($w1 == $w2) //no es igual porque los ID son diferentes
{
print("w1 y w2 son iguales n");
}
?＞
Si es nuevo en la programación orientada a objetos, es posible que se pregunte cuál es el propósito de utilizar miembros privados. Quizás recuerde las ideas de encapsulación y acoplamiento, que analizamos al principio de este capítulo. Los miembros privados ayudan a encapsular los datos. Se pueden ocultar dentro de una clase para que no puedan acceder a ellos mediante código externo a la clase. También ayudan a lograr un acoplamiento flexible. Si el código externo a la estructura de datos no puede acceder directamente a las propiedades internas, entonces no existe una correlación implícita.
Por supuesto, la mayoría de las propiedades privadas aún se pueden compartir mediante código externo. La solución es utilizar un par de métodos públicos, uno es obtener (obtener el valor de la propiedad) y el otro es establecer (establecer el valor de la propiedad). Los constructores también aceptan valores iniciales para las propiedades. Esto permite que la comunicación entre miembros se produzca a través de una interfaz estrecha y bien calificada. Esto también brinda la oportunidad de cambiar los valores pasados al método. Observe en el Ejemplo 6.8 cómo coacciona el constructor. Haga que el precio sea un número flotante (floadval()).
Todos los métodos de la misma clase y todos los métodos de las clases heredadas pueden acceder a los miembros protegidos (protegidos). Las propiedades públicas van en contra del espíritu de encapsulación porque permiten que las subclases dependan de una propiedad específica para escribir. Los métodos protegidos no generan esta preocupación. Una subclase que utiliza un método protegido necesita ser muy consciente de la estructura de su clase principal. .
El ejemplo 6.9 es una mejora del ejemplo 6.8 e incluye una subclase Thing de Widget. Tenga en cuenta que Widget ahora tiene un método protegido llamado getName. Si una instancia de Widget intenta llamar al método protegido, se producirá un error: $w1->getName() genera un error, pero el método getName en la subclase Thing puede llamar a este método protegido. Por supuesto, este ejemplo es demasiado simple para demostrar que el método Widget :: getName está protegido. En situaciones reales, el uso del método protegido depende de la comprensión de la estructura interna del objeto.
Listado 6.9
Widget de clase
de miembros protegidos
{
nombre $ privado;
precio privado $;
privado $id;
función pública __construct($nombre, $precio)
{
$this->nombre = $nombre;
$this->precio = floatval($precio);
$this->id = uniqid();
}
//comprueba si dos widgets son iguales
función pública es igual ($widget)
{
return(($this->nombre == $widget->nombre)AND($this->precio == $widget->precio));
}
función protegida getName()
{
return($este->nombre);
}
}
clase La cosa extiende el widget
{
privado $color;
función pública setColor($color)
{
$this->color = $color;
}
función pública getColor()
{
return($este->color);
}
función pública getName()
{
return(padre::getName());
}
}
$w1 = nuevo widget('Cog', 5.00);
$w2 = cosa nueva('Cog', 5.00);
$w2->setColor('Yellow');
//TRUE (¡aún!) El resultado sigue siendo verdadero
si($w1->es igual($w2))
{
print("w1 y w2 son iguales n");
}
//imprime la salida del Cog
print($w2->getName());
?>
Una subclase puede cambiar el método de acceso al método anulando el método de la clase principal. Sin embargo, todavía existen algunas restricciones. Si anula un miembro de una clase pública, debe permanecer público en sus subclases. Si anula un miembro protegido, puede permanecer protegido o volverse público. Los miembros privados seguirán siendo visibles sólo en la clase actual. Declarar un miembro con el mismo nombre que un miembro privado de la clase principal simplemente creará un miembro diferente en la clase actual. Por lo tanto, técnicamente no se puede anular un miembro privado.
La palabra clave Final es otra forma de restringir el acceso a los métodos de los miembros. Las subclases no pueden anular los métodos marcados como finales en la clase principal y la palabra clave Final no se puede utilizar para los atributos.