Code über einige Methoden und Funktionsanwendungen in PHP objektorientiert

Dieser Artikel stellt hauptsächlich einige Wissenspunkte über PHP-Objektorientierung vor, die einen gewissen Referenzwert haben. Jetzt können Freunde in Not darauf verweisen

1 🎜>

Eingebauter Konstruktor, der beim Erstellen des Objekts automatisch aufgerufen wird. Siehe den folgenden Code:

<?php
class ConstructTest {
    private $arg1;
    private $arg2;
 
    public function __construct($arg1, $arg2) {
        $this->arg1 = $arg1;
        $this->arg2 = $arg2;
        print "__construct is called...\n";
    }
    public function printAttributes() {
        print &#39;$arg1 = &#39;.$this->arg1.&#39; $arg2 = &#39;.$this->arg2."\n";
    }
}
$testObject = new ConstructTest("arg1","arg2");
$testObject->printAttributes();

Das laufende Ergebnis lautet wie folgt:

Stephens-Air:Desktop$ php Test.php 
__construct is called...
$arg1 = arg1 $arg2 = arg2

2. parent:

Wird verwendet, um die übergeordnete Klasse direkt aufzurufen Die Unterklassenmethode und -funktion entspricht super in Java.

<?php
class BaseClass {
    protected $arg1;
    protected $arg2;
 
    function __construct($arg1, $arg2) {
        $this->arg1 = $arg1;
        $this->arg2 = $arg2;
        print "__construct is called...\n";
    }
    function getAttributes() {
        return &#39;$arg1 = &#39;.$this->arg1.&#39; $arg2 = &#39;.$this->arg2;
    }
}
 
class SubClass extends BaseClass {
    protected $arg3;
 
    function __construct($baseArg1, $baseArg2, $subArg3) {
        parent::__construct($baseArg1, $baseArg2);
        $this->arg3 = $subArg3;
    }
    function getAttributes() {
        return parent::getAttributes().&#39; $arg3 = &#39;.$this->arg3;
    }
}
$testObject = new SubClass("arg1","arg2","arg3");
print $testObject->getAttributes()."\n";

Das laufende Ergebnis ist wie folgt:

Stephens-Air:Desktop$ php Test.php 
__construct is called...
$arg1 = arg1 $arg2 = arg2 $arg3 = arg3

3. self:

Rufen Sie die Präfixänderung von statischen Mitgliedern und statischen Methoden dieser Klasse auf Innerhalb der Klasse wird dies für nicht statische Mitgliedsvariablen und Funktionen verwendet.

<?php
class StaticExample {
    static public $arg1 = "Hello, This is static field.\n";
    static public function sayHello() {
        print self::$arg1;
    }
}
 
print StaticExample::$arg1;
StaticExample::sayHello();

Die laufenden Ergebnisse lauten wie folgt:

Stephens-Air:Desktop$ php Test.php 
Hello, This is static field.
Hello, This is static field.

4. static:

Das hier eingeführte Schlüsselwort static wird hauptsächlich in PHP 5.3 und höher verwendet . Verzögerte statische Bindungsfunktionalität. Bitte werfen Sie einen Blick auf den Code und kritische Kommentare.

<?php
abstract class Base {
    public static function getInstance() {
        //这里的new static()实例化的是调用该静态方法的当前类。
        return new static();
    }
    abstract public function printSelf();
}
 
class SubA extends Base {
    public function printSelf() {
        print "This is SubA::printSelf.\n";
    }
}
 
class SubB extends Base {
    public function printSelf() {
        print "This is SubB::printSelf.\n";
    }
}
 
SubA::getInstance()->printSelf();
SubB::getInstance()->printSelf();

Die laufenden Ergebnisse lauten wie folgt:

Stephens-Air:Desktop$ php Test.php 
This is SubA::printSelf.
This is SubB::printSelf.

Das Schlüsselwort static kann nicht nur zur Instanziierung verwendet werden. Wie self und parent kann auch static als Bezeichner für statische Methodenaufrufe verwendet werden, auch aus nicht statischen Kontexten. In diesem Szenario stellt self immer noch die Klasse dar, in der sich die aktuelle Methode befindet. Siehe den folgenden Code:

<?php
abstract class Base {
    private $ownedGroup;
    public function __construct() {
        //这里的static和上面的例子一样，表示当前调用该方法的实际类。
        //需要另外说明的是，这里的getGroup方法即便不是静态方法，也会得到相同的结果。然而倘若
        //getGroup真的只是普通类方法，那么这里还是建议使用$this。
        $this->ownedGroup = static::getGroup();
    }
    public function printGroup() {
        print "My Group is ".$this->ownedGroup."\n";
    }
    public static function getInstance() {
        return new static();
    }
    public static function getGroup() {
        return "default";
    }
}
 
class SubA extends Base {
}
 
class SubB extends Base {
    public static function getGroup() {
        return "SubB";
    }
}
 
SubA::getInstance()->printGroup();
SubB::getInstance()->printGroup();

Die laufenden Ergebnisse lauten wie folgt:

Stephens-Air:Desktop$ php Test.php 
My Group is default
My Group is SubB

5. __destruct:

Die Rolle Die Destruktormethode und die Konstruktormethode __construct sind genau das Gegenteil. Sie werden nur automatisch aufgerufen, bevor das Objekt vom Garbage Collector gesammelt wird. Wir können diese Methode verwenden, um einige notwendige Aufräumarbeiten durchzuführen.

<?php
class TestClass {
    function __destruct() {
        print "TestClass destructor is called.\n";
    }
}
 
$testObj = new TestClass();
unset($testObj);
print "Application will exit.\n";

Die laufenden Ergebnisse sind wie folgt:

Stephens-Air:Desktop$ php Test.php 
TestClass destructor is called.
Application will exit.

6. __Klon:

在PHP 5之后的版本中，对象之间的赋值为引用赋值，即赋值后的两个对象将指向同一地址空间，如果想基于对象赋值，可以使用PHP提供的clone方法。该方法将当前对象浅拷贝之后的副本返回，如果想在clone的过程中完成一些特殊的操作，如深拷贝，则需要在当前类的声明中实现__clone方法，该方法在执行clone的过程中会被隐式调用。另外需要格外注意的是，__clone方法是作用再被拷贝的对象上，即赋值后的对象上执行。

<?php
class InnerClass {
    public $id = 10;
    public function printSelf() {
        print &#39;$id = &#39;.$this->id."\n";
    }
}
 
class OuterClass {
    public $innerClass;
    public function __construct() {
        $this->innerClass = new InnerClass();
    }
    public function __clone() {
        $this->innerClass = clone $this->innerClass;
        print "__clone is called.\n";
    }
}
 
$outerA = new OuterClass();
print "Before calling to clone.\n";
$outerB = clone $outerA;
print "After calling to clone.\n";
$outerA->innerClass->id = 20;
print "In outerA: ";
$outerA->innerClass->printSelf();
print "In outerB: ";
$outerB->innerClass->printSelf();

运行结果如下：

Stephens-Air:Desktop$ php Test.php 
Before calling to clone.
__clone is called.
After calling to clone.
In outerA: $id = 20
In outerB: $id = 10

7. const:

PHP5可以在类中定义常量属性。和全局常量一样，一旦定义就不能改变。常量属性不需要像普通属性那样以$开头，按照惯例，只能用大写字母来命名常量。另外和静态属性一样，只能通过类而不能通过类的实例访问常量属性，引用常量时同样也不需要以$符号作为前导符。另外常量只能被赋值为基础类型，如整型，而不能指向任何对象类型。

<?php
class TestClass {
    const AVAILABLE = 0;
}
print "TestClass::AVAILABLE = ".TestClass::AVAILABLE."\n";

运行结果如下：

0Stephens-Air:Desktop$ php Test.php 
TestClass::AVAILABLE = 0

相关推荐：

PHP面向对象 静态延迟绑定static::

浅谈PHP面向对象编程

Das obige ist der detaillierte Inhalt vonCode über einige Methoden und Funktionsanwendungen in PHP objektorientiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!