Dieses Mal erkläre ich Ihnen ausführlich die Analyse und Verwendung der späten statischen Bindung von PHP. Das Folgende ist ein praktischer Fall.
Grundkenntnisse1. Bereichsanalyseoperator (::)
<?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();
AA
AASchlussfolgerung:
self:: und parent:: erscheinen in der Definition einer Klasse X und werden in die entsprechende Klasse geparst X, es sei denn, die Methode der übergeordneten Klasse wird in der Unterklasse überschrieben.
3.Statisches (statisches) SchlüsselwortFunktion:
-statischer Schlüssel für geänderte Variablen im Funktionskörper Wortwird verwendet, um statische lokale Variablen zu definieren. - 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
Zugriffskontrolleangegeben ist, gelten Eigenschaften und Methoden Der Standardwert ist ö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. Daher kann eine statische Eigenschaft 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 (erscheint in: 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 (erscheint in: 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 späte statische Bindung (Position: in Klassenmethoden, wird zum Ändern von Variablen oder Methoden verwendet)
Eine detaillierte Analyse untenSpä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 AnrufeWeitergeleitete 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原理：存储了在上一个“非转发调用”（non-forwarding call）中的类名。意思是当我们调用一个转发调用的静态调用时，实际调用的类是上一个非转发调用的类。 例子分析： 3.更多静态后期静态绑定的例子 a)Self, Parent 和 Static的对比 b)使用forward_static_call() c)使用get_called_class() 应用 前面已经提到过了，引入后期静态绑定的目的是：用于在继承范围内引用静态调用的类。 先看一下使用self是一个什么样的情况： 通过上面的例子可以看到，使用self，实例化得到的都是类A的同一个对象 再来看看使用static会得到什么样的结果 相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！ 推荐阅读：<?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
C<?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
Apple<?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 fruit<?php
class Mango {
static public function fruit() {
echo get_called_class() . "\n";
}
}
class Orange extends Mango {
//
}
Mango::fruit();
Orange::fruit();
?>
运行结果：
Mango
Orange
所以， 可以用后期静态绑定的办法解决单例继承问题。<?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) {
}<?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) {
}
Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Verwendung der späten statischen Bindungsanalyse von PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Was sind die vier Big-Data-Analysetools?
statistische Analyse
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
