Cet article présente principalement des informations pertinentes résumant les connaissances liées aux objets PHP. Les amis qui en ont besoin peuvent s'y référer
Passage d'objet : Une façon de le dire est "Les objets PHP sont passés par référence", ce qui est L'argument est que les alias (identifiants) sont transmis, c'est-à-dire qu'ils stockent tous une copie du même identifiant (ID), qui pointe vers le contenu réel du même objet.
<?php
class A {
public $foo = 1;
}
$a = new A;
$b = $a; // $a ,$b都是同一个标识符的拷贝
// ($a) = ($b) = <id>
$b->foo = 2;
echo $a->foo."\n";//2
$c = new A;
$d = &$c; // $c ,$d是引用
// ($c,$d) = <id>
$d->foo = 2;
echo $c->foo."\n";//2
$e = new A;
function foo($obj) {
// ($obj) = ($e) = <id>
$obj->foo = 2;
}
foo($e);
echo $e->foo."\n";//2•Copie d'objet : la copie d'objet peut être effectuée via le mot-clé clone Si l'objet d'origine définit la méthode __clone(), le nouvel objet le sera. La méthode __clone() sera appelée après la copie, et la méthode __clone() pourra être utilisée pour modifier la valeur des attributs de l'objet copié. Lorsqu'un objet est copié, une copie superficielle sera effectuée sur toutes les propriétés de l'objet, mais toutes les propriétés de référence seront toujours des références aux variables d'origine.
<?php
class SubObject
{
static $instances = 0;
public $instance;
public function __construct()
{
$this->instance = ++self::$instances;
}
public function __clone()
{
$this->instance = ++self::$instances;
}
}
class MyCloneable
{
public $object1;
public $object2;
function __clone()
{
// 强制复制一份this->object， 否则仍然指向同一个对象
$this->object1 = clone $this->object1;
}
function cloneTest()
{
echo 'cloneTest';
}
}
$obj = new MyCloneable();
$obj->object1 = new SubObject();
$obj->object2 = new SubObject();
$obj2 = clone $obj;
print("Original Object:\n");
print_r($obj);
print("Cloned Object:\n");
print_r($obj2);
echo $obj2->cloneTest().":\n";
echo (new Reflectionclass($obj2));Résultat de sortie de l'exemple ci-dessus :
Original Object:
MyCloneable Object
(
[object1] => SubObject Object
(
[instance] => 1
)
[object2] => SubObject Object
(
[instance] => 2
)
)
Cloned Object:
MyCloneable Object
(
[object1] => SubObject Object
(
[instance] => 3
)
[object2] => SubObject Object
(
[instance] => 2
)
)
cloneTest:
Class [ <user> class MyCloneable ] {
@@ /public/t.php 18-33
- Constants [0] {
}
- Static properties [0] {
}
- Static methods [0] {
}
- Properties [2] {
Property [ <default> public $object1 ]
Property [ <default> public $object2 ]
}
- Methods [2] {
Method [ <user> public method __clone ] {
@@ /public/t.php 23 - 27
}
Method [ <user> public method cloneTest ] {
@@ /public/t.php 29 - 32
}
}
}• Traversée d'objet : foreach ne peut parcourir que les propriétés visibles de l'objet, mais ne peut pas parcourir ses méthodes, il est donc plus facile à implémenter. De plus, les propriétés de l'objet peuvent également être parcourues en implémentant les méthodes de l'interface Iterator ou de l'interface IteratorAggregate.
•Contraintes de type : PHP est un langage faiblement typé. Les contraintes de type peuvent rendre la programmation plus standardisée et réduire les erreurs ; les contraintes de type peuvent non seulement être utilisées dans les définitions d'objets, mais également dans les définitions de fonctions. Les contraintes de type peuvent spécifier des objets, des interfaces, des tableaux et des callables (les rappels de fermeture sont utilisés pour garantir que le type de données réel est cohérent avec la définition du prototype). la valeur par défaut est NULL, le paramètre réel peut alors être NULL ; les contraintes de type ne peuvent pas être utilisées pour les types scalaires tels que int ou string, ni les traits.
• Sérialisation et restauration d'objets : la fonction serialize() peut convertir une chaîne contenant un flux d'octets en chaîne pour un stockage facile des objets, et la fonction unserialize() peut restaurer une chaîne en objet. Mais il existe un principe selon lequel, quelle que soit la sérialisation ou la désérialisation, la définition de classe de l'objet est terminée, c'est-à-dire que la classe (fichier) doit d'abord être importée.
•Surcharge : la surcharge de PHP inclut des attributs et des méthodes. Elle ressemble plus à un idiome. Elle ne prend pas en charge les spécifications de syntaxe de surcharge courantes. Elle est imprévisible et a un impact plus large. méthodes) pour appeler des attributs ou des méthodes de classe non définis ou invisibles dans l’environnement actuel. Toutes les méthodes surchargées doivent être déclarées publiques (cela devrait être plus facile à comprendre. D'autres peuvent avoir besoin de vous car elles sont invisibles, vous devez donc être visible), et les paramètres ne peuvent pas être transmis par référence (les méthodes surchargées sont imprévisibles, probablement pour des raisons de sécurité, à empêcher que les variables soient référencées à volonté). Les propriétés surchargées ne peuvent pas être utilisées dans d'autres constructions de langage à l'exception de isset(), ce qui signifie que lorsque empty() est utilisé sur une propriété surchargée, la méthode magique surchargée ne sera pas appelée pour éviter cette limitation, les attributs surchargés doivent être attribués aux variables locales ; puis empty() est utilisé. On peut voir qu'il existe des attributs surchargés entre les attributs légaux et les attributs illégaux.
[Surcharge d'attributs] : Ces méthodes ne peuvent pas être déclarées statiques. Dans les méthodes statiques, ces méthodes magiques ne seront pas appelées
public void __set ( string $name , Mixed $value )
Lors de l'attribution d'un valeur à une propriété inaccessible, __set() sera appelée
public mixte __get ( string $name )
Lors de la lecture de la valeur d'une propriété inaccessible, __get() sera appelée
public bool __isset ( string $name )
Lorsque isset() ou empty() est appelé sur une propriété inaccessible, __isset() sera appelé
public void __unset ( string $name )
Quand unset() est appelé sur une propriété inaccessible, __unset() sera appelé
Remarque :
En raison de la façon dont PHP gère les opérations d'affectation, la valeur de retour de __set() sera ignorée. De même, dans l'affectation de chaîne suivante, __get() ne sera pas appelé :
$a = $obj->b = 8;
[Surcharge de méthode] :
public Mixed __call ( string $name , array $arguments )
Lorsqu'une méthode inaccessible est appelée dans un objet, __call() sera appelée
public static Mixed __callStatic ( string $name , array $arguments )
Quand un inaccessible est appelée dans un contexte statique, __callStatic() sera appelée
• Propriétés et méthodes statiques : le mot-clé static est utilisé pour définir les propriétés statiques et les méthodes statiques ne peuvent pas être instanciées par Object-> accès (mais les méthodes statiques le peuvent). Les propriétés statiques ne peuvent être initialisées que sous forme d'expressions constantes. Les propriétés statiques peuvent donc être initialisées sous forme d'entiers ou de tableaux, mais elles ne peuvent pas être initialisées comme une autre variable ou valeur de retour de fonction, ni pointer vers un objet. Vous pouvez utiliser une variable pour représenter une classe afin d'appeler dynamiquement des propriétés statiques, mais la valeur de la variable ne peut pas être le mot-clé self, parent ou static.
class Foo
{
public static $my_static = 'foo';
public function staticValue() {
return self::$my_static;
}
}
class Bar extends Foo
{
public function fooStatic() {
return parent::$my_static;
}
}
print Foo::$my_static . "\n";
$foo = new Foo();
print $foo->staticValue() . "\n";
print $foo->my_static . "\n"; // Undefined "Property" my_static
print $foo::$my_static . "\n";
$classname = 'Foo';
print $classname::$my_static . "\n"; // As of PHP 5.3.0
print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";•后期静态绑定：static:: 定义后期静态绑定工作原理是存储了上一个“非转发调用”（non-forwarding call）的类名。当进行静态方法调用时，该类名即为明确指定的那个（通常在 :: 运算符左侧部分）；当进行非静态方法调用时，即为该对象所属的类。使用 self:: 或者 __CLASS__ 对当前类的静态引用，取决于定义当前方法所在的类；static:: 不再被解析为定义当前方法所在的类，而是在实际运行时计算的，可以用于静态属性和所有方法的调用。
<?php
class A
{
private $proPrivate = "private of A";
protected $proProtected = "protected of A";
public $proPublic = "public of A";
private function foo()
{
echo $this->proPrivate."\n";
echo $this->proProtected."\n";
echo $this->proPublic."\n";
}
public function test()
{
$this->foo();
static::foo();
}
}
class B extends A
{
/* foo() will be copied to B, hence its scope will still be A and
* the call be successful */
}
class C extends A
{
private $proPrivate = "private of C";
protected $proProtected = "protected of C";
public $proPublic = "public of C";
private function foo()
{
/* original method is replaced; the scope of the new one is C */
echo "I am C\n";
}
public function myFoo()
{
//parent::foo();
$this->foo();
}
}
echo "Class B:\n";
$b = new B();
$b->test();
echo "\nClass C:\n";
$c = new C();
$c->myFoo();
$c->test(); //fails上例输出结果：
Class B:
private of A
protected of A
public of A
private of A
protected of A
public of A
Class C:
I am C
private of A
protected of C
public of C
Fatal error: Uncaught Error: Call to private method C::foo() from context 'A' in /public/t.php:19 Stack trace: #0 /public/t.php(54): A->test() #1 {main} thrown in /public/t.php on line 19•继承：官方文档对继承有这样一段描述“当扩展一个类，子类就会继承父类所有公有的和受保护的方法。除非子类覆盖了父类的方法，被继承的方法都会保留其原有功能”，言下之意似乎私有属性和方法不会被继承；然而上例又告诉我们子类拥有与父类一致的属性和方法，继承就是全盘复制，这才能满足我们对继承编程的需求，如果私有的不能继承，子类就必须自行重新定义，在大多数时候没有必要。另外就是可见性问题，父类的私有属性和方法在子类是不可见的。上例还告诉我们对象实际执行的域要考虑可见性、继承、后期静态绑定机制。
以上就是本文的全部内容，希望对大家的学习有所帮助。
相关推荐：
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Comment ouvrir le fichier php
Comment supprimer les premiers éléments d'un tableau en php
Que faire si la désérialisation php échoue
Comment connecter PHP à la base de données mssql
Comment connecter PHP à la base de données mssql
Comment télécharger du HTML
Comment résoudre les caractères tronqués en PHP
Comment ouvrir des fichiers php sur un téléphone mobile
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
