php - PHP中看起来像多态的东西真的是多态吗？

Question

试图弄清楚 PHP 是否支持方法重载、继承和多态等特性，我发现：

• 它不支持方法重载
• 它确实支持继承

但我不确定多态性。我发现这个谷歌搜索互联网：

我应该注意到，在 PHP 中，多态性并不是它应该的样子。我的意思是它确实有效，但由于我们的数据类型很弱，所以它不正确。

那么它真的是多态性吗？

编辑 只是不能在PHP supports polymorphism. 我不愿意说：“PHP 不支持多态性”，而实际上它确实支持。或相反亦然。

Answer 1

class Animal {
    var $name;
    function __construct($name) {
        $this->name = $name;
    }
}

class Dog extends Animal {
    function speak() {
        return "Woof, woof!";
    }
}

class Cat extends Animal {
    function speak() {
        return "Meow...";
    }
}

$animals = array(new Dog('Skip'), new Cat('Snowball'));

foreach($animals as $animal) {
    print $animal->name . " says: " . $animal->speak() . '<br>';
}

你可以随心所欲地给它贴上标签，但这对我来说看起来像是多态性。

Answer 2

尽管 PHP 不支持您在其他语言（例如 Java）中体验过的方法重载。但是您可以在 PHP 中进行方法重载，但定义方法不同。如果您想为给定的方法提供不同的功能，在 PHP 中使用不同的参数集，您可以执行以下操作：

class myClass {
    public function overloadedMethod() {
        // func_num_args() is a build-in function that returns an Integer.
        // the number of parameters passed to the method.
        if ( func_num_args() > 1 ) {
            $param1 = func_get_arg(0);
            $param2 = func_get_arg(1);
            $this->_overloadedMethodImplementation2($param1,$param2)
        } else {
            $param1 = func_get_arg(0);
            $this->_overloadedMethodImplementation1($param1)
        }
    }

    protected function _overloadedMethodImplementation1($param1) {
        // code 1
    }

    protected function _overloadedMethodImplementation2($param1,$param2) {
        // code 2
    }
}

可能会有更干净的实现，但这只是一个示例。

PHP 支持继承和接口。所以你可以使用它们进行多态性。你可以有一个这样的界面：

// file: MyBackupInterface.php
interface MyBackupInterface {
    // saves the data on a reliable storage
    public function saveData();
    public function setData();
}

// file: myBackupAbstract.php
require_once 'MyBackupInterface.php';
class MyBackupAbstract implements MyBackupInterface {
     protected $_data;
     public function setData($data) {
         $this->_data= $data;
     }
     // there is no abstract modifier in PHP. so le'ts avoid this class to be used in other ways
     public function __construct() {
          throw new Exception('this class is abstract. you can not instantiate it');
     }
}

// file: BackupToDisk.php
require_once 'MyBackupAbstract.php';
class BackupToDisk extends MyBackupAbstract {
     protected $_savePath;

     // implement other methods ...

     public function saveData() {
           // file_put_contents() is a built-in function to save a string into a file.
           file_put_contents($this->_savePath, $this->_data);
     }
}

// file: BackupToWebService.php
require_once 'MyBackupAbstract.php';
class BackupToWebService extends MyBackupAbstract {
     protected $_webService;
     // implement other methods ...

     public function saveData() {
           // suppose sendData() is implemented in the class
           $this->sendData($this->_data);
     }
}

现在在您的应用程序中，您可以像这样使用它：

// file: saveMyData.php
// some code to populate $myData
$backupSolutions = array( new BackupToDisk('/tmp/backup') , new BackupToWebService('webserviceURL') );
foreach ( $backupSolutions as $bs ) {
    $bs->setData($myData);
    $bs->saveData();
}

你是对的，PHP 不是强类型语言，我们从未提到你的任何 $backupSolutions 将是“MyBackupAbstract”或“MyBackupInterface”，但这不会阻止我们具有多态性的性质，这是与使用不同的功能相同的方法。

Answer 3

PHP 具有基于类的多态性，但缺乏实现基于参数的多态性的正式机制。

基于类的多态性意味着您可以根据基类进行思考，并且调用的方法取决于最终类。例如，如果您有一个包含各种类（如 Triangle 和 Circle）的对象的数组，并且这些类中的每一个都扩展了同一个类 Shape，那么您可以将您的数组视为仅仅是形状的集合。您可以遍历形状并调用每个形状的 getArea() 方法。多态性是调用 getArea() 方法取决于对象的类的现象。如果您的形状是三角形，则调用 Triangle::getArea()，如果是圆形，则调用 Circle::getArea()——即使您的代码不区分圆形和三角形，而是将每个对象视为只是一个形状。同一行代码会导致执行不同的代码块，

基于参数的多态性是一些强类型语言的特性，其中可以在一个类中定义多个同名方法，只要它们具有不同的参数；那么调用哪个方法取决于提供的参数。您可以通过手动考虑方法中的参数类型来模拟弱类型语言（如 PHP）中基于参数的多态性。这就是 jQuery 为了实现多态 API 而做的，尽管 JavaScript 缺乏基于参数的原生多态性。

因此，如果“支持多态”是指它为实现基于参数的多态提供了一种正式的机制，那么答案是否定的。对于任何更广泛的解释，答案是肯定的。按理说，基于类的多态现象出现在每一种面向对象语言中；对于执行隐式类型转换的语言来实现基于参数的多态性是没有意义的。

Answer 4

__call()并且__callStatic()应该支持方法重载。有关这方面的更多信息，请参阅手册。或者你到底在追求什么？

更新：我刚刚注意到其他回复。

对于重载方法的另一种方法，请考虑以下内容：

<?php
public function foo()
{
    $args = func_get_arg();
}

当然不漂亮，但它让你几乎可以做任何你想做的事情。

Answer 5

您仍然可以覆盖方法，只是不要重载它们。重载（在 C++ 中）是指对多个方法使用相同的方法名称，只是参数的数量和类型不同。这在 PHP 中会很困难，因为它是弱类型的。

覆盖是子类替换基类中的方法的地方。这确实是多态性的基础，您可以在 PHP 中做到这一点。

Answer 6

有人称这为鸭子打字。

Answer 7

多态可以通过以下方法实现：

1. method overriding- 正常漂亮如上

2. method overloading

您可以通过魔术方法 __call() 来创建方法重载的错觉：

class Poly {
    function __call($method, $arguments) {
        if ($method == 'edit') {
            if (count($arguments) == 1) {

                return call_user_func_array(array($this,'edit1'), $arguments);
            } else if (count($arguments) == 2) {
                return call_user_func_array(array($this,'edit2'), $arguments);
            }
        }
    }
    function edit1($x) {
        echo "edit with (1) parameter";
    }

    function edit2($x, $y) {
        echo "edit with (2) parameter";
    }

}

$profile = new Poly();
$profile->edit(1);
$profile->edit(1,2);

说明：

1) Here we are utilizing the power of __call() of listening calls of 
   non-available     methods and 
2) after knowing it who had called with their inputs diverting them to desired 
   method 

In php，我们实际上是working under the hood要给出想要的行为并给出感觉of method overloading

Answer 8

PHP 允许在其他语言中产生编译错误的多态代码。一个简单的例子说明了这一点。第一个产生预期编译错误的 C++ 代码：

class Base {};

class CommonDerivedBase {
   public:
    // The "= 0" makes the method and class abstract
    // virtual means polymorphic method
    virtual whoami() = 0;
};

class DerivedBase : public CommonDerivedBase {
   public:    
     void  whoami() { cout << "I am DerivedBase \n"; }
};

class Derived1 : public CommonDerivedBase {
  public:
    void  whoami() { cout << "I am Derived1\n"; }
};

class Derived2 : public CommonDerivedBase {
public:
 void whoami() { cout <<  "I am Derived2\n"; }
};

/* This will not compile */
void  test_error(Base& db)
{
   db.whoami();
}

C++ 编译器将为该行发出此错误消息db.whoami()

error: no member named 'whoami' in 'Base'

因为 Base 没有名为 whoami() 的方法。然而，类似的 PHP 代码直到运行时才发现此类错误。

class Base {}

abstract class DerivedCommonBase {
  abstract function whoami();
}

class Derived1 extends DerivedCommonBase {

 public function whoami() { echo "I am Derived1\n"; }
}

class Derived2 extends DerivedCommonBase {

 public function whoami() { echo "I am Derived2\n"; }
}

/* In PHP, test(Base $b) does not give a runtime error, as long as the object 
 * passed at run time derives from Base and implements whoami().
 */
function test(Base $b)
{
  $b->whoami(); 
}

$b = new Base();
$d1 = new Derived1();
$d2 = new Derived2();

$a = array();

$a[] = $d1;
$a[] = $d2;

foreach($a as $x) {

  echo  test($x);
}

test($d1);
test($d2);
test($b); //<-- A run time error will result.

foreach 循环与输出一起工作

I am Derived1
I am Derived2

直到您调用 test($b) 并传递 Base 的实例才会出现运行时错误。所以在foreach之后，输出将是

I am Derived1
I am Derived2
PHP Fatal error:  Call to undefined method Base::whoami() in
home/kurt/public_html/spl/observer/test.php on line 22

关于使 PHP 更安全的唯一方法是添加运行时检查以测试 $b 是否是您想要的类的实例。

function test(Base $b)
{
  if ($b instanceof DerivedCommonBase) {
     $b->whoami(); 
  } 
}

但是多态性的全部意义在于消除这种运行时检查。

Answer 9

对于我在这里看到的，php 不支持多态性，也不支持重载方法。您可以破解自己的方式来实际接近这两个 oop 功能，但它们与它的最初目的相去甚远。这里的许多示例要么是扩展一个类，要么是创建一个 hack 来模拟多态性。