Rumah >pembangunan bahagian belakang >masalah PHP >Apakah kaedah statik php
Apakah kaedah statik php
- 藏色散人asal
- 2022-10-31 09:40:181981semak imbas
php statik "statik" dalam kaedah statik bermakna sifat dan kaedah ini boleh dipanggil secara langsung tanpa membuat instantiating kelas dan statik ialah kata kunci yang digunakan untuk mengubah suai sifat dan kaedah sintaks penggunaannya "kelas Foo {statik awam $my_static = 'hello';}".
Persekitaran pengendalian tutorial ini: sistem Windows 7, PHP versi 8.1, komputer Dell G3.
Penjelasan terperinci statik statik PHP
Atribut dan kaedah kelas PHP perlu dipanggil selepas kelas diwujudkan (kecuali atribut tetap), walau bagaimanapun, PHP juga menyediakan atribut statik dan kaedah statik Apa yang dipanggil "statik" bermakna sifat dan kaedah ini boleh dipanggil secara langsung tanpa membuat instantiating kelas. Bukannya kelas statik tidak boleh digunakan, tetapi ia boleh digunakan tanpa instantiasi.
Takrif ahli statik
Gunakan kata kunci statik untuk mengubah suai atribut dan kaedah kelas, dan panggil atribut dan kaedah ini sebagai atribut statik dan kaedah statik.
1. Atribut statik
Sintaks:
static 属性名
Contoh:
<?php
class Foo {
public static $my_static = 'hello';
}
?>
2.
Instance:static function 方法名{
//代码
}
Nota: Sifat dan kaedah statik adalah sama dengan sifat dan kaedah objek, menyokong tiga tetapan keterlihatan: <?php
class Foo {
public static function staticValue() {
return 'hello';
}
}
?>, dan private tahap. protectedpublicPanggilan ahli statik
1. Panggil sifat/kaedah statik di luar kelas
Panggil melalui
. 类名::属性/方法
<?php
class Mystatic {
public static $staticvalue = 'zhangsan';
public static function staticMethod() {
$a = 'hello';
return $a;
}
}
echo '$staticvalue: '.Mystatic::$staticvalue.PHP_EOL;
echo '$a: '.Mystatic::staticMethod().PHP_EOL;
?>
mewakili aksara baris baharu sistem. PHP_EOL Keputusan:
$staticvalue: zhangsan $a: hello
. 对象名::属性/方法
<?php
class Mystatic {
public static $staticvalue = 'zhangsan';
public static function staticMethod() {
$a = 'hello';
return $a;
}
}
$obj = new Mystatic();
echo '$staticvalue: '.$obj::$staticvalue.PHP_EOL;
echo '$a: '.$obj::staticMethod();
?>
dipanggil melalui $staticvalue: zhangsan $a: hello
, 对象名 -> 方法 akan gagal. 对象名 -> 属性
<?php
error_reporting(0);
class Mystatic {
public static $staticvalue = 'zhangsan';
public static function staticMethod() {
$a = 'hello';
return $a;
}
}
$obj = new Mystatic();
echo '$staticvalue: '.$obj -> staticvalue.PHP_EOL;
echo '$a: '.$obj -> staticMethod();
?>
2. Panggil sifat/kaedah statik dalam kaedah bukan statik $staticvalue: $a: hello
melalui
Apabila dipanggil , self::属性/方法sendiri menunjuk ke kelas semasa , sama seperti $this menunjuk ke objek semasa dan jika tiada instantiasi, menunjuk ke objek kosong $this, jadi anda tidak boleh menyentuhnya untuk merujuk sifat dan kaedah statik.
<?php
class Mystatic {
public static $staticvalue = 'zhangsan';
public static function staticMethod() {
$a = 'hello';
return $a;
}
public function noStatic(){
echo '$staticvalue: '.self::$staticvalue.PHP_EOL;
echo '$a: '.self::staticMethod();
}
}
$obj = new Mystatic();
$obj -> noStatic();
?>
3. Memanggil sifat/kaedah statik dalam kaedah statik $staticvalue: zhangsan $a: hello
adalah sama seperti memanggil sifat/kaedah statik dalam kaedah bukan statik .
Keputusan:<?php
class Mystatic {
public static $staticvalue = 'zhangsan';
public static function staticMethod1() {
$a = 'hello';
return $a;
}
public static function staticMethod2(){
echo '$staticvalue: '.self::$staticvalue.PHP_EOL;
echo '$a: '.self::staticMethod1().PHP_EOL;
}
}
Mystatic::staticMethod2();
$obj = new Mystatic();
$obj -> staticMethod2();
?>
4 Panggil sifat/kaedah statik kelas lain $staticvalue: zhangsan $a: hello $staticvalue: zhangsan $a: hello
Jika anda memanggil sifat statik dan kaedah kelas lain dalam satu. kelas , perlu dipetik melalui
. 完整类名::
<?php
class Mystatic1 {
public static $staticvalue1 = 'xiaomin';
}
class Mystatic2 {
public static $staticvalue2 = 'zhangsan';
public static function staticMethod() {
echo '$staticvalue1: '.Mystatic1::$staticvalue1.PHP_EOL;
echo '$staticvalue2: '.self::$staticvalue2.PHP_EOL;
}
}
Mystatic2::staticMethod();
$obj = new Mystatic2();
$obj -> staticMethod();
?>
5 Panggil $staticvalue1: xiaomin $staticvalue2: zhangsan $staticvalue1: xiaomin $staticvalue2: zhangsan,
sifat statik/kaedah tahap keterlihatan privateprotected disebabkan oleh
, <. sekatan atribut> hanya boleh dipanggil dalam kelas. Jika anda ingin memanggilnya di luar kelas, anda perlu menyediakan kaedah untuk kaedah di luar. Terminologi: Kelas menyediakan antara muka kepada dunia luar. privateprotectedpublicHasil: privateprotected
<?php
class Mystatic {
public static $staticvalue1 = 'zhangsan';
private static $staticvalue2 = 20;
protected static $staticvalue3 = 'student';
private static function staticMethod() {
$a = 'hello';
return $a;
}
public function port1() {
echo '$staticvalue1: '.self::$staticvalue1.PHP_EOL;
echo '$staticvalue2: '.self::$staticvalue2.PHP_EOL;
echo '$staticvalue3: '.self::$staticvalue3.PHP_EOL;
echo '$a: '.self::staticMethod().PHP_EOL;
}
public static function port2() {
echo '$staticvalue1: '.self::$staticvalue1.PHP_EOL;
echo '$staticvalue2: '.self::$staticvalue2.PHP_EOL;
echo '$staticvalue3: '.self::$staticvalue3.PHP_EOL;
echo '$a: '.self::staticMethod().PHP_EOL;
}
}
$obj = new Mystatic();
$obj -> port1();
echo "\r\n";
Mystatic::port2();
?>
Dalam aplikasi sebenar, akan terdapat berbilang objek kelas, yang mungkin berkongsi sekeping data . Kedua-dua pemalar kelas dan sifat statik boleh dilaksanakan. Sifat statik adalah serupa (sama) dengan pemalar kelas, satu-satunya perbezaan ialah pemalar kelas tidak boleh diubah, manakala sifat statik boleh diubah. Kaedah capaian adalah sama dan boleh diakses menggunakan
. Sifat statik perlu menambah $, dan tiada $ sebelum nama tetap, jadi tidak perlu menambahnya apabila mengakses pemalar kelas.$staticvalue1: zhangsan $staticvalue2: 20 $staticvalue3: student $a: hello $staticvalue1: zhangsan $staticvalue2: 20 $staticvalue3: student $a: hello
1. Pemalar kelas
::Keputusan:
<?php
class Myconst {
const A = 1234;
}
$obj1 = new Myconst();
echo 'A: '.$obj1::A.PHP_EOL;
$obj1->A='aaa';
//$obj1::A='aaa';会报错
echo "\r\n";
$obj2 = new Myconst();
echo 'A: '.$obj2::A.PHP_EOL;
?>
Hasil: A: 1234 A: 1234
Pewarisan dan penggantian ahli statik
<?php
class Mystatic {
public static $A = 1234;
}
echo '$A: '.Mystatic::$A.PHP_EOL;
Mystatic::$A = 6666;
echo '$A: '.Mystatic::$A.PHP_EOL;
$obj1 = new Mystatic();
echo '$A: '.$obj1::$A.PHP_EOL;
Mystatic::$A = 5555;
$obj2 = new Mystatic();
echo '$A: '.$obj2::$A.PHP_EOL;
echo '$A: '.$obj1::$A.PHP_EOL;
?>Seperti sifat/kaedah bukan statik, sifat dan kaedah statik juga boleh diwarisi oleh subkelas, dan sifat dan kaedah statik juga boleh ditindih oleh subkelas. 1. Atribut statik $A: 1234 $A: 6666 $A: 6666 $A: 5555 $A: 5555
Subkelas boleh mengatasi pembolehubah ahli statik kelas induk, tetapi pembolehubah statik kelas induk ini adalah bebas dipanggil mengikut panggilan Nama kelas diakses secara berasingan.
Keputusan:2. Kaedah statik
<?php
class Mystatic
{
static public $a; //定义一个静态变量
static function test() //定义静态方法来操作并输出静态变量
{
self::$a++;
return self::$a;
}
}
class Mystatic2 extends Mystatic //定义一个子类
{
static function test() //定义子类的静态方法
{
self::$a++; //访问并操作父类的静态变量
return self::$a;
}
}
$obj1=new Mystatic; //新建父类对象
echo '此时$a的值为: '.$obj1->test().PHP_EOL; //通过对象调用静态方法test,静态属性$a的值+1
$obj2=new Mystatic; //新建另一个父类对象
echo '此时$a的值为: '.$obj2->test().PHP_EOL; //新父类对象调用静态方法test,静态属性$a的值+1+1
$obj3=new Mystatic2; //新建子类对象
echo '此时$a的值为: '.$obj3->test().PHP_EOL; //子类对象调用同名静态方法test, 静态属性$a的值+1+1+1
echo Mystatic::$a.PHP_EOL; //通过父类::直接访问静态成员$a变量
echo $obj1::$a.PHP_EOL; //通过对象名::可以直接访问静态成员$a变量
?>Subkelas boleh mengatasi kaedah statik kelas induk.
此时$a的值为: 1 此时$a的值为: 2 此时$a的值为: 3 3 3Anda boleh mendapatkan nama kelas kelas semasa melalui
Kami memanggil kaedah
dua kelas masing-masing: Keputusan:<?php
class Mystatic1 {
public static function getclassName() {
return __CLASS__;
}
public static function whoclassName() {
echo self::getclassName().PHP_EOL;
}
}
class Mystatic2 extends Mystatic1{
public static function getclassName() {
return __CLASS__;
}
}
echo Mystatic1::getclassName().PHP_EOL;
echo Mystatic2::getclassName().PHP_EOL;
?>
Ini bermakna subkelas mengatasi kaedah statik dengan nama yang sama bagi kelas induk Begitu juga, kita juga boleh memanggil kaedah __CLASS__ dalam kelas induk pada subkelas: getClassName
Keputusan:
Mystatic1 Mystatic2
Mengapakah hasil cetakan kedua nama kelas induk whoclassName bukannya nama subkelas
<?php
class Mystatic1 {
public static function getclassName() {
return __CLASS__;
}
public static function whoclassName() {
echo self::getclassName().PHP_EOL;
}
}
class Mystatic2 extends Mystatic1{
public static function getclassName() {
return __CLASS__;
}
}
echo Mystatic1::whoclassName();
echo Mystatic2::whoclassName();
?> sentiasa menghala ke objek rujukan yang memegangnya dan menghala ke
bukannyaMystatic1 Mystatic1Untuk menyelesaikan masalah ini, bermula dari PHP 5.3, penunjuk baharu dipanggil
Ciri pengikatan statik tertundaMystatic1. Mystatic2
延迟静态绑定
延迟静态绑定（Late Static Bindings）针对的是静态方法的调用，使用该特性时不再通过 <span style="background-color:#fe2c24;">self::</span> 引用静态方法，而是通过 static::，如果是在定义它的类中调用，则指向当前类，此时和 self 功能一样，如果是在子类或者其他类中调用，则指向调用该方法所在的类。
<?php
class Mystatic1 {
public static function getclassName() {
return __CLASS__;
}
public static function whoclassName() {
echo static::getclassName().PHP_EOL;
}
}
class Mystatic2 extends Mystatic1{
//self改为static
public static function getclassName() {
return __CLASS__;
}
}
echo Mystatic1::whoclassName();
echo Mystatic2::whoclassName();
?>
结果：
Mystatic1 Mystatic2
表明后期静态绑定生效，即 static 指向的是调用它的方法所在的类，而不是定义时，所以称之为延迟静态绑定。
此外，还可以通过 static::class 来指向当前调用类的类名，例如我们可以通过它来替代 __CLASS__，这样上述子类就没有必要重写 getClassName 方法了：
<?php
class Mystatic1 {
public static function getclassName() {
return static::class;
}
public static function whoclassName() {
echo static::getclassName().PHP_EOL;
}
}
class Mystatic2 extends Mystatic1{}
echo Mystatic1::getclassName().PHP_EOL;
echo Mystatic2::getclassName().PHP_EOL;
echo Mystatic1::whoclassName();
echo Mystatic2::whoclassName();
?>
结果：
Mystatic1 Mystatic2 Mystatic1 Mystatic2
同理，self::class 则始终指向的是定义它的类。
静态与非静态的区别
静态属性和方法可以直接通过类引用，所以又被称作类属性和类方法。非静态属性和非静态方法需要实例化后通过对象引用，因此被称作对象属性和对象方法。
静态属性保存在类空间，非静态属性保存在对象空间。非静态方法可以访问类中的任何成员(包括静态)，静态方法只能访问类中的静态成员。
静态方法可以直接调用，类名调用和对象调用（
类名或self：：调用），但是非静态方法只能通过对象调用（对象名或$this->调用）。一个类的所有实例对象，共用类中的静态属性。如果修改了这个类静态属性，那么这个类的所有对象都能访问到这个新值。
静态方法和属性的生命周期跟相应的类一样长，静态方法和静态属性会随着类的定义而被分配和装载入内存中。一直到线程结束，静态属性和方法才会被销毁。 非静态方法和属性的生命周期和类的实例化对象一样长，只有当类实例化了一个对象，非静态方法和属性才会被创建，而当这个对象被销毁时，非静态方法也马上被销毁。静态方法和静态变量创建后始终使用同一块内存，而使用实例的方式会创建多个内存。但静态方法效率上要比实例化高，静态方法的缺点是不自动进行销毁，而实例化的则可以做销毁。
应用场景：
静态方法最适合工具类中方法的定义；比如文件操作，日期处理方法等.
静态变量适合全局变量的定义.
推荐学习：《PHP视频教程》
Atas ialah kandungan terperinci Apakah kaedah statik php. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!