PHP еще не поддерживает множественное наследование классов, однако он поддерживает множественное наследование интерфейсов.

См. Некоторые примеры в http://www.hudzilla.org/php/6_17_0.php.

У вас не может быть класса, расширяющего два базовых класса. Вы не могли этого сделать.

// this is NOT allowed (for all you google speeders)
Matron extends Nurse, HumanEntity

Однако у вас может быть следующая иерархия ...

Matron extends Nurse    
Consultant extends Doctor

Nurse extends HumanEntity
Doctor extends HumanEntity

HumanEntity extends DatabaseTable
DatabaseTable extends AbstractTable

и так далее.

Классы не должны быть просто коллекциями методов. Предполагается, что класс представляет абстрактное понятие, как с состоянием (полями), так и поведением (методами), которое изменяет состояние. Использование наследования только для получения желаемого поведения звучит как плохой объектно-ориентированный дизайн, и именно по этой причине многие языки запрещают множественное наследование: чтобы предотвратить «наследование спагетти», то есть расширение 3 классов, потому что у каждого есть метод, который вам нужен, и в итоге класс, который наследует 100 методов и 20 полей, но использует только 5 из них.

Если вы действительно хотите имитировать множественное наследование в PHP 5.3, вы можете использовать волшебную функцию __call ().

Это уродливо, хотя с точки зрения пользователя класса А работает:

class B {
    public function method_from_b($s) {
        echo $s;
    }
}

class C {
    public function method_from_c($s) {
        echo $s;
    }
}

class A extends B
{
  private $c;
    
  public function __construct()
  {
    $this->c = new C;
  }
    
  // fake "extends C" using magic function
  public function __call($method, $args)
  {
    $this->c->$method($args[0]);
  }
}


$a = new A;
$a->method_from_b("abc");
$a->method_from_c("def");

Печатает "abcdef"

PHP не допускает множественного наследования, но вы можете реализовать несколько интерфейсов. Если реализация «тяжелая», предоставьте скелетная реализация для каждого интерфейса в отдельном классе. Затем вы можете делегировать весь интерфейсный класс этим скелетным реализациям через сдерживание объекта.

Я прочитал несколько статей, не одобряющих наследование в проектах (в отличие от библиотек / фреймворков) и поощряющих программирование интерфейсов, не противоречащих реализации. Они также защищают объектно-ориентированный подход по составу: если вам нужны функции в классе a и b, сделайте c, имеющим элементы / поля этого типа:

class C
{
    private $a, $b;

    public function __construct($x, $y)
    {
        $this->a = new A(42, $x);
        $this->b = new B($y);
    }

    protected function DoSomething()
    {
        $this->a->Act();
        $this->b->Do();
    }
}

Я полагаю, что в ближайшее время есть планы по добавлению микшеров.

Но до тех пор оставайтесь с принятым ответом. Вы можете немного абстрагироваться от этого, чтобы создать «расширяемый» класс:

class Extendable{
  private $extender=array();

  public function addExtender(Extender $obj){
    $this->extenders[] = $obj;
    $obj->setExtendee($this);
  }

  public function __call($name, $params){
    foreach($this->extenders as $extender){
       //do reflection to see if extender has this method with this argument count
       if (method_exists($extender, $name)){
          return call_user_func_array(array($extender, $name), $params);
       }
    }
  }
}


$foo = new Extendable();
$foo->addExtender(new OtherClass());
$foo->other_class_method();

Обратите внимание, что в этой модели OtherClass «знает» о $ foo. OtherClass должен иметь общедоступную функцию с именем "setExtendee", чтобы установить эту связь. Затем, если его методы вызываются из $ foo, он может получить доступ к $ foo изнутри. Однако он не получит доступа к каким-либо частным / защищенным методам / переменным, как настоящий расширенный класс.

Не зная точно, чего вы пытаетесь достичь, я бы посоветовал изучить возможность перепроектирования вашего приложения для использования в этом случае композиции, а не наследования.

Всегда хорошая идея - создать родительский класс с функциями ... т.е. добавить все эти функции в родительский.

И «переместите» все классы, которые используют это иерархически, вниз. Мне нужно - переписать функции, которые специфичны.

Вы можете использовать трейты, которые, надеюсь, будут доступны в PHP 5.4.

Traits - это механизм для повторного использования кода в языках с единичным наследованием, таких как PHP. Признак предназначен для уменьшения некоторых ограничений одиночного наследования, позволяя разработчику свободно повторно использовать наборы методов в нескольких независимых классах, находящихся в разных иерархиях классов. Семантика комбинации Traits и классов определяется способом, который снижает сложность и позволяет избежать типичных проблем, связанных с множественным наследованием и Mixins.

Они известны своим потенциалом в поддержке лучшей композиции и повторного использования, следовательно, их интеграция в новые версии языков, таких как Perl 6, Squeak, Scala, Slate и Fortress. Черты также были перенесены на Java и C#.

Дополнительная информация: https://wiki.php.net/rfc/traits

Я только что решил проблему с "множественным наследованием":

class Session {
    public $username;
}

class MyServiceResponsetype {
    protected $only_avaliable_in_response;
}

class SessionResponse extends MyServiceResponsetype {
    /** has shared $only_avaliable_in_response */

    public $session;

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

}

Таким образом, у меня есть возможность управлять сеансом внутри SessionResponse, который расширяет MyServiceResponsetype, по-прежнему имея возможность обрабатывать сеанс самостоятельно.

Если вы хотите проверить, является ли функция общедоступной, см. Эту тему: https://stackoverflow.com/a/4160928/2226755

И используйте метод call_user_func_array (...) для многих аргументов или нет.

Как это :

class B {
    public function method_from_b($s) {
        echo $s;
    }
}

class C {
    public function method_from_c($l, $l1, $l2) {
        echo $l.$l1.$l2;
    }
}

class A extends B {
    private $c;

    public function __construct() {
        $this->c = new C;
    }

    public function __call($method, $args) {
        if (method_exists($this->c, $method)) {
            $reflection = new ReflectionMethod($this->c, $method);
            if (!$reflection->isPublic()) {
                throw new RuntimeException("Call to not public method ".get_class($this)."::$method()");
            }

            return call_user_func_array(array($this->c, $method), $args);
        } else {
            throw new RuntimeException("Call to undefined method ".get_class($this)."::$method()");
        }
    }
}


$a = new A;
$a->method_from_b("abc");
$a->method_from_c("d", "e", "f");

<?php
// what if we want to extend more than one class?

abstract class ExtensionBridge
{
    // array containing all the extended classes
    private $_exts = array();
    public $_this;

    function __construct() {$_this = $this;}

    public function addExt($object)
    {
        $this->_exts[]=$object;
    }

    public function __get($varname)
    {
        foreach($this->_exts as $ext)
        {
            if (property_exists($ext,$varname))
            return $ext->$varname;
        }
    }

    public function __call($method,$args)
    {
        foreach($this->_exts as $ext)
        {
            if (method_exists($ext,$method))
            return call_user_method_array($method,$ext,$args);
        }
        throw new Exception("This Method {$method} doesn't exists");
    }


}

class Ext1
{
    private $name = "";
    private $id = "";
    public function setID($id){$this->id = $id;}
    public function setName($name){$this->name = $name;}
    public function getID(){return $this->id;}
    public function getName(){return $this->name;}
}

class Ext2
{
    private $address = "";
    private $country = "";
    public function setAddress($address){$this->address = $address;}
    public function setCountry($country){$this->country = $country;}
    public function getAddress(){return $this->address;}
    public function getCountry(){return $this->country;}
}

class Extender extends ExtensionBridge
{
    function __construct()
    {
        parent::addExt(new Ext1());
        parent::addExt(new Ext2());
    }

    public function __toString()
    {
        return $this->getName().', from: '.$this->getCountry();
    }
}

$o = new Extender();
$o->setName("Mahdi");
$o->setCountry("Al-Ahwaz");
echo $o;
?>

Обновлено: 2020 PHP 5.4+ и 7+

Начиная с PHP 5.4.0 есть "Черты" - вы можете использовать больше трейтов в одном классе, поэтому окончательный момент принятия решения будет заключаться в том, хотите ли вы действительно наследство или вам просто нужен какая-то "особенность" (черта). Тенденция - это, расплывчато сказано, уже реализованный интерфейс, который должен быть просто used.

Точный ответ

Нет, соответственно, не совсем, как говорит руководство по ключевому слову extends:

An extended class is always dependent on a single base class, that is, multiple inheritance is not supported.

Реальный ответ

Однако, как правильно предположил @adam, это НЕ запрещает вам использовать множественное иерархическое наследование.

Вы МОЖЕТЕ расширить один класс другим, а другой - другим и так далее ...

Вот довольно простой пример:

class firstInheritance{}
class secondInheritance extends firstInheritance{}
class someFinalClass extends secondInheritance{}
//...and so on...

Важная заметка

Как вы могли заметить, вы можете выполнять множественное (2+) взаимодействие по иерархии только в том случае, если у вас есть контроль над всеми классами, включенными в процесс. - это означает, что вы не можете применить это решение, например. со встроенными классами или с классами, которые вы просто не можете редактировать - если вы хотите это сделать, у вас останется решение @Franck - дочерние экземпляры.

... И, наконец, пример с некоторым выводом:

class A{
  function a_hi(){
    echo "I am a of A".PHP_EOL."<br>".PHP_EOL;  
  }
}

class B extends A{
  function b_hi(){
    echo "I am b of B".PHP_EOL."<br>".PHP_EOL;  
  }
}

class C extends B{
  function c_hi(){
    echo "I am c of C".PHP_EOL."<br>".PHP_EOL;  
  }
}

$myTestInstance = new C();

$myTestInstance->a_hi();
$myTestInstance->b_hi();
$myTestInstance->c_hi();

Какие выходы

I am a of A 
I am b of B 
I am c of C 

Вы можете сделать это с помощью Traits в PHP, объявленных в PHP 5.4.

Вот краткое руководство для вас, http://culttt.com/2014/06/25/php-traits/

Множественное наследование работает на уровне интерфейса. Сделал тест на php 5.6.1.

Вот рабочий код:

<?php


interface Animal
{
    public function sayHello();
}


interface HairyThing
{
    public function plush();
}

interface Dog extends Animal, HairyThing
{
    public function bark();
}


class Puppy implements Dog
{
    public function bark()
    {
        echo "ouaf";
    }

    public function sayHello()
    {
        echo "hello";
    }

    public function plush()
    {
        echo "plush";
    }


}


echo PHP_VERSION; // 5.6.1
$o = new Puppy();
$o->bark();
$o->plush();
$o->sayHello(); // displays: 5.6.16ouafplushhello

Я не думал, что это возможно, но я наткнулся на исходный код SwiftMailer в классе Swift_Transport_IoBuffer, который имеет следующее определение:

interface Swift_Transport_IoBuffer extends Swift_InputByteStream, Swift_OutputByteStream

Я еще не играл с этим, но подумал, что, возможно, будет интересно поделиться.

Одна из проблем PHP как языка программирования заключается в том, что у вас может быть только одиночное наследование. Это означает, что класс может наследовать только от одного другого класса.

Однако в большинстве случаев было бы полезно наследовать от нескольких классов. Например, может быть желательно наследовать методы от пары разных классов, чтобы предотвратить дублирование кода.

Эта проблема может привести к классу, который имеет долгую семейную историю наследования, что часто не имеет смысла.

В PHP 5.4 была добавлена ​​новая функция языка, известная как Traits. Trait похож на Mixin в том смысле, что он позволяет вам смешивать классы Trait в существующий класс. Это означает, что вы можете уменьшить дублирование кода и получить преимущества, избегая проблем множественного наследования.

Черты

Используйте черты характера как базовые классы. Затем используйте их в родительском классе. Расширьте это.

trait business{
  function sell(){

  }

  function buy(){

  }

  function collectMoney(){
  }

}

trait human{

   function think(){

   }

   function speak(){

   }

}

class BusinessPerson{
  use business;
  use human;
  // If you have more traits bring more
}


class BusinessWoman extends BusinessPerson{

   function getPregnant(){

   }

}


$bw = new BusinessWoman();
$bw ->speak();
$bw->getPregnant();

Теперь представьте, что бизнес-леди логически унаследовала и бизнес, и человека;

класс A расширяет B {}

класс B расширяет C {}

Тогда A расширил и B, и C

Это не настоящий ответ, у нас есть повторяющийся класс

... но работает :)

class A {
    //do some things
}

class B {
    //do some things
}

class copy_B копирует весь класс B

class copy_B extends A {

    //do some things (copy class B)
}

class A_B extends copy_B{}

Теперь

class C_A extends A{}
class C_B extends B{}
class C_A_b extends A_B{}  //extends A & B