Zusammenfassung des Wissens über PHP-Objekte

Dieser Artikel stellt hauptsächlich relevante Informationen vor, die das Wissen über PHP-Objekte zusammenfassen. Freunde, die sie benötigen, können darauf verweisen.

Objektübergabe: Eine Möglichkeit, es auszudrücken, ist, dass „PHP-Objekte per Referenz übergeben werden“. Das Argument ist, dass Aliase (Bezeichner) übergeben werden, das heißt, sie speichern alle eine Kopie desselben Bezeichners (ID), der auf den tatsächlichen Inhalt desselben Objekts verweist.

 <?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

• Kopieren von Objekten: Das Kopieren von Objekten kann über das Schlüsselwort clone abgeschlossen werden. Wenn das ursprüngliche Objekt die Methode __clone() definiert, dann _ im neuen Objekt Die Methode _clone() wird nach dem Kopieren aufgerufen und die Methode __clone() kann verwendet werden, um den Wert der Attribute des kopierten Objekts zu ändern. Wenn ein Objekt kopiert wird, wird eine flache Kopie aller Eigenschaften des Objekts durchgeführt, alle Referenzeigenschaften sind jedoch weiterhin Verweise auf die ursprünglichen Variablen.

 <?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 &#39;cloneTest&#39;;
   }
 }
 
 $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));

Das Ausgabeergebnis des obigen Beispiels:

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
  }
 }
}

• Objektdurchquerung: foreach kann nur die sichtbaren Eigenschaften eines Objekts durchlaufen, nicht seine Methoden, daher ist es einfacher zu implementieren. Darüber hinaus können Sie Objekteigenschaften auch über Methoden durchlaufen, die die Iterator-Schnittstelle oder die IteratorAggregate-Schnittstelle implementieren.

Typbeschränkungen: PHP ist eine schwach typisierte Sprache, die die Programmierung standardisieren und Fehler reduzieren kann. Typbeschränkungen können nicht nur in Objektdefinitionen, sondern auch in Funktionsdefinitionen verwendet werden. Typeinschränkungen können Objekte, Schnittstellen, Arrays und aufrufbare Elemente angeben (Abschlussrückrufe), um sicherzustellen, dass der tatsächliche Datentyp mit der Prototypdefinition übereinstimmt. Wenn er jedoch inkonsistent ist, wird ein abfangbarer schwerwiegender Fehler ausgegeben. Wenn der Standardwert NULL ist, kann der tatsächliche Parameter NULL sein. Typbeschränkungen können nicht für Skalartypen wie int oder string verwendet werden, ebenso wenig wie Merkmale.

• Objektserialisierung und -wiederherstellung: Die Funktion serialize() kann eine Zeichenfolge, die einen Bytestrom enthält, in eine Zeichenfolge umwandeln, um die Speicherung von Objekten zu vereinfachen, und die Funktion unserialize() kann eine Zeichenfolge in ein Objekt wiederherstellen. Es besteht jedoch die Voraussetzung, dass die Klassendefinition des Objekts unabhängig von der Serialisierung oder Deserialisierung abgeschlossen ist, dh die Klasse (Datei) muss zuerst importiert werden.

•Überladung: Die Überladung von PHP ähnelt eher einer Redewendung. Sie ist unvorhersehbar und hat eine größere Auswirkung. Methoden), um undefinierte oder unsichtbare Klassenattribute oder Methoden in der aktuellen Umgebung aufzurufen. Alle überladenen Methoden müssen als öffentlich deklariert werden (dies sollte leichter zu verstehen sein. Andere benötigen Sie möglicherweise, weil sie unsichtbar sind, sodass Sie sichtbar sein müssen), und Parameter können nicht als Referenz übergeben werden (überladene Methoden sind unvorhersehbar, wahrscheinlich aus Sicherheitsgründen, um dies zu verhindern). Variablen können nicht beliebig referenziert werden). Überladene Eigenschaften können in anderen Sprachkonstrukten außer isset() nicht verwendet werden. Das bedeutet, dass bei Verwendung von empty() für eine überladene Eigenschaft die überladene Magic-Methode nicht aufgerufen wird, um diese Einschränkung zu vermeiden. Überladene Attribute müssen lokalen Variablen zugewiesen werden und dann wird empty() verwendet. Es ist ersichtlich, dass zwischen legalen Attributen und illegalen Attributen überladene Attribute vorhanden sind.

[Attributüberladung]: Diese Methoden können nicht als statisch deklariert werden. In statischen Methoden werden diese magischen Methoden nicht aufgerufen
public void __set ( string $name , Mixed $value )
Bei der Zuweisung von a Wert für eine unzugängliche Eigenschaft, wird __set() aufgerufen

öffentliches gemischtes __get ( string $name )
Beim Lesen des Werts einer unzugänglichen Eigenschaft wird __get() aufgerufen

public bool __isset ( string $name )
Wenn isset() oder empty() für eine unzugängliche Eigenschaft aufgerufen wird, wird __isset() aufgerufen

public void __unset ( string $name )
Wann Wenn unset() für eine unzugängliche Eigenschaft aufgerufen wird, wird __unset() aufgerufen

Hinweis:
Aufgrund der Art und Weise, wie PHP Zuweisungsvorgänge verarbeitet, wird der Rückgabewert von __set() ignoriert. Ebenso wird __get() in der folgenden Kettenzuweisung nicht aufgerufen:
$a = $obj->b = 8;

[Methodenüberladung]:
public Mixed __call ( string $name , array $arguments )
Wenn eine unzugängliche Methode in einem Objekt aufgerufen wird, wird __call() aufgerufen

public static Mixed __callStatic ( string $name , array $arguments )
Wenn an Wenn eine nicht zugängliche Methode in einem statischen Kontext aufgerufen wird, wird __callStatic() aufgerufen.

• Statische Eigenschaften und Methoden: Das Schlüsselwort static wird verwendet, um statische Eigenschaften und statische Methoden zu definieren Zugriff (statische Methoden können dies jedoch). Statische Eigenschaften können nur als konstante Ausdrücke initialisiert werden, sodass statische Eigenschaften als Ganzzahlen oder Arrays initialisiert werden können. Sie können jedoch nicht als andere Variable oder Funktionsrückgabewert initialisiert werden und können auch nicht auf ein Objekt verweisen. Sie können eine Variable verwenden, um eine Klasse darzustellen und statische Eigenschaften dynamisch aufzurufen. Der Wert der Variablen darf jedoch nicht das Schlüsselwort self, parent oder static sein.

 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

•继承：官方文档对继承有这样一段描述“当扩展一个类，子类就会继承父类所有公有的和受保护的方法。除非子类覆盖了父类的方法，被继承的方法都会保留其原有功能”，言下之意似乎私有属性和方法不会被继承；然而上例又告诉我们子类拥有与父类一致的属性和方法，继承就是全盘复制，这才能满足我们对继承编程的需求，如果私有的不能继承，子类就必须自行重新定义，在大多数时候没有必要。另外就是可见性问题，父类的私有属性和方法在子类是不可见的。上例还告诉我们对象实际执行的域要考虑可见性、继承、后期静态绑定机制。

以上就是本文的全部内容，希望对大家的学习有所帮助。

相关推荐：

PHP表单数据写入MySQL数据库的代码

php基于登陆时间判断实现一天多次登录只积分一次功能

php 三元运算符实例详细介绍

Das obige ist der detaillierte Inhalt vonZusammenfassung des Wissens über PHP-Objekte. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!