Métodos de acceso y permisos de los miembros de la clase PHP.

Los métodos de acceso de PHP5 le permiten restringir el acceso a los miembros de la clase. Esta es una característica nueva en PHP5, pero ya existe en muchos lenguajes orientados a objetos. Con los métodos de acceso, puede desarrollar una aplicación orientada a objetos confiable y construir objetos reutilizables. Biblioteca de clases orientada

a C++ y Java, PHP tiene tres métodos de acceso: público, privado y protegido. Para el método de acceso de un miembro de la clase, puede ser uno de ellos. Si no especifica el método de acceso, el acceso es el predeterminado. El método es público. También puede especificar un método de acceso para miembros estáticos colocando el método de acceso antes de la palabra clave estática (como

se puede acceder a miembros públicos estáticos sin restricciones

Puedes llamar a un método público desde cualquier lugar de tu script. En versiones anteriores de PHP, todos los métodos y propiedades eran públicos, lo que hacía que los objetos parecieran matrices bien estructuradas.

Visible sólo dentro de la clase.

la

clase principal.

la clase puede acceder a miembros privados. Consulte el ejemplo 6.8. El método igual compara dos widgets. El operador == compara dos widgets de la misma clase Objeto, pero en este ejemplo cada instancia de objeto tiene una ID única. y precio. Observe cómo el método igual accede a la propiedad privada de otra instancia de widget. Tanto Java como C permiten esta operación

.
widget de clase
{
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 Comprueba si dos widgets son iguales
función pública es igual ($widget)
{
return(($this->nombre == $widget->nombre)Y
($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 igualesn");
}

//FALSO
si($w1->es igual($w3))
{
print("w1 y w3 son igualesn");
}

//FALSE, == incluye id en comparación
if($w1 == $w2) //no es igual porque los ID son diferentes
{
print("w1 y w2 son igualesn");
}
?>

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 datos.

un

acoplamiento flexible. Si el código fuera de la estructura de datos no puede acceder directamente a las propiedades internas, entonces no habrá una relación implícita.

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). valor inicial. Esto permite que la comunicación entre los miembros se produzca a través de una interfaz estrecha y bien calificada. Esto también brinda la oportunidad de cambiar el valor pasado al método. Observe en el Ejemplo 6.8 cómo el constructor fuerza que el precio sea un número flotante (floadval(). )).

Se puede acceder a los miembros protegidos mediante todos los métodos de la misma clase y en las clases heredadas. Las propiedades públicas violan el espíritu de encapsulación porque permiten que las subclases dependan de Escribir un atributo específico en el método protegido no genera esta preocupación. El uso del método protegido debe tener clara la estructura de su clase principal.

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, para demostrar que el método Widget :: getName está protegido, este ejemplo parece demasiado simple. En situaciones reales, el uso de métodos protegidos depende de. comprender la estructura interna del objeto.

<?php
widget de clase
{
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)Y
($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 igualesn");
}

//imprime la salida del Cog
print($w2->getName());
?>

Una subclase puede cambiar la forma en que se accede al método anulando el método de la clase principal. Sin embargo, todavía existen algunas restricciones. Si anula un miembro de la clase pública, debe permanecer público en la subclase. miembro, puede permanecer protegido o volverse público. Los miembros privados todavía son visibles solo 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. no puede anular un miembro privado.

La palabra clave Final es otra forma de restringir el acceso a los métodos de los miembros. Una subclase no puede anular un método marcado como final en una clase principal.