Les objets de PHP5 ont été ajustés de manière plus systématique et complète, et leur apparence actuelle peut ressembler quelque peu à celle de Java. Cette section se concentre sur le nouveau mode objet de PHP5 et donne quelques exemples plus simples à illustrer. Laissez cette section être un nouveau point de départ pour votre voyage PHP5. :)
* Constructeur et destructeur
* Référence d'objet
*Clone d'objet
* Modes privé, public et protégé dans les objets
*Interfaces
* Classe abstraite
* __appel
* __set et __get
* Membres statiques
Constructeur et destructeur
En PHP4, lorsqu'une fonction porte le même nom qu'un objet, cette fonction deviendra le constructeur de l'objet, et il n'y a pas de notion de destructeur en PHP4.
En PHP5, le constructeur est uniformément nommé __construct, et le concept de destructeur est introduit, qui est uniformément nommé __destruct.
Exemple 1 : Constructeur et destructeur
classe foo {
var $x;
fonction __construct($x) {
$this->x = $x;
}
fonction affichage() {
print($this->x);
}
fonction __destruct() {
print("au revoir");
}
}
$o1 = nouveau foo(4);
$o1->affichage();
?>
Dans l'exemple ci-dessus, lorsque vous terminez l'appel à la classe foo, son destructeur sera appelé et "bye bye" sera affiché dans l'exemple ci-dessus.
les références d'objet
, en PHP4, passer une variable à une fonction ou une méthode crée en fait une copie de la variable, ce qui signifie que ce que vous transmettez à la fonction ou à la méthode est une copie de la variable, sauf si vous utilisez une référence. . Le symbole "&" est utilisé pour déclarer qu'une référence doit être faite et non une copie. En PHP5, les objets existent toujours sous forme de références, et les opérations d'affectation dans les objets sont également des opérations de référence.
Exemple 2 : référence d'objet
classe foo {
var $x;
fonction setX($x) {
$this->x = $x;
}
fonction getX() {
retourner $this->x;
}
}
$o1 = nouveau foto ;
$o1->setX(4);
$o2 = $o1 ;
$o1->setX(5);
if($o1->getX() == $o2->getX()) print("Oh mon dieu !");
?>
Cloner un objet
Comme mentionné ci-dessus, lorsqu'un objet est toujours appelé sous forme de référence, que dois-je faire si je souhaite obtenir une copie de l'objet ? PHP5 fournit une nouvelle fonction, qui est le clonage d'objets, et la syntaxe est __clone.
Exemple 3 : Clonage d'objets
classe foo {
var $x;
fonction setX($x) {
$this->x = $x;
}
fonction getX() {
retourner $this->x;
}
}
$o1 = nouveau foto ;
$o1->setX(4);
$o2 = $o1->__clone();
$o1->setX(5); if($o1->getX() != $o2->getX()) print（"Les copies sont indépendantes"）;
?>
Les méthodes de clonage d'objets existent dans de nombreux autres langages d'application, vous n'avez donc pas à vous soucier de leur stabilité. :)
Modes privé, public et protégé dans les objets
En PHP4, toutes les méthodes et variables d'un objet sont publiques, ce qui signifie que vous pouvez utiliser n'importe quelle variable et méthode en dehors d'un objet. PHP5 introduit trois nouveaux modes pour contrôler cette autorisation d'accès : Public, Protégé et Privé.
Mode public (Public) : permet le contrôle des opérations en dehors de l'objet.
Mode privé (Privé) : seules les méthodes de cet objet sont autorisées à le faire fonctionner et à le contrôler.
Mode protégé (Protégé) : permet à cet objet et à son objet parent de le faire fonctionner et de le contrôler.
Exemple 4 : Modes privé, public et protégé dans les objets
classe foo {
privé $x ;
fonction publique public_foo() {
print("Je suis public");
}
fonction protégée protected_foo() {
$this->private_foo(); //Ok parce que nous sommes dans la même classe, nous pouvons appeler des méthodes privées
print("Je suis protégé");
}
fonction privée private_foo() {
$this->x = 3;
print("Je suis privé");
}
}
la classe foo2 étend foo {
affichage de la fonction publique() {
$this->protected_foo();
$this->public_foo();
// $this->private_foo(); // Invalide ! la fonction est privée dans la classe de base
}
} $x = nouveau foo();
$x->public_foo();
//$x->protected_foo(); //Invalid ne peut pas appeler de méthodes protégées en dehors de la classe et des classes dérivées
//$x->private_foo(); //Les méthodes privées invalides ne peuvent être utilisées qu'à l'intérieur de la classe $x2 = new foo2();
$x2->affichage();
?>
Astuce : Les variables dans les objets existent toujours sous forme privée. L'exploitation directe des variables dans un objet n'est pas une bonne habitude de programmation orientée objet. Une meilleure façon consiste à transmettre les variables souhaitées à la méthode d'un objet pour le traitement.
Interfaces
Comme nous le savons tous, les objets en PHP4 prennent en charge l'héritage. Pour faire d'un objet une classe dérivée d'un autre objet, vous devez utiliser un code similaire à "class foo extends parent" pour le contrôler. En PHP4 et PHP5, un objet ne peut être hérité qu'une seule fois et l'héritage multiple n'est pas pris en charge. Cependant, un nouveau terme est né en PHP5 : interface. Une interface est un objet spécial sans code de traitement spécifique. Elle définit uniquement les noms et les paramètres de certaines méthodes. Après cela, l'objet peut être facilement utilisé avec le mot-clé 'implement'. Les interfaces requises sont intégrées, puis le code d'exécution spécifique est ajouté.
Exemple 5 : Interface
interface affichable {
affichage de la fonction();
}
interface imprimable {
fonction doprint();
}
la classe foo implémente displayable,printable {
fonction affichage() {
//code
} fonction doprint() {
//code
}
}
?>
Ceci est très utile pour améliorer la lisibilité et la popularité du code. À partir de l'exemple ci-dessus, nous pouvons voir que l'objet foo contient deux interfaces, affichable et imprimable. À ce stade, nous pouvons clairement savoir que l'objet foo doit avoir un affichage. () et une méthode print(), il vous suffit de comprendre la partie interface, vous pouvez facilement utiliser l'objet sans avoir à vous soucier du fonctionnement interne de l'objet.
Classes abstraites
Les classes abstraites ne peuvent pas être instanciées.
Les classes abstraites, comme les autres classes, permettent de définir des variables et des méthodes.
Une classe abstraite peut également définir une méthode abstraite. La méthode de la classe abstraite ne sera pas exécutée, mais elle pourra l'être dans sa classe dérivée.
Exemple 6 : classe abstraite
classe abstraite foo {
protégé $x ;
affichage de la fonction abstraite ();
fonction setX($x) {
$this->x = $x;
}
}
la classe foo2 étend foo {
fonction affichage() {
//Code
}
}
?>
__call
Les objets PHP5 ont une nouvelle méthode dédiée __call(), qui est utilisée pour surveiller d'autres méthodes dans un objet. Si vous essayez d'appeler une méthode qui n'existe pas sur l'objet, la méthode __call sera appelée automatiquement.
Exemple 7 : __appel
classe foo {
fonction __call($nom,$arguments) {
print("M'as-tu appelé ? Je m'appelle $name !");
}
} $x = nouveau foo();
$x->doStuff();
$x->fancy_stuff();
?>
Cette méthode spéciale peut être utilisée pour implémenter des actions de « surcharge », afin que vous puissiez vérifier vos paramètres et les transmettre en appelant une méthode privée.
Exemple 8 : Utilisation de __call pour implémenter l'action « surcharge »
classe Magie {
fonction __call($nom,$arguments) {
si($nom=='foo') {
if(is_int($arguments[0])) $this->foo_for_int($arguments[0]);
if(is_string($arguments[0])) $this->foo_for_string($arguments[0]);
}
} fonction privée foo_for_int($x) {
print("oh un int!");
} fonction privée foo_for_string($x) {
print("oh une chaîne !");
}
} $x = nouveau Magic();
$x->foo(3);
$x->foo("3");
?>
__set et __get
C'est une excellente méthode Les méthodes __set et __get peuvent être utilisées pour capturer des variables et des méthodes qui n'existent pas dans un objet.
Exemple 9 : __set et __get
classe foo {
fonction __set ($ nom, $ val) {
print("Bonjour, vous avez essayé de mettre $val dans $name");
}
fonction __get($nom) {
print("Hé, tu as demandé $name");
}
}
$x = nouveau foo();
$x->barre = 3 ;
print($x->winky_winky);
?>
Indication de type
En PHP5, vous pouvez spécifier dans la méthode d'un objet que son paramètre doit être une instance d'un autre objet.
Exemple 10 : Indication de type
classe foo {
//code...
}
barre de classe {
fonction publique process_a_foo(foo $foo) {
//Un peu de code
}
}
$b = nouvelle barre();
$f = nouveau foo();
$b->process_a_foo($f);
?>
Comme on peut le voir, nous pouvons spécifier explicitement le nom d'un objet avant le paramètre, et PHP5 reconnaîtra que le paramètre sera une instance d'objet.
Membres statiques
Les membres statiques et les méthodes statiques sont appelés « méthodes objet (méthodes de classe) » et « variables objet (variables de classe) » dans la terminologie de programmation orientée objet.
Les « méthodes objet » peuvent être appelées avant qu’un objet ne soit instancié. De même, les « variables d'objet » peuvent être contrôlées indépendamment avant qu'un objet ne soit instancié (sans utiliser les méthodes d'un objet pour le contrôler).
Exemple 11 : méthodes objet et variables objet
calculateur de classe {
public statique $pi = 3,14151692 ;
fonction publique statique add($x,$y) {
retourner $x + $y ;
}
}
$s = calculatrice ::$pi;
$result = calculatrice :: add (3,7);
print("$résultat");
?>
Gestion des exceptions
La gestion des exceptions est reconnue comme une méthode idéale pour gérer les erreurs de programme. Ce concept est disponible en Java et C++. Nous sommes heureux de voir que cette application a été ajoutée à PHP5. Vous pouvez essayer d'utiliser « try » et « catch » pour contrôler les erreurs du programme.
Exemple 12 : Gestion des exceptions
classe foo {
fonction diviser($x,$y) {
if($y==0) throw new Exception("ne peut pas diviser par zéro");
retourner $x/$y ;
}
}
$x = nouveau foo();
essayer {
$x->diviser(3,0);
} catch (Exception $e) {
echo $e->getMessage();
écho "n
n";
// Quelques mesures catastrophiques ici
}
?>
Dans l'exemple ci-dessus, nous avons utilisé "try" pour exécuter l'instruction entre accolades. Lorsqu'une erreur se produit, le code transmettra l'erreur à la clause "catch" pour traitement. Dans la clause "catch", vous devez spécifier. La gestion des erreurs sur un objet peut rendre la structure du code plus claire, car nous pouvons désormais transmettre toutes les informations d'erreur à un objet pour qu'il soit traité.
Gestion des erreurs personnalisée
Vous pouvez facilement contrôler les accidents dans votre programme avec un code de gestion des erreurs personnalisé. Il vous suffit de dériver votre propre classe de contrôle d'erreurs à partir de la classe d'exception. Dans votre propre classe de contrôle d'erreurs, vous devez disposer d'un constructeur et d'une méthode getMessage.
Exemple 13 : Gestion des erreurs personnalisée
la classe WeirdProblem étend l'exception {
données $ privées ;
fonction WeirdProblem($données) {
parent::exception();
$this->données = $données ;
}
fonction getMessage() {
return $this->data . " a provoqué une exception étrange ! ";
}
}
?>
Nous pouvons maintenant utiliser "throw new WeirdProblem($foo)" pour lancer un gestionnaire d'erreurs. Si l'erreur se produit dans le bloc de code "try", PHP5 transmettra automatiquement l'erreur à la partie "catch" pour traitement.
Espaces de noms
Les espaces de noms sont utiles pour le regroupement de classes ou le regroupement de fonctions. Il peut regrouper certaines classes ou fonctions associées pour faciliter les appels ultérieurs.
Exemple 14 : espace de noms
espace de noms Math {
classe Complexe {
//...code...
fonction __construct() {
print("hé");
}
}
} $m = nouveau Math::Complexe();
?>
Faites attention aux circonstances dans lesquelles vous devez utiliser des espaces de noms. Dans les applications pratiques, vous devrez peut-être déclarer deux objets ou plus avec le même nom pour faire des choses différentes, vous pourrez alors les placer dans des espaces de noms différents (mais l'interface doit l'être. le même).