Bisakah saya memperluas kelas menggunakan lebih dari 1 kelas di PHP?

Jika saya memiliki beberapa kelas dengan fungsi yang saya perlukan tetapi ingin menyimpan secara terpisah untuk organisasi, dapatkah saya memperluas kelas untuk memiliki keduanya?

yaitu class a extends b extends c

sunting: Saya tahu cara memperluas kelas satu per satu, tetapi saya sedang mencari metode untuk langsung memperpanjang kelas menggunakan beberapa kelas dasar - AFAIK Anda tidak dapat melakukan ini dalam PHP tetapi harus ada cara di sekitarnya tanpa menggunakan class c extends b,class b extends a

Menjawab hasil edit Anda:

Jika Anda benar-benar ingin memalsukan banyak warisan, Anda dapat menggunakan fungsi ajaib __call ().

Ini jelek meskipun bekerja dari sudut pandang pengguna kelas 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");

Mencetak "abcdef"

Anda tidak dapat memiliki kelas yang memperpanjang dua kelas dasar. Anda tidak bisa.

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

Namun Anda dapat memiliki hierarki sebagai berikut ...

Matron extends Nurse    
Consultant extends Doctor

Nurse extends HumanEntity
Doctor extends HumanEntity

HumanEntity extends DatabaseTable
DatabaseTable extends AbstractTable

dan seterusnya.

Anda dapat menggunakan ciri-ciri, yang, semoga, akan tersedia dari PHP 5.4.

Ciri adalah mekanisme untuk menggunakan kembali kode dalam bahasa pewarisan tunggal seperti PHP. Trait dimaksudkan untuk mengurangi beberapa batasan pewarisan tunggal dengan memungkinkan pengembang untuk menggunakan kembali set metode secara bebas di beberapa kelas independen yang hidup dalam hierarki kelas yang berbeda. Semantik dari kombinasi Ciri dan kelas didefinisikan dengan cara, yang mengurangi kompleksitas dan menghindari masalah khas yang terkait dengan pewarisan berganda dan Mixin.

Mereka dikenal karena potensi mereka dalam mendukung komposisi dan penggunaan kembali yang lebih baik, karenanya integrasi mereka dalam versi bahasa yang lebih baru seperti Perl 6, Squeak, Scala, Slate dan Fortress. Ciri juga telah porting ke Jawa dan C #.

Informasi lebih lanjut: https://wiki.php.net/rfc/traits

Kelas tidak hanya dimaksudkan sebagai kumpulan metode. Kelas seharusnya mewakili konsep abstrak, dengan kedua negara (bidang) dan perilaku (metode) yang mengubah negara. Menggunakan pewarisan hanya untuk mendapatkan beberapa perilaku yang diinginkan terdengar seperti desain OO yang buruk, dan justru alasan mengapa banyak bahasa melarang pewarisan berganda: untuk mencegah "pewarisan spaghetti", yaitu memperluas 3 kelas karena masing-masing memiliki metode yang Anda butuhkan, dan berakhir dengan kelas yang mewarisi 100 metode dan 20 bidang, namun hanya menggunakan 5 di antaranya.

Saya yakin ada rencana untuk menambahkan mix-in segera.

Tetapi sampai saat itu, pergilah dengan jawaban yang diterima. Anda bisa abstrak sedikit untuk membuat kelas "extended":

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

Perhatikan bahwa dalam model ini "OtherClass" dapat 'mengetahui' tentang $ foo. OtherClass perlu memiliki fungsi publik yang disebut "setExtendee" untuk mengatur hubungan ini. Kemudian, jika metode itu dipanggil dari $ foo, ia dapat mengakses $ foo secara internal. Namun, itu tidak akan mendapatkan akses ke metode / variabel pribadi / terlindungi seperti yang akan diperluas oleh kelas nyata.

Gunakan sifat sebagai kelas dasar. Kemudian gunakan di kelas induk. Perpanjang itu.

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

Lihat sekarang wanita bisnis yang secara logis mewarisi bisnis dan manusia;

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

Jawaban yang saat ini diterima oleh @Franck akan bekerja tetapi sebenarnya bukan multiple inheritance tetapi turunan anak dari kelas yang didefinisikan di luar ruang lingkup, juga terdapat __call()singkatan - pertimbangkan untuk menggunakan di $this->childInstance->method(args)mana saja Anda memerlukan metode kelas ExternalClass di kelas "extended".

Jawaban yang tepat

Tidak, Anda tidak dapat, masing-masing, tidak benar-benar, seperti yang dikatakan oleh kata kunci manualextends :

Kelas yang diperluas selalu tergantung pada kelas basis tunggal, yaitu, multiple inheritance tidak didukung.

Jawaban nyata

Namun seperti yang disarankan @adam dengan benar, ini TIDAK melarang Anda untuk menggunakan banyak pewarisan hierarki.

Anda BISA memperpanjang satu kelas, dengan yang lain dan yang lain dengan yang lain dan seterusnya ...

Contoh yang cukup sederhana untuk ini adalah:

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

Catatan penting

Seperti yang mungkin telah Anda perhatikan, Anda hanya dapat melakukan beberapa (2+) intehritance berdasarkan hierarki jika Anda memiliki kendali atas semua kelas yang termasuk dalam proses - itu artinya, Anda tidak dapat menerapkan solusi ini misalnya dengan kelas bawaan atau dengan kelas yang Anda miliki. tidak dapat mengedit - jika Anda ingin melakukan itu, Anda dibiarkan dengan solusi @Franck - instance anak.

... Dan akhirnya contoh dengan beberapa output:

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

Output yang mana

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

Saya telah membaca beberapa artikel yang mengecilkan warisan dalam proyek-proyek (tidak seperti perpustakaan / kerangka kerja), dan mendorong untuk memprogram antarmuka antarmuka, tidak menentang implementasi.
Mereka juga menganjurkan OO dengan komposisi: jika Anda memerlukan fungsi di kelas a dan b, buat c memiliki anggota / bidang seperti ini:

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

Warisan berganda tampaknya berfungsi pada level antarmuka. Saya membuat tes di php 5.6.1.

Ini adalah kode yang berfungsi:

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

Saya tidak berpikir itu mungkin, tapi saya menemukan kode sumber SwiftMailer, di kelas Swift_Transport_IoBuffer, yang memiliki definisi berikut:

interface Swift_Transport_IoBuffer extends Swift_InputByteStream, Swift_OutputByteStream

Saya belum bermain dengannya, tapi saya pikir mungkin menarik untuk dibagikan.

Saya baru saja menyelesaikan masalah "multiple inheritance" saya dengan:

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

}

Dengan cara ini saya memiliki kekuatan untuk memanipulasi sesi di dalam SessionResponse yang meluas MyServiceResponsetype masih bisa menangani Session dengan sendirinya.

Jika Anda ingin memeriksa apakah suatu fungsi bersifat publik, lihat topik ini: https://stackoverflow.com/a/4160928/2226755

Dan gunakan metode call_user_func_array (...) untuk banyak atau tidak argumen.

Seperti ini :

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

Anda dapat melakukannya menggunakan Ciri-ciri di PHP yang diumumkan pada PHP 5.4

Ini adalah tutorial singkat untuk Anda, http://culttt.com/2014/06/25/php-traits/

PHP belum mendukung multiple class inheritance, namun ia mendukung multiple interface inheritance.

Lihat http://www.hudzilla.org/php/6_17_0.php untuk beberapa contoh.

PHP tidak mengizinkan banyak pewarisan, tetapi Anda dapat melakukannya dengan mengimplementasikan banyak antarmuka. Jika implementasinya "berat", berikan implementasi kerangka untuk setiap antarmuka dalam kelas yang terpisah. Kemudian, Anda bisa mendelegasikan semua kelas antarmuka ke implementasi kerangka ini melalui penahanan objek .

Tidak tahu persis apa yang ingin Anda capai, saya sarankan melihat kemungkinan mendesain ulang aplikasi Anda untuk menggunakan komposisi daripada warisan dalam kasus ini.

Gagasan yang selalu baik adalah membuat kelas induk, dengan fungsi ... yaitu menambahkan semua fungsi ini ke induk.

Dan "pindahkan" semua kelas yang menggunakan ini secara hierarkis ke bawah. Saya perlu - menulis ulang fungsi, yang spesifik.

Salah satu masalah PHP sebagai bahasa pemrograman adalah kenyataan bahwa Anda hanya dapat memiliki satu warisan. Ini berarti suatu kelas hanya dapat mewarisi dari satu kelas lain.

Namun, banyak waktu akan bermanfaat untuk mewarisi dari beberapa kelas. Misalnya, mungkin diinginkan untuk mewarisi metode dari beberapa kelas yang berbeda untuk mencegah duplikasi kode.

Masalah ini dapat menyebabkan kelas yang memiliki sejarah keluarga yang panjang tentang warisan yang seringkali tidak masuk akal.

Dalam PHP 5.4 fitur baru bahasa ditambahkan dikenal sebagai Ciri. Trait adalah jenis seperti Mixin karena memungkinkan Anda untuk mencampur kelas Trait menjadi kelas yang ada. Ini berarti Anda dapat mengurangi duplikasi kode dan mendapatkan manfaat sambil menghindari masalah pewarisan berganda.

Sifat

Ini bukan jawaban nyata, kami memiliki kelas duplikat

... tapi berhasil :)

class A {
    //do some things
}

class B {
    //do some things
}

kelas copy_B adalah salin semua kelas B

class copy_B extends A {

    //do some things (copy class B)
}

class A_B extends copy_B{}

sekarang

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

kelas A meluas B {}

kelas B meluas C {}

Kemudian A telah memperpanjang B dan C