Inhalt in diesem Abschnitt erklärt
Vorwort
Im vorherigen Abschnitt haben wir die grundlegende Verwendung von objektorientiert eingeführt, das Wissen im vorherigen Abschnitt jedoch nicht In der Praxis gibt es immer noch Probleme, die nicht gelöst werden können. Wenn wir beispielsweise ein Ticket kaufen, gibt es eine Gesamtzahl von Stimmen (die das Attribut des Tickets definieren) und eine Person kommt, um ein Ticket zu kaufen (. Ticket-1), aber wir erstellen jedes Mal ein Objekt und die Methode im Speicher besteht darin, eine Gesamtzahl von Stimmen neu zu erstellen. Hier verwenden wir das Konzept der Statik Klassen in PHP:
Statische Eigenschaften
Statische Methoden
Statische Eigenschaften
Statische Eigenschaften sind von dieser Klasse. Eine Variable, die von allen Objekten gemeinsam genutzt wird. Wenn ein beliebiges Objekt dieser Klasse darauf zugreift, erhält es denselben Wert Wenn die Klasse sie ändert, wird auch dieselbe Variable geändert.
<?php
class Ticket{
public static $number = 100; //设置总的票数是100；
public $name ;
public function __construct($name){
$this-> name = $name;
}
//定义一个方法进行买票
public function sellTicket(){
echo $this-> name . '买票了<br>';
self::$number--; //每调用一次方法总票数就减一。
}
}
$people1 = new Ticket('小白');
$people2 = new Ticket('小明');
$people3 = new Ticket('小华');
$people4 = new Ticket('小张');
//每个人进行买票
$people1 -> sellTicket();
$people2 -> sellTicket();
$people3 -> sellTicket();
$people4 -> sellTicket();
echo Ticket::$number; //在类的外部通过类名访问静态属性。
......结果........
小白买票了
小明买票了
小华买票了
小张买票了
96Nach dem Login kopieren
Im obigen Code können Sie sehen, wie statische Eigenschaften definiert sind.
访问修饰符 static $静态属性名字 = 初始化值;
Nach dem Login kopieren
Statische Eigenschaften können nur innerhalb einer Klasse definiert werden.
Zugriff auf statische Eigenschaften
Außerhalb der Klasse
Wir können auch außerhalb der Klasse auf statische Eigenschaften in der Klasse zugreifen. wie oben geschrieben, direkter Zugriff über den Klassennamen (dies ist nur möglich, wenn der Berechtigungsmodifikator öffentlich ist) Ticket::$number wobei:: der Bereichsparser ist.
Auf statische Eigenschaften kann auch über Objekte außerhalb der Klasse zugegriffen werden
$people4::$number;
Nach dem Login kopieren
Der Zugriff über den Klassennamen erfolgt über den Bereichsparser::.
In der Klasse
Im obigen Code können wir sehen, dass wir in der Klasse über den Eigenschaftsnamen self::$static darauf zugreifen. Zusätzlich zu dieser Methode gibt es eine weitere Möglichkeit, in der Klasse darauf zuzugreifen.
Ticket::$number--;
Nach dem Login kopieren
Zugriff über den Klassennamen. Das empfohlene Format ist die Verwendung von self, da auf diese Weise bei einer Änderung unseres Klassennamens keine Änderung erforderlich ist. Was ist also der Unterschied zwischen self und $this?
Der Unterschied zwischen $this und self
Tatsächlich verweist $this, wie im vorherigen Abschnitt erwähnt, auf das aktuelle
Objekt und Hier zeigt self auf die aktuelle Klasse , einer zeigt auf das Objekt und der andere zeigt auf die Klasse, die auf verschiedene Punkte zeigen. Gleichzeitig werden sie auf unterschiedliche Weise verwendet: self is two::, $this is ->. Der Anwendungsbereich beider ist jedoch derselbe und sie werden beide innerhalb der Klasse verwendet.
Verwendung statischer Attribute
Oben haben wir nur erklärt, wie statische Attribute definiert und verwendet werden, wenn wir statische Attribute verwenden müssen. Wenn wir während der Projektentwicklung allen Objekten die gemeinsame Nutzung von Daten ermöglichen müssen, ziehen wir die Verwendung statischer Eigenschaften in Betracht.
Statisches Attribut ist ebenfalls ein Attribut, daher besteht der Unterschied zu gewöhnlichen Attributen darin:
- Attribut mit dem Schlüsselwort „statisch“ wird zu einem statischen Attribut.
- Statische Eigenschaften gehören zur Klasse und Eigenschaften, die von allen Objekten gemeinsam genutzt werden
- Gewöhnliche Eigenschaften gehören zu einem einzelnen Objekt.
Beachten Sie, dass wie oben beschrieben auf statische Eigenschaften mit nicht statischen Methoden zugegriffen werden kann. ;
Statische Methode
Wir haben oben über statische Eigenschaften gesprochen, also lasst uns als nächstes über statische Methoden sprechen.
<?php
class Ticket{
public static $number = 100; //设置总的票数是100；
public $name ;
public function __construct($name){
$this-> name = $name;
}
public static function sayHello(){
echo '这是静态方法<br>';
}
public function info(){
//在类的内部使用静态方法
self::sayHello(); //通过self访问
Ticket::sayHello();//通过类名的方式进行访问
}
}
$people1 = new Ticket('小白');
$people1 -> info();
$people1::sayHello(); //在类的外部通过对象名进行访问
Ticket::sayHello(); //通过类型进行访问。
......结果........
这是静态方法
这是静态方法
这是静态方法
这是静态方法Nach dem Login kopieren
Statische Methoden werden durch das Schlüsselwort static definiert:
访问修饰符 static function 方法名（参数列表）{
code....
}Nach dem Login kopieren
Zugriff auf statische Methoden
Außerhalb der Klasse
Die Zugriffsform statischer Methoden außerhalb der Klasse ist dieselbe wie die Methode des Zugriffs auf statische Eigenschaften (auf den Berechtigungsmodifikator kann nur extern zugegriffen werden, wenn er öffentlich ist).
- Zugriff über Klassennamen: :statischer Methodenname
- Zugriff über Objektnamen: :statischer Methodenname (nicht empfohlen)
- Nach Objektnamen ->statischer Methodenname. Das ist die Form der Zugriffsmethode.
In einer Klasse
Der Zugriff auf statische Methoden in einer Klasse ist derselbe wie der Zugriff auf statische Eigenschaften
- self::static method name
- class name::static method name
Nutzung von statische Methode
Unter welchen Umständen verwenden wir also statische Methoden? Wir können statische Methoden verwenden, wenn wir statische Eigenschaften bearbeiten.
- Wenn wir statische Attribute bedienen müssen, erwägen wir die Verwendung von
- In unserer PHP-Entwicklung verwenden wir häufig einige Muster, z. B. ein einzelnes Beispiel Modus, Fabrikmodus, Beobachtermodus usw. verwenden alle statische Methoden
Hinweis: Statische Methoden können nicht auf nicht statische Eigenschaften zugreifen
Zugriffsmodifikator
Im obigen Code und in der Beschreibung können wir sehen, dass sich vor der Eigenschaft oder vor der Methode ein öffentlicher Zugriffsmodifikator befindet von ihnen. Man kann sagen, dass Zugriffsmodifikatoren eine Methode zur Implementierung der Objektkapselung sind.
访问修饰符的分类及区别
在PHP中访问修饰符可以分为三中
public 在上面的代码中我们都是使用的public，使用这种这个关键字修饰的属性和方法，不管在类的内部还是在类的内部都是可以访问的。
protected(受保护的)如果使用这个关键字修饰，那么在类的外部是不能访问。只能在类的内部进行访问。
<?php
class Cat{
public $name;
protected $age;
public function __construct($name,$age){
$this -> name = $name;
$this -> age = $age;
}
}
$cat = new Cat('小白',4);
echo $cat -> name; //在类的外部访问public
echo '<br>';
echo $cat -> age; //在类的外部访问protected修饰的属性。
......结果.....
小白
Fatal error: Cannot access protected property Cat::$age in D:\mywamp\Apache24\htdocs\zendstudio\yunsuanfu\xiushifu.php on line 16Nach dem Login kopieren
错误的信息是说不能访问protected修饰的属性。
private(私有的),只能在类的内部使用，在外部使用会报和上面一样的错误。
这三种，后面两种看起来作用一样，都是只能在类内部使用，那又有什么区别呢？现在看来，并没有区别，但是学过类的继承，那么这两种还是有区别的。
访问修饰符的使用：
成员属性必须制定访问修饰符，不然会报错
方法前面可以不写修饰符，默认是public
静态属性可以不指定访问修饰符，默认是public
单例模式
上面讲解到我们什么时候使用到静态方法。在一些设计模式中，我们可以使用到静态方法和静态属性。
设计模式:是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。(百度)
在开发的时候，我们有这样的需求，在代码中我们创建一个对象，但是我们希望在一个项目中，这个对象实例只能有一个，不能创建多个对象，从而实现对数据库等资源的保护。这时候就使用到单例模式。
<?php
class DaoMysql{
public $link; //模拟数据库连接
private static $instance;//当前类的对象。
private function __construct(){
echo '数据库连接<br>';
}
public static function getInstance(){
if(self::$instance == null){
self::$instance = new DaoMysql();
}
return self::$instance;
}
public function insertSql(){
echo '添加数据<br>';
}
}
$daoMysql = DaoMysql::getInstance();
$daoMysql -> insertSql();
$daoMysql2 = DaoMysql::getInstance();
$daoMysql2 -> insertSql();
......结果.......
数据库连接
添加数据
添加数据Nach dem Login kopieren
1. 既然是单例模式，那么就不能在外部创建对象，这就要把构造函数用private修饰(创建对象要调用构造函数，这里把构造函数私有化，调用不起来)，这样在外部就不能创建对象。
2. 我们在类里面创建了一个对象的引用$instance，在类里面创建对象，这是允许的。
3. 在类中定义一个静态方法，我们就是通过这个方法来创建对象，通过类名::方法名进行创建，进去后先判断$instance是否为空，只有如空的时候我们才进行创建。然后返回对象。
4. 因为要在静态方法中访问属性，那么这个属性就应该是静态的属性。
5. 在类的外部通过类::静态方法名进行对象的创建。
6. 在结果中我们可以看到我们有两个对象，但是构造方法在第二次没有执行，说明对象没有创建。
虽然在上面我们做了很多限制，但是在PHP中还是有方法的到更过的对象，克隆和继承。
对象类型运算符
在上面的静态方法中判断对象是否创建还有一种方法。
if(!(self::$instance instanceof self)){
self::$instance = new DaoMysql();
}Nach dem Login kopieren
其中instanceof就是类型运算符。 根据帮助文档，它有几个作用
用于确定一个 PHP 变量是否属于某一类 class 的实例：
可用来确定一个变量是不是继承自某一父类的子类的实例：
也可用于确定一个变量是不是实现了某个接口的对象的实例:
上面的代码中self代表当前的类。instanceof判断前面的变量是否是后面类的实例，然后取反。
魔术方法
在PHP中有一些定义在类中的神奇的方法，称为魔术方法。具体的魔术的方法的使用可以看另外一篇博客
PHP的魔术方法
类的自动加载
在前面我们讲过文件的引入，使用include和require这两种类型。在开发中我们有时需要引入大量的文件，可以是10个，也可能是20个，如果还是使用原来的方法，累人。
在 PHP 5 中，不再需要这样了。可以定义一个 __autoload() 函数，它会在试图使用尚未被定义的类时自动调用。
而我们在写类的时候，一般都是一个类一个文件，而文件的名字我们一般是类名.class.php的格式。
<?php
//自动加载的方法，当我们使用这个文件不存在的类的时候，就会自动加载。
function __autoload($class_name){
require_once './' . $class_name . '.class.php';
}
$dao = new Dao('小白',5);
$cat = new Cat('小花',2);
$dao -> eat();
$cat -> eat();Nach dem Login kopieren
__autoload($类名)，在个函数不是写在类中的，所以前面是没有权限修饰符。
上面的自动加载方式是有局限性的，当文件是在不同的文件夹中的时候，这种方法显然是不行的。这时候可以创建一个数组，把类名当做键，对应的路径当成值，进行存储。自动加载的时候就能正确的引入。
<?php
$path = array(
'Dao' => './dao/Dao.class.php',
'Cat' => './cat/Cat.class.php'
);
//自动加载的方法，当我们使用这个文件不存在的类的时候，就会自动加载。
function __autoload($class_name){
global $path;
require_once $path[$class_name];
}
$dao = new Dao('小白',5);
$cat = new Cat('小花',2);
$dao -> eat();
$cat -> eat();Nach dem Login kopieren
可以看到在前面定义了一个数组用来存储路径。
注意：在函数中使用global声明一下，才能使用全局变量。
总结
在面向对象中用到静态属性和静态方法的时候还是很多的。同时权限修饰符在面向对象中是很重要的，因为我们通过修饰符控制访问权限。魔术方法的掌握，也可以让我们在访问中明白各种调理机制。
以上就是PHP基础教程十之静态属性和静态方法的内容，更多相关内容请关注PHP中文网（www.php.cn）！
