La méthode d'accès de PHP5 permet de restreindre l'accès aux membres de la classe. Il s'agit d'une nouvelle fonctionnalité de PHP5, mais elle existe depuis longtemps dans de nombreux langages orientés objet. Avec les méthodes d'accès, vous pouvez développer une application orientée objet fiable et créer une bibliothèque de classes orientée objet réutilisable.
Comme C++ et Java, PHP dispose de trois méthodes d'accès : publique, privée et protégée. La méthode d'accès pour un membre de classe peut en faire partie. Si vous ne spécifiez pas la méthode d'accès, la méthode d'accès par défaut est publique. Les membres statiques spécifient une méthode d'accès. Placez la méthode d'accès avant le mot clé static (par exemple, public static
est accessible sans restrictions. Tout code en dehors de la classe peut lire et écrire des propriétés publiques à partir de). le script. Appelez une méthode publique n’importe où. Dans les versions précédentes de PHP, toutes les méthodes et propriétés étaient publiques, ce qui donnait aux objets l'apparence de tableaux bien structurés.
Les membres privés ne sont visibles qu'à l'intérieur de la classe. Vous ne pouvez pas modifier ou lire la valeur d'une propriété privée en dehors de la méthode de classe où elle réside. De même, seules les méthodes de la même classe peuvent appeler une méthode privée et les sous-classes héritées ne peuvent pas accéder aux membres privés de la classe parent.
Notez que les membres privés sont accessibles par n’importe quel membre de la classe et par les instances de la classe. En regardant l'exemple 6.8, la méthode égal compare deux widgets. L'opérateur == compare deux objets de la même classe, mais dans cet exemple, chaque instance d'objet a un identifiant unique. La méthode égal compare uniquement le nom et le prix. Remarquez comment la méthode equals accède à la propriété privée d'une autre instance de Widget. Java et C le permettent.
Listing 6.8
Widget de classe pour
les membres privés
{
privé $nom ;
prix privé en $ ;
$id privé ;
fonction publique __construct ($ nom, $ prix)
{
$this->nom = $nom;
$this->price = floatval($price);
$this->id = uniqid();
}
// vérifie si deux widgets sont identiques fonction publique égale ($widget)
{
return(($this->name == $widget->name)AND ($this->price == $widget->price));
}
}
$w1 = nouveau widget('Cog', 5.00);
$w2 = nouveau widget('Cog', 5.00);
//TRUE
);
si($w1->est égal($w2))
{
print("w1 et w2 sont identiques n");
}
//FAUX
si($w1->est égal($w3))
{
print("w1 et w3 sont identiques n");
}
//FALSE, == inclut l'identifiant en comparaison
if($w1 == $w2) //pas égal car les identifiants sont différents
{
print("w1 et w2 sont identiques n");
}
?＞
Si vous êtes nouveau dans la programmation orientée objet, vous vous demandez peut-être à quoi sert l'utilisation de membres privés. Vous vous souvenez peut-être des idées d'encapsulation et de couplage, dont nous avons parlé au début de ce chapitre. Les membres privés aident à encapsuler les données. Ils peuvent être masqués dans une classe pour empêcher l'accès au code en dehors de la classe. Ils aident également à obtenir un couplage lâche si le code en dehors de la structure de données ne peut pas accéder directement aux propriétés internes, alors il n'y a pas de corrélation implicite.
Bien entendu, la plupart des propriétés privées peuvent toujours être partagées par du code externe. La solution consiste à utiliser une paire de méthodes publiques, l'une est get (récupère la valeur de la propriété), l'autre est set (définit la valeur de la propriété). Les constructeurs acceptent également les valeurs initiales des propriétés. Cela permet à la communication entre les membres de s'effectuer via une interface étroite et bien qualifiée. Cela offre également la possibilité de modifier les valeurs transmises à la méthode. Notez dans l'exemple 6.8 comment le constructeur force. Faites du prix un nombre flottant (floadval()).
Les membres protégés (protégés) sont accessibles par toutes les méthodes de la même classe et par toutes les méthodes des classes héritées. Les propriétés publiques vont à l'encontre de l'esprit de l'encapsulation car elles permettent aux sous-classes de s'appuyer sur une propriété spécifique pour écrire. Les méthodes protégées ne posent pas ce problème. Une sous-classe utilisant une méthode protégée doit être très consciente de la structure de sa classe parent. .
L'exemple 6.9 est amélioré par rapport à l'exemple 6.8 et inclut une sous-classe Thing de Widget. Notez que Widget a désormais une méthode protégée appelée getName. Si une instance de Widget tente d'appeler la méthode protégée, une erreur se produira : $w1->getName() génère une erreur, mais la méthode getName de la sous-classe Thing peut appeler cette méthode protégée. Bien sûr, cet exemple est trop simple pour prouver que la méthode Widget::getName est protégée. Dans les situations réelles, l'utilisation de la méthode protégée dépend de la compréhension de la structure interne de l'objet.
Listing 6.9
Widget de classe
de membres protégés
{
privé $nom ;
prix privé en $ ;
$id privé ;
fonction publique __construct ($ nom, $ prix)
{
$this->nom = $nom;
$this->price = floatval($price);
$this->id = uniqid();
}
// vérifie si deux widgets sont identiques
la fonction publique est égale ($ widget)
{
return(($this->name == $widget->name)AND($this->price == $widget->price));
}
fonction protégée getName()
{
return($this->nom);
}
}
classe Thing étend le widget
{
privé $color ;
fonction publique setColor($color)
{
$this->color = $color;
}
fonction publique getColor()
{
return($this->color);
}
fonction publique getName()
{
return(parent::getName());
}
}
$w1 = nouveau widget('Cog', 5.00);
$w2 = nouvelle chose('Cog', 5,00);
$w2->setColor('Yellow');
//TRUE (encore !) Le résultat est toujours vrai
si($w1->est égal($w2))
{
print("w1 et w2 sont identiques n");
}
//imprimer la sortie Cog Cog
print($w2->getName());
?>
Une sous-classe peut modifier la méthode d'accès à la méthode en remplaçant la méthode de la classe parent. Cependant, il existe encore certaines restrictions. Si vous remplacez un membre de classe public, il doit rester public dans ses sous-classes. Si vous remplacez un membre protégé, il peut rester protégé ou devenir public. Les membres privés sont toujours visibles uniquement dans la classe actuelle. Déclarer un membre portant le même nom qu'un membre privé de la classe parent créera simplement un membre différent dans la classe actuelle. Par conséquent, techniquement, vous ne pouvez pas remplacer un membre privé.
Le mot-clé Final est un autre moyen de restreindre l'accès aux méthodes membres. Les sous-classes ne peuvent pas remplacer les méthodes marquées comme final dans la classe parent et le mot-clé Final ne peut pas être utilisé pour les attributs.