Dieses Mal zeige ich Ihnen, wie Sie die statische PHP-Bindung in Projekten verwenden und welche Vorsichtsmaßnahmen für die Verwendung der statischen PHP-Bindung in Projekten gelten. Das Folgende ist ein praktischer Fall, schauen wir uns das an.
Grundkenntnisse
1. Bereichsanalyseoperator (::)
kann verwendet werden Es wird für den Zugriff auf statische Mitglieder und Klassenkonstanten verwendet und kann auch zum Überschreiben von Eigenschaften und Methoden in der Klasse verwendet werden.
Die drei speziellen Schlüsselwörter self, parent und static werden verwendet, um auf ihre Eigenschaften oder Methoden innerhalb der Klassendefinition zuzugreifen.
parent wird verwendet, um überschriebene Eigenschaften oder Methoden in der übergeordneten Klasse aufzurufen (wo es erscheint, wird es in die übergeordnete Klasse der entsprechenden Klasse aufgelöst).
self wird verwendet, um Methoden oder Eigenschaften in dieser Klasse aufzurufen (wo immer es erscheint, wird es in die entsprechende Klasse geparst; beachten Sie den Unterschied zu $this, $this zeigt auf den aktuellen Wert instanziiertes Objekt).
Wenn eine Unterklasse eine Methode in ihrer übergeordneten Klasse überschreibt, ruft PHP die überschriebene Methode in der übergeordneten Klasse nicht auf. Ob die Methode der übergeordneten Klasse aufgerufen wird, hängt von der untergeordneten Klasse ab.
2. Der PHP-Kernel platziert die Vererbungsimplementierung von Klassen in der „Kompilierungsphase“
<?php
class A{
const H = 'A';
const J = 'A';
static function testSelf(){
echo self::H; //在编译阶段就确定了 self解析为 A
}
}
class B extends A{
const H = "B";
const J = 'B';
static function testParent(){
echo parent::J; //在编译阶段就确定了 parent解析为A
}
/* 若重写testSelf则能输出“B”, 且C::testSelf()也是输出“B”
static function testSelf(){
echo self::H;
}
*/
}
class C extends B{
const H = "C";
const J = 'C';
}
B::testParent();
B::testSelf();
echo "\n";
C::testParent();
C::testSelf();Ergebnisse ausführen:
AA
AA
Schlussfolgerung:
self:: und parent:: erscheinen in der Definition einer Klasse X, sie werden in die entsprechende Klasse geparst X, es sei denn, die Methode der übergeordneten Klasse wird in der Unterklasse überschrieben.
3.Statisches (statisches) Schlüsselwort
Funktion:
- Das statische Schlüsselwort wird zum Ändern von Variablen im Funktionskörper Definieren verwendet statische lokale Variablen.
- Wird zum Deklarieren statischer Mitglieder beim Ändern von Klassenmitgliedsfunktionen und Mitgliedsvariablen verwendet.
- (nach PHP5.3) eine spezielle Klasse, die eine statische verzögerte Bindung vor dem Scope-Resolver darstellt (::).
Beispiel:
Statische lokale Variablen definieren (Vorkommen: in lokalen Funktionen)
Feature: Statische Variablen existieren nur im lokalen Funktionsbereich, aber wenn das Programm Sein Wert geht nicht verloren, wenn die Ausführung diesen Bereich verlässt.
<?php
function test()
{
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
test();
}
$count--;
}Statische Methoden und statische Attribute definieren
a) Klassenattribute oder -methoden als statisch deklarieren, damit direkt auf sie zugegriffen werden kann, ohne die Klasse zu instanziieren.
b) Auf statische Eigenschaften kann nicht über ein instanziiertes Objekt einer Klasse zugegriffen werden (auf statische Methoden ist dies jedoch möglich).
c) Wenn keine Zugriffskontrolle angegeben ist, sind Eigenschaften und Methoden standardmäßig öffentlich.
d) Da statische Methoden keinen Aufruf eines Objekts erfordern, ist die Pseudovariable $this in statischen Methoden nicht verfügbar.
e) Auf statische Eigenschaften können Objekte nicht über den ->-Operator zugreifen.
f) Der statische Aufruf einer nicht statischen Methode führt zu einem Fehler auf E_STRICT-Ebene.
g) Wie alle anderen statischen PHP-Variablen können statische Eigenschaften nur als Literale oder Konstanten initialisiert werden, nicht als Ausdrücke. Eine statische Eigenschaft kann also mit einer Ganzzahl oder einem Array initialisiert werden, sie kann jedoch nicht mit einem anderen Variablen- oder Funktionsrückgabewert initialisiert werden und kann auch nicht auf ein Objekt verweisen.
a. Beispiel für eine statische Methode (Vorkommen: Klassenmethodendefinition)
<?php
class Foo {
public static function aStaticMethod() {
// ...
}
}
Foo::aStaticMethod();
$classname = 'Foo';
$classname::aStaticMethod(); // 自PHP 5.3.0后，可以通过变量引用类
?>b. Beispiel für ein statisches Attribut (Vorkommen: Klassenattributdefinition)
<?php
class Foo
{
public static $my_static = 'foo';
public function staticValue() {
return self::$my_static; //self 即 FOO类
}
}
class Bar extends Foo
{
public function fooStatic() {
return parent::$my_static; //parent 即 FOO类
}
}
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";
?>c Bindung (Position: in Klassenmethoden, wird zum Ändern von Variablen oder Methoden verwendet)
Eine detaillierte Analyse unten
Späte statische Bindung (späte statische Bindung)
Seit PHP 5.3.0 hat PHP eine Funktion namens „späte statische Bindung“ hinzugefügt, die verwendet wird, um statisch aufgerufene Klassen im Vererbungsbereich zu referenzieren.
1. Weitergeleitete Anrufe und nicht weitergeleitete Anrufe
Weitergeleitete Anrufe:
bezieht sich auf statische Anrufe, die auf folgende Weise getätigt werden: selbst: :, parent::, static:: und forward_static_call().
Nicht weitergeleitete Aufrufe:
Statische Aufrufe, die explizit den Klassennamen angeben (z. B. Foo::foo())
Nicht statische Aufrufe (z. B. $foo-> ;foo( ))
2. Funktionsprinzip der späten statischen Bindung
Prinzip: Der Klassenname im vorherigen „Nicht-Weiterleitungsaufruf“ wird gespeichert. Das heißt, wenn wir einen statischen Aufruf aufrufen, bei dem es sich um einen Weiterleitungsaufruf handelt, ist die tatsächlich aufgerufene Klasse die Klasse des vorherigen Nicht-Weiterleitungsaufrufs.
例子分析：
<?php
class A {
public static function foo() {
echo __CLASS__."\n";
static::who();
}
public static function who() {
echo __CLASS__."\n";
}
}
class B extends A {
public static function test() {
echo "A::foo()\n";
A::foo();
echo "parent::foo()\n";
parent::foo();
echo "self::foo()\n";
self::foo();
}
public static function who() {
echo __CLASS__."\n";
}
}
class C extends B {
public static function who() {
echo __CLASS__."\n";
}
}
C::test();
/*
* C::test(); //非转发调用 ，进入test()调用后，“上一次非转发调用”存储的类名为C
*
* //当前的“上一次非转发调用”存储的类名为C
* public static function test() {
* A::foo(); //非转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为A，然后实际执行代码A::foo(), 转 0-0
* parent::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为C， 此处的parent解析为A ,转1-0
* self::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为C， 此处self解析为B, 转2-0
* }
*
*
* 0-0
* //当前的“上一次非转发调用”存储的类名为A
* public static function foo() {
* static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为A， 故实际执行代码A::who(),即static代表A，进入who()调用后，“上一次非转发调用”存储的类名依然为A，因此打印 “A”
* }
*
* 1-0
* //当前的“上一次非转发调用”存储的类名为C
* public static function foo() {
* static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为C， 故实际执行代码C::who(),即static代表C，进入who()调用后，“上一次非转发调用”存储的类名依然为C，因此打印 “C”
* }
*
* 2-0
* //当前的“上一次非转发调用”存储的类名为C
* public static function foo() {
* static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为C， 故实际执行代码C::who(),即static代表C，进入who()调用后，“上一次非转发调用”存储的类名依然为C，因此打印 “C”
* }
*/
故最终结果为：
A::foo()
A
A
parent::foo()
A
C
self::foo()
A
C3.更多静态后期静态绑定的例子
a)Self, Parent 和 Static的对比
<?php
class Mango {
function classname(){
return __CLASS__;
}
function selfname(){
return self::classname();
}
function staticname(){
return static::classname();
}
}
class Orange extends Mango {
function parentname(){
return parent::classname();
}
function classname(){
return __CLASS__;
}
}
class Apple extends Orange {
function parentname(){
return parent::classname();
}
function classname(){
return __CLASS__;
}
}
$apple = new Apple();
echo $apple->selfname() . "\n";
echo $apple->parentname() . "\n";
echo $apple->staticname();
?>
运行结果：
Mango
Orange
Appleb)使用forward_static_call()
<?php
class Mango
{
const NAME = 'Mango is';
public static function fruit() {
$args = func_get_args();
echo static::NAME, " " . join(' ', $args) . "\n";
}
}
class Orange extends Mango
{
const NAME = 'Orange is';
public static function fruit() {
echo self::NAME, "\n";
forward_static_call(array('Mango', 'fruit'), 'my', 'favorite', 'fruit');
forward_static_call('fruit', 'my', 'father\'s', 'favorite', 'fruit');
}
}
Orange::fruit('NO');
function fruit() {
$args = func_get_args();
echo "Apple is " . join(' ', $args). "\n";
}
?>
运行结果：
Orange is
Orange is my favorite fruit
Apple is my father's favorite fruitc)使用get_called_class()
<?php
class Mango {
static public function fruit() {
echo get_called_class() . "\n";
}
}
class Orange extends Mango {
//
}
Mango::fruit();
Orange::fruit();
?>
运行结果：
Mango
Orange应用
前面已经提到过了，引入后期静态绑定的目的是：用于在继承范围内引用静态调用的类。
所以， 可以用后期静态绑定的办法解决单例继承问题。
先看一下使用self是一个什么样的情况：
<?php
// new self 得到的单例都为A。
class A
{
protected static $_instance = null;
protected function __construct()
{
//disallow new instance
}
protected function __clone(){
//disallow clone
}
static public function getInstance()
{
if (self::$_instance === null) {
self::$_instance = new self();
}
return self::$_instance;
}
}
class B extends A
{
protected static $_instance = null;
}
class C extends A{
protected static $_instance = null;
}
$a = A::getInstance();
$b = B::getInstance();
$c = C::getInstance();
var_dump($a);
var_dump($b);
var_dump($c);
运行结果：
E:\code\php_test\apply\self.php:37:
class A#1 (0) {
}
E:\code\php_test\apply\self.php:38:
class A#1 (0) {
}
E:\code\php_test\apply\self.php:39:
class A#1 (0) {
}通过上面的例子可以看到，使用self，实例化得到的都是类A的同一个对象
再来看看使用static会得到什么样的结果
<?php
// new static 得到的单例分别为D，E和F。
class D
{
protected static $_instance = null;
protected function __construct(){}
protected function __clone()
{
//disallow clone
}
static public function getInstance()
{
if (static::$_instance === null) {
static::$_instance = new static();
}
return static::$_instance;
}
}
class E extends D
{
protected static $_instance = null;
}
class F extends D{
protected static $_instance = null;
}
$d = D::getInstance();
$e = E::getInstance();
$f = F::getInstance();
var_dump($d);
var_dump($e);
var_dump($f);
运行结果：
E:\code\php_test\apply\static.php:35:
class D#1 (0) {
}
E:\code\php_test\apply\static.php:36:
class E#2 (0) {
}
E:\code\php_test\apply\static.php:37:
class F#3 (0) {
}相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！
推荐阅读：
Das obige ist der detaillierte Inhalt vonSo verwenden Sie die statische PHP-Bindung in Ihrem Projekt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
So öffnen Sie eine PHP-Datei
So entfernen Sie die ersten paar Elemente eines Arrays in PHP
Was tun, wenn die PHP-Deserialisierung fehlschlägt?
So verbinden Sie PHP mit der MSSQL-Datenbank
So verbinden Sie PHP mit der MSSQL-Datenbank
So laden Sie HTML hoch
So lösen Sie verstümmelte Zeichen in PHP
So öffnen Sie PHP-Dateien auf einem Mobiltelefon
