Czy mogę rozszerzyć klasę używając więcej niż 1 klasy w PHP?

Jeśli mam kilka klas z funkcjami, których potrzebuję, ale chcę przechowywać je oddzielnie dla organizacji, czy mogę rozszerzyć klasę, aby mieć obie?

to znaczy class a extends b extends c

edycja: Wiem, jak rozszerzać klasy pojedynczo, ale szukam metody, aby natychmiast rozszerzyć klasę za pomocą wielu klas bazowych - AFAIK, nie możesz tego zrobić w PHP, ale powinny być sposoby obejścia tego bez uciekania się do class c extends b,class b extends a

Odpowiadając na zmianę:

Jeśli naprawdę chcesz sfałszować wielokrotne dziedziczenie, możesz użyć magicznej funkcji __call ().

To jest brzydkie, chociaż działa z punktu widzenia użytkownika klasy A:

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");

Wyświetla „abcdef”

Nie możesz mieć klasy, która rozszerza dwie klasy bazowe. Nie mogłeś.

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

Możesz jednak mieć następującą hierarchię ...

Matron extends Nurse    
Consultant extends Doctor

Nurse extends HumanEntity
Doctor extends HumanEntity

HumanEntity extends DatabaseTable
DatabaseTable extends AbstractTable

i tak dalej.

Możesz użyć cech, które, miejmy nadzieję, będą dostępne w PHP 5.4.

Cechy to mechanizm ponownego wykorzystania kodu w pojedynczych językach dziedziczenia, takich jak PHP. Cecha ma na celu zmniejszenie niektórych ograniczeń pojedynczego dziedziczenia poprzez umożliwienie programiście swobodnego ponownego wykorzystywania zestawów metod w kilku niezależnych klasach żyjących w różnych hierarchiach klas. Semantyka kombinacji cech i klas jest zdefiniowana w sposób, który zmniejsza złożoność i pozwala uniknąć typowych problemów związanych z dziedziczeniem wielokrotnym i mieszankami.

Są znane ze swojego potencjału w zakresie wspierania lepszej kompozycji i ponownego wykorzystania, stąd ich integracja z nowszymi wersjami języków, takich jak Perl 6, Squeak, Scala, Slate i Fortress. Cechy zostały również przeniesione na Javę i C #.

Więcej informacji: https://wiki.php.net/rfc/traits

Zajęcia nie mają być tylko zbiorem metod. Klasa ma reprezentować abstrakcyjną koncepcję, zawierającą zarówno stan (pola), jak i zachowanie (metody), które zmienia stan. Używanie dziedziczenia tylko po to, by uzyskać pożądane zachowanie, brzmi jak zły projekt obiektu obiektowego i jest dokładnie powodem, dla którego wiele języków nie zezwala na wielokrotne dziedziczenie: aby zapobiec „dziedziczeniu spaghetti”, tj. Rozszerzając 3 klasy, ponieważ każda ma metodę, której potrzebujesz, i kończy się na klasa, która dziedziczy 100 metod i 20 pól, ale zawsze używa tylko 5 z nich.

Sądzę, że są plany dodania wkrótce miksów.

Ale do tego czasu stosuj zaakceptowaną odpowiedź. Możesz to nieco wyodrębnić, aby utworzyć klasę „rozszerzalną”:

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();

Zauważ, że w tym modelu „OtherClass” „wie” o $ foo. OtherClass musi mieć funkcję publiczną o nazwie „setExtendee”, aby ustawić tę relację. Następnie, jeśli jego metody są wywoływane z $ foo, może uzyskać dostęp do $ foo wewnętrznie. Nie uzyska jednak dostępu do żadnych prywatnych / chronionych metod / zmiennych, takich jak prawdziwa klasa rozszerzona.

Użyj cech jako klas podstawowych. Następnie użyj ich w klasie nadrzędnej. Przedłuż to.

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();

Spójrzmy teraz na kobietę biznesu, która logicznie odziedziczyła biznes i ludzi;

<?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;
?>

Aktualnie akceptowana odpowiedź @Franck będzie działać, ale w rzeczywistości nie jest to dziedziczenie wielokrotne, ale instancja potomna klasy zdefiniowanej poza zakresem, jest też __call()skrót - rozważ użycie $this->childInstance->method(args)wszędzie tam, gdzie potrzebujesz metody klasy ExternalClass w klasie „rozszerzonej”.

Dokładna odpowiedź

Nie, nie możesz, odpowiednio, nie, ponieważ instrukcja extendssłowa kluczowego mówi:

Klasa rozszerzona jest zawsze zależna od jednej klasy bazowej, co oznacza, że ​​dziedziczenie wielokrotne nie jest obsługiwane.

Prawdziwa odpowiedź

Jednak, jak poprawnie zasugerował @adam, NIE zabrania to używania wielokrotnego dziedziczenia hierarchicznego.

MOŻESZ rozszerzyć jedną klasę o inną, o kolejną i tak dalej ...

Takim prostym przykładem byłoby:

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

Ważna uwaga

Jak pewnie zauważyłeś, możesz wykonywać wielokrotne (2+) intehritance przez hierarchię tylko wtedy, gdy masz kontrolę nad wszystkimi klasami wchodzącymi w skład procesu - oznacza to, że nie możesz zastosować tego rozwiązania np. Z klasami wbudowanymi lub z klasami, które po prostu nie można edytować - jeśli chcesz to zrobić, pozostaje rozwiązanie @Franck - instancje podrzędne.

... I na koniec przykład z wynikami:

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();

Które wyjścia

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

Przeczytałem kilka artykułów odradzających dziedziczenie w projektach (w przeciwieństwie do bibliotek / frameworków) i zachęcających do programowania interfejsów agaisnt, nie przeciwko implementacjom.
Popierają również OO ze względu na skład: jeśli potrzebujesz funkcji w klasie a i b, spraw, aby c miał elementy / pola tego typu:

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();
    }
}

Dziedziczenie wielokrotne wydaje się działać na poziomie interfejsu. Zrobiłem test na php 5.6.1.

Oto działający kod:

<?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

Nie sądziłem, że to możliwe, ale natknąłem się na kod źródłowy SwiftMailer, w klasie Swift_Transport_IoBuffer, która ma następującą definicję:

interface Swift_Transport_IoBuffer extends Swift_InputByteStream, Swift_OutputByteStream

Jeszcze się tym nie bawiłem, ale pomyślałem, że podzielenie się nim może być interesujące.

Właśnie rozwiązałem mój problem z dziedziczeniem wielokrotnym:

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;
    }

}

W ten sposób mam możliwość manipulowania sesją wewnątrz SessionResponse, która rozszerza MyServiceResponsetype o możliwość samodzielnej obsługi sesji.

Jeśli chcesz sprawdzić, czy funkcja jest publiczna, zajrzyj do tego tematu: https://stackoverflow.com/a/4160928/2226755

I użyj metody call_user_func_array (...) dla wielu argumentów lub nie.

Lubię to :

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");

Możesz to zrobić używając funkcji w PHP, które zostały ogłoszone w PHP 5.4

Oto krótki samouczek dla Ciebie, http://culttt.com/2014/06/25/php-traits/

PHP nie obsługuje jeszcze dziedziczenia wielu klas, obsługuje jednak dziedziczenie wielu interfejsów.

Zobacz http://www.hudzilla.org/php/6_17_0.php po kilka przykładów.

PHP nie pozwala na wielokrotne dziedziczenie, ale możesz to zrobić, implementując wiele interfejsów. Jeśli implementacja jest „ciężka”, podaj szkieletową implementację dla każdego interfejsu w osobnej klasie. Następnie możesz delegować wszystkie klasy interfejsu do tych szkieletowych implementacji poprzez zawieranie obiektów .

Nie wiedząc dokładnie, co próbujesz osiągnąć, sugerowałbym przyjrzenie się możliwości przeprojektowania aplikacji tak, aby w tym przypadku używała kompozycji zamiast dziedziczenia.

Zawsze dobrym pomysłem jest stworzenie klasy nadrzędnej z funkcjami ... tj. Dodanie tej całej funkcjonalności do klasy rodzica.

I „przenieś” wszystkie klasy, które używają tego hierarchicznie w dół. Potrzebuję - przepisanie funkcji, które są specyficzne.

Jednym z problemów PHP jako języka programowania jest fakt, że możesz mieć tylko jedno dziedzictwo. Oznacza to, że klasa może dziedziczyć tylko z jednej innej klasy.

Jednak często warto dziedziczyć z wielu klas. Na przykład może być pożądane, aby dziedziczyć metody z kilku różnych klas, aby zapobiec duplikowaniu kodu.

Ten problem może prowadzić do tego, że klasa ma długą rodzinną historię dziedziczenia, co często nie ma sensu.

W PHP 5.4 dodano nową funkcję języka znaną jako Cechy. Cecha jest czymś w rodzaju Mixina, ponieważ pozwala na mieszanie klas cech z istniejącą klasą. Oznacza to, że możesz zredukować powielanie kodu i uzyskać korzyści, unikając jednocześnie problemów związanych z wielokrotnym dziedziczeniem.

Cechy

To nie jest prawdziwa odpowiedź, mamy zduplikowaną klasę

... ale działa :)

class A {
    //do some things
}

class B {
    //do some things
}

klasa copy_B to kopia całej klasy B.

class copy_B extends A {

    //do some things (copy class B)
}

class A_B extends copy_B{}

teraz

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

klasa A rozszerza B {}

klasa B rozszerza C {}

Następnie A przedłużył zarówno B, jak i C.