Question

由于只有狗可以玩“获取”，这个例子是好还是坏？由于使用了instanceof，我怀疑这是一个非常糟糕的主意，但我不完全确定原因。

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

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

    function playFetch() {
        return 'getting the stick';
    }
}

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>';
    if ($animal instanceof Dog) echo $animal->playFetch();
}

另一个例子。由于我不断创建具有ID的数据对象，我想我也可以从基类扩展它们以避免代码重复。再次，这是不对的？由于椅子没有名字，狗没有轮子。但是他们这两个数据对象都非常令人困惑。

class Data_Object {
    protected $_id;

    function setId($id) {
        $this->_id = $id;
    }

    function getId() {
        return $this->_id;
    }
}

class Dog extends Data_Object {
    protected $_name;
    function setName($name) {
        $this->_name = 
    }

    function getName() {
        return $this->_name;
    }
}

class Chair extends Data_Object {
    protected $_numberOfWheels;
    function setNumberOfWheels($number) {
        $this->_numberOfWheels = $number;
    }

    function getNumberOfWheels() {
        return $this->_numberOfWheels;
    }
}

基本上我认为我要问的是：“如果所有子类都有相同的接口，或者它们可以有不同的接口吗？”

Answer 1

在这种情况下，谈谈接口是很有用的。

interface Talkative {
    public function speak();
}

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

任何实现Talkative接口的动物或人（或外星人）都可以在需要健谈的环境中使用：

protected function makeItSpeak(Talkative $being) {
    echo $being->speak();
}

这是一种使用得当的多态方法。只要可以speak()，您就不在乎您正在处理的。

如果Dog s也可以播放，那对他们来说很棒。如果你想概括一下，也可以根据界面来考虑它。也许有一天你会得到一只训练有素的猫，它也可以玩。

class Cog extends Cat implements Playfulness {
    public function playFetch() { ... }
}

重要的一点是，当你调用 playFetch()某事时，这是因为你想玩那个动物的获取。你不打电话给playFetch因为，好吧......你可以，但是因为你想在这一刻玩点球。如果您不想播放提取，则不要调用它。如果你需要在某种情况下玩提取，那么你需要一些可以播放的东西。您可以通过接口声明来确保这一点。

使用类继承可以实现相同的功能，但它的灵活性较差。在某些情况下，存在严格的层次结构虽然它非常有用：

abstract class Animal { }

abstract class Pet extends Animal { }

class Dog extends Pet {
    public function playFetch() { ... }
}

class GermanShepherd extends Dog {
    public function beAwesome() { ... }
}

然后，在某些特定的上下文中，您可能不需要可以执行某些操作的任何对象（接口），但您正在寻找GermanShepherd，因为只有它可以很棒：

protected function awesomeness(GermanShepherd $dog) {
    $dog->beAwesome();
}

也许在未来的道路上你会创造出一种新的GermanShepherd，它们也很棒，但是extend GermanShepherd类。他们仍然可以使用awesomeness函数，就像使用接口一样。

你当然不应该做的是循环一堆随机的东西，检查它们是什么，让它们做自己的事情。在任何情况下，这都不是很明智。

Answer 2

PHP中的多态性的另一个例子

    <?php
interface Shape {
   public function getArea();
}

class Square implements Shape {
   private $width;
   private $height;

   public function __construct($width, $height) {
      $this->width = $width;
      $this->height = $height;
   }

   public function getArea(){
      return $this->width * $this->height;
   }
}

class Circle implements Shape {
   private $radius;

   public function __construct($radius) {
      $this->radius = $radius;
   }

   public function getArea(){

      return 3.14 * $this->radius * $this->radius;
   }
}

function calculateArea(Shape $shape) {
   return $shape->getArea();
}

$square = new Square(5, 5);
$circle = new Circle(7);

echo calculateArea($square), "<br/>";
echo calculateArea($circle);
?>

Answer 3

几乎和你的克里希纳达斯一样，布拉德。本文帮助我了解如何处理PHP中的多态性

http://code.tutsplus.com/tutorials/understanding-and-applying-polymorphism-in-php--net-14362

interface shape_drawer{
    public function draw(Shape $obj);
}

class circle implements shape_drawer{
    public function draw(Shape $obj){
        echo "Drawing Circle, Area: {$obj->area} <br>";
    }
}

class square implements shape_drawer{
    public function draw(Shape $obj){
        echo "Drawing Square, Area: {$obj->area} <br>";
    }
}

class triangle implements shape_drawer{
    public function draw(Shape $obj){
        echo "Drawing Triangle, Area: {$obj->area} <br>";
    }    
}

class shape_factory{
    public static function getShape(){

        $shape = $_REQUEST['shape'];

        if(class_exists($shape)) {
            return new $shape();
        }
        throw new Exception('Unsupported format');
    }
}

class Shape{

    public function __construct($area){
        $this->area = $area;
    }
    public function draw(shape_drawer $obj) {
        return $obj->draw($this);
    }
}


$shape = new Shape(50);
try {
    $drawer = shape_factory::getShape();
}
catch (Exception $e) {
    $drawer = new circle();
}

echo $shape->draw($drawer);

Answer 4

多态性描述了面向对象编程中的一种模式，其中类在共享公共接口的同时具有不同的功能

接口接口与类相似，除了它不能包含代码。接口可以定义方法名称和参数，但不能定义方法的内容。任何实现接口的类都必须实现该接口定义的所有方法。一个类可以实现多个接口。

使用'interface'关键字声明接口：

interface MyInterface {
    // methods
}

，并使用“ implements”关键字附加到类（可以通过用逗号分隔列出多个接口来实现多个接口）：

class MyClass implements MyInterface {
    // methods
}

方法可以像在类中一样在接口中定义，除了没有主体的括号之间的部分外：

interface MyInterface {
    public function doThis();
    public function doThat();
    public function setName($name);
}

此处定义的所有方法都必须完全按照所描述的那样包含在任何实现类中。（阅读下面的代码注释）

//有效

class MyClass implements MyInterface {
    protected $name;
    public function doThis() {
        // code that does this
    }
    public function doThat() {
        // code that does that
    }
    public function setName($name) {
        $this->name = $name;
    }
}

// INVALID
class MyClass implements MyInterface {
    // missing doThis()!

    private function doThat() {
        // this should be public!
    }
    public function setName() {
        // missing the name argument!
    }
}

一般多态性与PHP的例子

4 个答案: