Kaedah Overloading dalam PHP

Metode Overloading ialah satu jenis Overloading selain daripada Property Overloading. Ia adalah untuk mencipta satu/banyak kaedah dinamik yang tidak dibuat dalam skop/skop kelas tersebut. Konsep kelebihan beban kaedah PHP juga membantu mencetuskan kaedah ajaib yang ditentukan untuk tujuan yang sesuai. Selain daripada konsep kelebihan beban harta, konsep kelebihan muatan kaedah PHP membenarkan panggilan/panggilan fungsi pada kedua-dua objek dan konteks statik. Pada asasnya adalah salah satu kaedah OOP.

IKLAN Kursus Popular dalam kategori ini PEMBANGUN PHP - Pengkhususan | 8 Siri Kursus | 3 Ujian Olok-olok

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Sintaks:

Public _call (string $name1 , array $arguments1 ) : mixed
Public static _callStatic (string $name1 , array $arguments1 ) : mixed

Bagaimana Method Overloading berfungsi dalam PHP?

Method Overloading berfungsi dengan pengisytiharan di dalam kelas dengan mencipta kaedah dinamik. Ia juga berfungsi dengan mencetuskan beberapa kaedah ajaib untuk tujuan yang sesuai dan memanggil fungsi/fungsi panggilan pada kedua-dua konteks statik dan objek. Konsep Method Overloading juga bagus dengan kebanyakan bahasa pengaturcaraan lain seperti c, java, dll. Kami merujuk kepada Method Overloading sebagai polimorfisme statik.

Terdapat beberapa fungsi ajaib iaitu:

• _call(): Konteks objek boleh mencetuskan pelaksanaan kaedah terlebih beban menggunakan fungsi call().
• _callStatic(): Fungsi ajaib callstatic() mengaktifkan konsep/kaedah yang terlebih beban dalam konteks statik.

Contoh Kaedah Lebih Muatan dalam PHP

Berikut ialah contoh Method Overloading dalam PHP yang dinyatakan di bawah

Contoh #1

Argumen $name1, dalam bahasa pengaturcaraan PHP di bawah, ialah nama kaedah yang akan dipanggil, manakala $arguments ialah salah satu tatasusunan terhitung yang mengandungi parameter/argumen yang digunakan untuk dihantar ke kaedah $name' ed.

Fungsi

_call() digunakan menggunakan 2 parameter $name1 dan $arguments1. Fungsi Implode() mengembalikan rentetan daripada elemen tatasusunan, iaitu, daripada rentetan/ayat. Dalam Implode(separator, array), pemisah ialah parameter pilihan, tetapi ia hanyalah cadangan untuk menggunakan kedua-dua parameter untuk keserasian ke belakang. Jenis pemisah tertentu dalam parameter pemisah akan memasukkan pemisah kepada perkataan/rentetan yang terdapat dalam parameter tatasusunan.

Pembolehubah Obj akan mencipta objek baharu yang dipanggil SPK. Obj-> akan membantu untuk mengakses kaedah dan sifat objek. Spk akan melaksanakan daripada konteks statik, manakala obj akan dijalankan daripada konteks objek.

Kod:

<?php
class SPK {
public function __call($name1, $arguments1) {
echo "object method calling '$name1' "
. implode(', ', $arguments1). "\n";
}
public static function __callStatic($name1, $arguments1) {
echo "static method Calling '$name1' "
. implode(', ', $arguments1). "\n";
}
}
// Create new object
$obj = new SPK;
$obj->runTest('in one of the object context');
SPK::runTest('in one of the static context');
?>

Output:

Contoh #2

Contoh kod mentakrifkan kelas foo1 dengan satu fungsi _call() yang melaksanakan fungsi die() untuk memaparkan mesej dan menamatkan skrip PHP semasa. Die() adalah sama dengan fungsi exit(), yang menerima hanya satu parameter di dalam kurungannya.

Foo1-> akan membantu untuk mengakses kaedah dan sifat objek daripada pembolehubah $foo1.

Kod:

<?php
class Foo1 {
function __call($m1, $a1) {
die($m1);
}
}
$foo1 = new Foo1;
print $foo1->{' wow !'}();
// outputs ' wow !'
?>

Output:

Contoh #3

Ini ialah contoh kaedah terlebih muatan dalam bahasa pengaturcaraan PHP menggunakan fungsi call() dan kaedah persendirian/dilindungi.

Di sini memanggil kaedah persendirian/dilindungi dilakukan dengan mengakses melalui kesilapan menaip atau sebagainya.

Echo _METHOD_PHP_EOL akan mengembalikan jenis kaedah yang digunakan. Ia hanya menggunakan fungsi _call(), yang dijalankan daripada konteks objek.

Kod:

<?php
class TestMagicCallMethod1 {
public function foo1()
{
echo __METHOD__.PHP_EOL;
}
public function __call($method1, $args1)
{
echo __METHOD__.PHP_EOL;
if(method_exists($this, $method1))
{
$this->$method1();
}
}
protected function bar1()
{
echo __METHOD__.PHP_EOL;
}
private function baz1()
{
echo __METHOD__.PHP_EOL;
}
}
$test    =    new TestMagicCallMethod1();
$test->foo1();
$test->bar1();
$test->baz1();
?>

Output:

Contoh #4

Ini ialah program konsep fungsi call() dan call static(), yang digunakan untuk konsep overloading kaedah. Program PHP di bawah ini akan memanggil fungsi _call() dahulu sebelum fungsi _callstatic() dalam contoh.

Var dump() akan memberikan maklumat tentang pembolehubah dalam kurungan dalam PHP & beberapa bahasa pengaturcaraan berorientasikan objek lain. Selain daripada itu, semuanya sama, seperti contoh di atas.

Kod:

<?php
class A1 {
public function test1 () {
static::who();
A1::who();
self::who();
$this->who();
}
public static function __callStatic($a1, $b1) {
var_dump('A1 static');
}
public function __call($a1, $b1) {
var_dump('A1 call');
}
}
$a1 = new A1;
$a1->test1();
?>

Output:

Contoh #5

Ini ialah contoh fungsi _call(); jika kelas objek dipanggil dengan kaedah, yang tidak wujud pun, maka konsep fungsi _call() dipanggil dan bukannya kaedah.

Execute the _call() function to support the concept of method overloading through the dynamic area() method included in the PHP program below. The object’s behavior will vary depending on the parameters that pass to it.

Code:

<?php
class Shape1 {
const PI1 = 3.142 ;
function __call($name1,$arg1){
if($name1 == 'area1')
switch(count($arg1)){
case 0 : return 0 ;
case 1 : return self::PI1 * $arg1[0] ;
case 2 : return $arg1[0] * $arg1[1];
}
}
}
$circle1 = new Shape1();
echo $circle1->area1(3);
$rect1 = new Shape1();
echo $rect1->area1(8,6);
?>

Output:

Example #6

Here, the _call() and _callstatic() functions are used like in the 1^st example.

Code:

<?php
class Toys1
{
public function __call($name1,$pavan1){
echo "Magic method invoked while method overloading with object reference";
}
public static function __callStatic($name1,$pavan1){
echo "Magic method invoked while method overloading with static access";
}
}
$objToys1 = new Toys1;
$objToys1->overloaded_method();
Toys1::overloaded_property();
?>

Output:

Example #7

The call () function of method Overloading triggered and invoked the inaccessible methods in the object context. Call() is mixed with the syntax _call(string $name1 , array $arguments1).

Then $name1 parameter is for the name of the method which is to be called, whereas the array $arguments1 is the parameter that is an enumerated array that contains/has the parameters which are to be passed to the $name variables method.

Code:

<?php
class ABC1 {
public function __call($method_name1, $arguments1) {
$methodArray1 = array('displayMessage11','displayMessage12');
if (in_array($method_name1,$methodArray1) === false) {
die("\n Method does not exist");
}
if (count($arguments1) === 2) {
$this->displayMessage12($arguments1[0],$arguments1[1]);
}
elseif (count($arguments1) === 1) {
$this->displayMessage11($arguments1[0]);
} else {
echo "\n unknown method";
return false;
}
}
function displayMessage11($var11) {
echo "\n from func1($var11)";
}
function displayMessage12($var11,$var12) {
echo "\n from func2($var11,$var12)";
}
}
$obj1 = new ABC1;
$obj1->displayMessage11('hello');
$obj1->displayMessage12('hello','hello2');
$obj1->displayMessage13('Hello');
?>

Output:

Example #8

It is also just like the first example program. Check it once.

Code:

<?php
class MethodOverloading1
{
public function __call($name1,$pavan1){
echo "\n--It is now With the object reference ";
}
public static function __callStatic($name1,$pavan1){
echo "\n-----It is now With the static reference \n";
}
}
// Here now creating the object of the class " MethodOverloading "
$obj1 = new MethodOverloading1;
echo "Method Overloading1 Now in Command ";
// Now using the object's reference
$obj1->DemoTest1();
// Now using the static's reference
MethodOverloading1::DemoTest1();
?>

Output:

Example #9

This program shows the area of the circle and rectangle using some parameters and the call() function of the method overloading concept. The program will only run with the object context due to the object assigning an object variable to the class, etc.

Code:

<?php
class TDshape1 {
const Pi1 = 3.142 ;  // constant value
function __call($fname1, $argument1){
if($fname1 == 'area1')
switch(count($argument1)){
case 0 : return 0 ;
case 1 : return self::Pi1 * $argument1[0] ; // 3.14 * 15
case 2 : return $argument1[0] * $argument1[1];  // 5 * 11
}
}
}
$circle1 = new TDshape1();
echo "Area of the circle:".$circle1->area1(15); // display output of the area of circle
$rect1 = new TDshape1();
echo "\n Area of the rectangle:".$rect1->area1(5,11); // display output of the area of rectangle
?>

Output:

Atas ialah kandungan terperinci Kaedah Overloading dalam PHP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!