Klassenstruktur: Die internen Funktionen einer Klasse können drei Dinge haben, nämlich Konstanten, Eigenschaften und Methoden. Funktionen können als Konstanten, Variablen und Funktionen außerhalb der Klasse verstanden werden.
Der Code lautet wie folgt:
<?php
class TEST
{
const NAME = 'value'; // 常量
public $name = 'value'; // 属性
public function name() // 方法
{
echo 'value';
}
}
?>
Dabei können Eigenschaften und Methoden drei verschiedene Schlüsselwörter verwenden: public, protected und private, um die Funktionen von Eigenschaften und Methoden zu kombinieren Der Gültigkeitsbereich wird weiter unterschieden. Eigenschaften und Methoden mit dem Schlüsselwort „private“ können nur von Methoden in der Klasse aufgerufen werden, in der sie sich befinden. Eigenschaften und Methoden mit dem Schlüsselwort „protected“ können von Methoden in ihrer eigenen übergeordneten Klasse und Unterklasse aufgerufen werden Es kann auch nach der Instanziierung mit dem Schlüsselwort public aufgerufen werden. Der größte Vorteil besteht darin, dass es allen Eigenschaften und Methoden einige beschreibende Funktionen hinzufügt, was die Organisation und Organisation des Codes erleichtert . Struktur. Das Schlüsselwort const wird zuerst übersprungen und später zusammen mit static besprochen.
Das statische Schlüsselwort ist ein weiterer Schlüsselworttyp, der sich von „public“, „protected“ und „private“ unterscheidet (es kann also in Kombination mit „public“, „protected“ und „private“ verwendet werden):
Der Code lautet wie folgt:
<?php
class TEST
{
public static function name()
{
echo 'value';
}
}
?>
Methoden mit dem Schlüsselwort static können direkt über das Symbol „::“ aufgerufen werden, ohne die Klasse zu instanziieren, und werden mit public, protected und private kombiniert , Sie können den Aufruf auch Berechtigungen unterscheiden lassen, aber er wird normalerweise mit public gepaart. Das oben erwähnte konstante Schlüsselwort const sollte vom öffentlichen statischen Typ sein, sodass Konstanten nur über self::NAME, TEST::NAME aufgerufen werden können Die folgenden Methoden sind __construct, __destruct und andere statisch.
Im Strukturteil der Klasse sind die letzten beiden eingeführten Schlüsselwörter „abstract“ und „final“. Das Schlüsselwort „abstract“ gibt an, dass diese Klasse von ihren Unterklassen überschrieben werden muss, und das Schlüsselwort „final“ gibt an, dass diese Klasse nicht überschrieben werden darf Durch die Unterklassenüberschreibung sind die Funktionen dieser beiden Schlüsselwörter genau entgegengesetzt. Methoden mit abstrakten Methoden werden als abstrakte Klassen bezeichnet. Es gibt zwei Hauptmöglichkeiten, die
-Klasse zu verwenden: Es gibt zwei Hauptmöglichkeiten, die
-Klasse zu verwenden: Eine besteht darin, das neue Schlüsselwort zu verwenden, die andere darin, das „::“ zu verwenden. Symbol:
PHP-Code
Der Code lautet wie folgt:
<?php
class TEST
{
public static function name()
{
echo 'value';
}
}
//方法1：使用new关键字
$test = new TEST;
$test->name();
//方法2：使用“::”符号
TEST::name();
?>
(1): Verwenden Sie das neue Schlüsselwort, um zu werden Eine Instanziierung. Das obige $test ist eine TEST-Klasse. Für durch Instanziierung generierte Objekte wird $test->name() als Namensmethode des $test-Objekts bezeichnet.
(2): Wenn Sie das Schlüsselwort new zur Verwendung einer Klasse verwenden, können Sie mit $this auf die Klasse selbst verweisen.
(3): Voraussetzung für die Verwendung des Symbols „::“ ist, dass die Methode das Schlüsselwort „statisch“ haben muss öffentliches Schlüsselwort, geschützt, privat, der Standardwert ist öffentlich)
(4): Dieselbe Klasse kann über das neue Schlüsselwort in mehrere verschiedene Objekte instanziiert werden, diese sind jedoch voneinander isoliert Wird die Methode verwendet, wird sie von mehreren Benutzern gemeinsam genutzt:
PHP-Code
Der Code lautet wie folgt:
<?php
class TEST1
{
public $name = 0;
public function name()
{
$this->name = $this->name + 1;
}
}
$test1 = new TEST1;
$test2 = new TEST1;
$test1->name(); //$name1 == 1
$test2->name(); //$name1 == 1
/*--------------------------------------------*/
class TEST2
{
public static $name = 0;
public static function name()
{
TEST2::$name = TEST2::$name + 1;
}
}
TEST2::name(); // $name == 1
TEST2::name(); // $name == 2
?>Beziehung zwischen Klassen:
Die Beziehung zwischen Klassen umfasst hauptsächlich Abstraktion, Schnittstelle und Vererbung:
PHP-Code
Der Code lautet wie folgt:
<?php
abstract class TEST1 // 抽象
{
abstract public function name1();
public function name2()
{
}
}
class TEST2 extends TEST1 implements TEST3 // 继承
{
public function name1()
{
}
}
interface TEST3 // 接口
{
public function name2();
}
?>
(1) Klassen mit dem Schlüsselwort abstract sind abstrakte Klassen, und Methoden mit dem Schlüsselwort abstract sind abstrakte Methoden. Abstrakte Methoden in abstrakten Klassen müssen in Unterklassen überschrieben werden.
(2) Eine Klasse mit dem Schlüsselwort interface ist eine Schnittstelle. Es ist nicht zulässig, dass alle Methoden in der Schnittstelle in Unterklassen überschrieben werden.
(3) Die Worte „KlasseA erweitert KlasseB“ oder „KlasseA implementiert KlasseB“ bedeuten, dass eine andere Klasse geerbt wird, und „implementiert“ bedeutet, dass eine andere Schnittstelle geerbt wird. Es kann jedoch jeweils nur eine Klasse erweitert werden, es können jedoch mehrere Schnittstellen implementiert werden.
(4) Abstrakte Klassen, Schnittstellen und letztendlich geerbte und implementierte Methoden müssen öffentlich sein.
Während des Vererbungsprozesses überschreibt die Unterklasse die Methode der übergeordneten Klasse mit demselben Namen. Wenn Sie zu diesem Zeitpunkt die Methode der übergeordneten Klasse in der Unterklasse aufrufen müssen, können Sie die übergeordnete Klasse verwenden Schlüsselwort oder der Klassenname plus ":: "Symbolaufruf:
PHP-Code
Der Code lautet wie folgt:
<?php
class TEST1 extends TEST2
{
public function name()
{
echo parent::name2();
echo TEST2::name2();
}
}
class TEST2
{
public function name2()
{
echo 'value2';
}
}
$test = new TEST1;
$test->name();
?>
Hier ist eine weitere Erklärung der Methode „::“ in der Klasse. Unter den Funktionen besteht eine darin, Konstanten aufzurufen (eigentlich kann sie auch als statisch verstanden werden), statische Eigenschaften und Methoden ohne Instanziierung, und die andere darin, bequem zu erstellen diejenigen innerhalb der Klasse über den Kanal „Selbst“, „Eltern“ und „Klasse“.
Die Beziehung zwischen Objekten ist hauptsächlich "==" gleich, "===" alle gleich, nicht gleich und Klon:
PHP-Code
<?php
class TEST
{
public function name()
{
}
}
$test1 = new TEST;
$test2 = new TEST;
$test3 = $test1;
echo $test1 == $test2 ? true : false; // true
echo $test1 == $test3 ? true : false; // true
echo $test2 == $test3 ? true : false; // true
echo $test1 === $test2 ? true : false; // false
echo $test1 === $test3 ? true : false; // true
echo $test2 === $test3 ? true : false; // false
?>（1）两个类只要拥有相同的属性和方法，就是“==”等于。
（2）两个类必须是指向的同一个对象，才能是“===”全等于。
clone比较特殊，在上面的例子中，$test3 = $test1的过程并不是给了 $test3 一份 $test1 对象的拷贝，而是让 $test3 指向了 $test1，如果一定要获得一份$test1的拷贝，就必须使用clone关键字：
PHP代码
代码如下:
<?php $test3 = clone $test1; ?>
类的钩子：
__autoload：
是一个函数名，也是唯一一个在类的外部使用的钩子，在实例化一个对象的时候，如果没有预先载入类，就会调用这个钩子。
__construct
在类被实例话的时候，被调用的钩子，可以做一些初始化的操作。
__destruct
在类被销毁的时候，被调用的钩子。
__call
当对象试图调用一个不存在的方法的时候，被调用的钩子
__sleep
当使用serialize()函数对一个类进行序列话操作的时候，会调用这个钩子
__wakeup
当使用unserialize()函数对一个类进行反序列话操作的时候，会调用这个钩子
__toString
当一个对象将被转变为字符串的时候，会调用这个钩子（比如echo的时候）
__set_state
当调用var_export()函数操作一个类的时候，会调用这个钩子
__clone
当使用clone关键字对一个类进行拷贝操作的时候，会调用这个钩子
__get
在获取一个类中的属性值的时候，会调用这个钩子
__set
在设置一个类中的属性值的时候，会调用这个钩子
__isset
在使用isset()函数对类中的属性值进行判定的时候，会调用这个钩子
__unset
在使用unset()函数销毁一个属性值的时候，会调用这个钩子
类的小技巧：
在实例话一个类的时候，可以使用这样的形式给__construct钩子传递参数：
PHP代码
代码如下:
<?php
class TEST
{
public function __construct($para)
{
echo $para;
}
}
$test = new TEST('value'); // 显示 value
?>
foreach()函数可以用来对类或者对象中的属性进行遍历，遍历的时候会先判断public, protected, private的情况而显示：
PHP代码
代码如下:
<?php
class TEST
{
public $property1 = 'value1';
public $property2 = 'value2';
public $property3 = 'value3';
public function name()
{
foreach($this as $key => $value)
{
print "$key => $value\n";
}
}
}
$test = new TEST;
foreach($test as $key => $value)
{
print "$key => $value\n";
}
$test->name();
?>
在给类中的方法传递参数的时候，可以对参数进行强制的判定，这里只支持对数组和对象的判定：
PHP代码
代码如下:
<?php
class TEST1
{
public function name( TEST2 $para )
{
}
}
class TEST2
{
}
$test2 = new TEST2;
$test1 = new TEST1;
$test1->name('value'); // 会报错，因为这个参数必须是TEST2实例化以后的对象
$test1->name($test1); // 不会报错
?>
兼容php4的语法：
php5的类是往下兼容php4的，这些php4时代的语法也得到了继承，但是并不建议在php5的环境中使用。
（1）使用var预设属性，会自动转换成public。
（2）使用类名作为构造函数，在没有__construct构造方法的情况下，会寻找和类名相同的函数作为构造函数。
Das obige ist der detaillierte Inhalt vonwie man Klassen in PHP lernt. 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
