Terangkan perbezaan antara diri ::, ibu bapa ::, dan statik :: dalam php oop.

Dalam php oop, diri :: merujuk kepada kelas semasa, ibu bapa :: merujuk kepada kelas induk, statik :: digunakan untuk mengikat statik lewat. 1. Self :: digunakan untuk kaedah statik dan panggilan berterusan, tetapi tidak menyokong pengikatan statik lewat. 2. Ibu bapa :: digunakan untuk subkelas untuk memanggil kaedah kelas induk, dan kaedah peribadi tidak dapat diakses. 3. Statik :: Menyokong pengikatan statik lewat, sesuai untuk warisan dan polimorfisme, tetapi boleh menjejaskan kebolehbacaan kod.

Pengenalan

Dalam pengaturcaraan berorientasikan objek PHP (OOP), adalah penting untuk memahami perbezaan antara self:: parent:: , dan static:: . Kata kunci ini memainkan peranan yang berbeza apabila berurusan dengan kelas dan objek, dan menguasai mereka dapat membantu anda menulis dan mengekalkan kod dengan lebih cekap. Dengan membaca artikel ini, anda akan belajar bagaimana menggunakan kata kunci ini dengan betul dalam senario yang berbeza dan memahami prinsip dan amalan terbaik di belakangnya.

Semak pengetahuan asas

Sebelum menggali kata kunci ini, mari kita semak beberapa konsep asas PHP OOP. Kelas dan objek PHP adalah teras OOP. Kelas menentukan satu set sifat dan kaedah, manakala objek adalah contoh kelas. Dalam kelas, kita sering perlu merujuk kepada kelas itu sendiri, kelas induk, atau konteks semasa, di mana self:: , parent:: , dan static:: bermain.

Konsep teras atau analisis fungsi

Definisi dan fungsi self::

self:: Kata kunci digunakan untuk merujuk kepada kelas semasa itu sendiri. Ia sering digunakan untuk panggilan untuk kaedah statik dan pemalar. Sebagai contoh, jika anda perlu memanggil kaedah statik lain di dalam kelas atau mengakses harta statik, anda boleh menggunakan self:: .

 kelas myclass {
    fungsi statik awam myMethod () {
        echo "Ini adalah mymethod";
    }

    fungsi statik awam lainMethod () {
        diri sendiri :: mymethod (); // panggil mymethod dalam kelas yang sama
    }
}

Kelebihan self:: adalah secara jelas merujuk kelas semasa, yang sangat berguna dalam konteks statik. Walau bagaimanapun, batasannya adalah bahawa ia tidak boleh digunakan untuk pengikatan statik lewat kerana ia selalu menunjuk kepada kelas yang mentakrifkannya, bukan kelas yang memanggilnya.

Definisi dan fungsi parent::

parent:: Kata kunci digunakan untuk merujuk kepada kelas induk. Ia digunakan dalam subkelas untuk memanggil kaedah kelas induk atau mengakses sifat kelas induk. Sebagai contoh, jika anda mahu memanggil kaedah kelas induk dalam subkelas, anda boleh menggunakan parent:: .

 kelas parentclass {
    fungsi awam myMethod () {
        echo "Ini adalah MyMethod Parentclass";
    }
}

Kelas Childlass memanjangkan ParentClass {
    fungsi awam myMethod () {
        ibu bapa :: myMethod (); // panggil mymethod kelas induk
        echo "Ini adalah MyMethod Childlass";
    }
}

Kelebihan parent:: adalah membolehkan anda mengatasi kaedah kelas induk sementara masih mempunyai akses kepada pelaksanaan kelas induk. Walau bagaimanapun, perlu diperhatikan bahawa jika kaedah kelas induk adalah peribadi, kelas kanak -kanak tidak akan dapat mengaksesnya menggunakan parent:: .

Definisi dan fungsi static::

Kata kunci static:: digunakan untuk mengikat statik lewat. Ia merujuk kepada kelas yang memanggilnya, bukan kelas yang mentakrifkannya. Ini menjadikannya sangat berguna dalam kaedah statik, terutamanya dalam senario warisan dan polimorfik.

 kelas parentclass {
    fungsi statik awam myMethod () {
        echo "Ini adalah MyMethod Parentclass";
    }
}

Kelas Childlass memanjangkan ParentClass {
    fungsi statik awam myMethod () {
        echo "Ini adalah MyMethod Childlass";
    }

    fungsi statik awam lainMethod () {
        statik :: myMethod (); // Panggilan adalah mymethod dari kelas kanak -kanak
    }
}

Kelebihan static:: ialah ia memberikan kelonggaran yang lebih besar untuk menentukan secara dinamik kaedah kaedah yang hendak dipanggil pada masa runtime. Walau bagaimanapun, ini juga boleh menyebabkan penurunan kebolehbacaan dan pemeliharaan kod, kerana panggilan kepada konteks statik mungkin kurang intuitif.

Contoh penggunaan

Penggunaan asas

Mari lihat beberapa contoh penggunaan asas:

 kelas myclass {
    public static $ myProperty = "Hello, World!";

    fungsi statik awam myMethod () {
        echo self :: $ myproperty;
    }
}

MyClass :: myMethod (); // output "Hello, dunia!"

 kelas parentclass {
    fungsi awam myMethod () {
        echo "parentclass";
    }
}

Kelas Childlass memanjangkan ParentClass {
    fungsi awam myMethod () {
        ibu bapa :: myMethod ();
        echo "anak kecil";
    }
}

$ child = New Childlass ();
$ anak-> myMethod (); // output "kelas kanak -kanak parentlass"

 kelas parentclass {
    fungsi statik awam myMethod () {
        echo "parentclass";
    }
}

Kelas Childlass memanjangkan ParentClass {
    fungsi statik awam myMethod () {
        echo "anak kecil";
    }

    fungsi statik awam lainMethod () {
        statik :: myMethod ();
    }
}

Kanak -kanak :: lainMethod (); // output "anak kecil"

Penggunaan lanjutan

Dalam senario yang lebih kompleks, kata kunci ini dapat membantu anda mencapai struktur kod yang lebih fleksibel. Sebagai contoh, dalam corak reka bentuk, static:: boleh digunakan untuk melaksanakan corak singleton:

 kelas singleton {
    contoh $ statik peribadi;

    fungsi yang dilindungi __construct () {}

    fungsi statik awam getInstance () {
        jika (null === static :: $ contoh) {
            statik :: $ instance = statik baru ();
        }
        kembali statik :: $ contoh;
    }
}

Concretesingleton kelas memanjangkan singleton {}

$ singleton1 = concretesingleton :: getInstance ();
$ singleton2 = concretesingleton :: getInstance ();

var_dump ($ singleton1 === $ singleton2); // output bool (benar)

Kesilapan biasa dan tip debugging

Kesalahan biasa apabila menggunakan kata kunci ini termasuk:

• Apabila menggunakan self:: , ia tersilap berfikir bahawa ia akan melakukan pengikatan statik lewat, mengakibatkan kaedah kelas yang salah dipanggil.
• Apabila menggunakan parent:: Dalam subkelas, lupa bahawa kaedah kelas induk boleh diswastakan, mengakibatkan tidak dapat diakses.
• Apabila menggunakan static:: , kebolehbacaan kod berkurangan dan sukar untuk mengesan kelas panggilan sebenar.

Kaedah untuk menyahpepijat masalah ini termasuk:

• Gunakan alat penyahpepijatan IDE untuk melihat timbunan panggilan dan sahkan kelas dan kaedah panggilan sebenar.
• Tambah log atau maklumat debug ke kod untuk membantu mengesan aliran pelaksanaan.
• Baca dokumentasi PHP dengan teliti untuk memahami tingkah laku dan batasan kata kunci tertentu.

Pengoptimuman prestasi dan amalan terbaik

Dari segi pengoptimuman prestasi, self:: dan parent:: biasanya tidak menyebabkan perbezaan prestasi yang signifikan, kerana mereka sudah menentukan kelas panggilan pada waktu penyusunan. Walau bagaimanapun, static:: mungkin mempunyai beberapa prestasi overhead kerana keperluan untuk mengikat statik lewat pada masa runtime.

Amalan terbaik termasuk:

• Dalam konteks statik, cuba gunakan self:: atau static:: Daripada secara langsung menggunakan nama kelas, yang dapat meningkatkan pemeliharaan kod.
• Dalam subkelas, jika anda perlu memanggil kaedah kelas induk, parent:: lebih disukai, supaya niat dapat dinyatakan secara eksplisit.
• Dalam corak reka bentuk atau senario di mana pengikatan statik lewat diperlukan, gunakan static:: , tetapi perhatikan kebolehbacaan dan pemeliharaan kod.

Dengan memahami dan menggunakan self:: , parent:: , dan static:: , anda dapat memahami dengan lebih baik intipati php oop dan menulis lebih efisien dan mudah untuk mengekalkan kod.

Atas ialah kandungan terperinci Terangkan perbezaan antara diri ::, ibu bapa ::, dan statik :: dalam php oop.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!