Java Multiple Inheritance

Dalam upaya untuk sepenuhnya memahami bagaimana menyelesaikan beberapa masalah warisan Java, saya memiliki pertanyaan klasik yang perlu saya klarifikasi.

Katakanlah saya memiliki kelas Animalini memiliki sub kelas Birddan Horsedan saya perlu membuat kelas Pegasusyang memanjang dari Birddan Horsekarena Pegasusmerupakan burung dan kuda.

Saya pikir ini adalah masalah berlian klasik. Dari apa yang saya bisa mengerti cara klasik untuk menyelesaikan ini adalah dengan membuat Animal, Birddan Horsekelas antarmuka dan mengimplementasikannya Pegasus.

Saya bertanya-tanya apakah ada cara lain untuk memecahkan masalah di mana saya masih bisa membuat objek untuk burung dan kuda. Jika ada cara untuk bisa menciptakan hewan juga itu akan bagus tapi tidak perlu.

Anda dapat membuat antarmuka untuk kelas hewan (kelas dalam arti biologis), seperti public interface Equidaeuntuk kuda dan public interface Avialaeburung (saya bukan ahli biologi, jadi istilahnya mungkin salah).

Maka Anda masih dapat membuat

public class Bird implements Avialae {
}

dan

public class Horse implements Equidae {}

dan juga

public class Pegasus implements Avialae, Equidae {}

Menambahkan dari komentar:

Untuk mengurangi kode duplikat, Anda bisa membuat kelas abstrak yang berisi sebagian besar kode umum hewan yang ingin Anda terapkan.

public abstract class AbstractHorse implements Equidae {}

public class Horse extends AbstractHorse {}

public class Pegasus extends AbstractHorse implements Avialae {}

Memperbarui

Saya ingin menambahkan satu detail lagi. Seperti yang Brian katakan , ini adalah sesuatu yang sudah diketahui OP.

Namun, saya ingin menekankan, bahwa saya menyarankan untuk memotong masalah "multi-inheritance" dengan antarmuka dan bahwa saya tidak merekomendasikan untuk menggunakan antarmuka yang sudah mewakili tipe konkret (seperti Bird) tetapi lebih merupakan perilaku (yang lain merujuk pada mengetik bebek, itu bagus juga, tapi maksud saya adil: kelas biologis burung, Avialae). Saya juga tidak menyarankan untuk menggunakan nama antarmuka yang dimulai dengan huruf 'I', seperti IBird, yang tidak memberi tahu apa-apa tentang mengapa Anda memerlukan antarmuka. Itulah perbedaan dari pertanyaan: membangun hierarki warisan menggunakan antarmuka, menggunakan kelas abstrak saat berguna, mengimplementasikan kelas konkret di mana diperlukan dan menggunakan delegasi jika sesuai.

Ada dua pendekatan mendasar untuk menggabungkan objek:

• Yang pertama adalah Warisan . Karena Anda telah mengidentifikasi batasan-batasan warisan berarti Anda tidak dapat melakukan apa yang Anda butuhkan di sini.
• Yang kedua adalah Komposisi . Karena warisan gagal, Anda perlu menggunakan komposisi.

Cara kerjanya adalah Anda memiliki objek Hewan. Di dalam objek itu Anda kemudian menambahkan objek lebih lanjut yang memberikan properti dan perilaku yang Anda butuhkan.

Sebagai contoh:

• Bird memperpanjang Animal implement IFlier
• Kuda memperluas Animal mengimplementasikan IHerbivore, IQuadruped
• Pegasus memperluas Animal implement IHerbivore, IQuadruped, IFlier

Sekarang IFlierhanya terlihat seperti ini:

 interface IFlier {
     Flier getFlier();
 }

Jadi Birdterlihat seperti ini:

 class Bird extends Animal implements IFlier {
      Flier flier = new Flier();
      public Flier getFlier() { return flier; }
 }

Sekarang Anda memiliki semua keunggulan Warisan. Anda dapat menggunakan kembali kode. Anda dapat memiliki koleksi IFliers, dan dapat menggunakan semua keuntungan lain dari polimorfisme, dll.

Namun Anda juga memiliki semua fleksibilitas dari Komposisi. Anda dapat menerapkan sebanyak mungkin antarmuka dan kelas dukungan komposit yang berbeda sesuai keinginan untuk setiap jenis Animal- dengan sebanyak mungkin kendali yang Anda perlukan atas cara setiap bit diatur.

Strategi Pendekatan alternatif pola komposisi

Pendekatan alternatif tergantung pada apa dan bagaimana Anda lakukan adalah membuat Animalkelas dasar berisi koleksi internal untuk menyimpan daftar perilaku yang berbeda. Dalam hal ini Anda akhirnya menggunakan sesuatu yang lebih dekat dengan Pola Strategi. Itu memang memberi keuntungan dalam hal menyederhanakan kode (misalnya Horsetidak perlu tahu apa-apa tentang Quadrupedatau Herbivore) tetapi jika Anda tidak juga melakukan pendekatan antarmuka Anda kehilangan banyak keuntungan polimorfisme, dll.

Saya punya ide bodoh:

public class Pegasus {
    private Horse horseFeatures; 
    private Bird birdFeatures; 

   public Pegasus(Horse horse, Bird bird) {
     this.horseFeatures = horse;
     this.birdFeatures = bird;
   }

  public void jump() {
    horseFeatures.jump();
  }

  public void fly() {
    birdFeatures.fly();
  }
}

Bolehkah saya menyarankan konsep Duck-typing ?

Kemungkinan besar Anda cenderung membuat Pegasus memperluas antarmuka Burung dan Kuda, tetapi mengetik bebek sebenarnya menunjukkan bahwa Anda sebaiknya mewarisi perilaku . Seperti yang sudah dinyatakan dalam komentar, pegasus bukan burung tetapi bisa terbang. Jadi Pegasus Anda sebaiknya mewarisi Flyable-interface dan katakanlah Gallopable-interface.

Konsep semacam ini digunakan dalam Pola Strategi . Contoh yang diberikan sebenarnya menunjukkan kepada Anda bagaimana seekor bebek mewarisi FlyBehaviourdan QuackBehaviourdan masih ada bebek, misalnya RubberDuck, yang tidak bisa terbang. Mereka bisa saja membuat Duckperpanjangan Birdkelas-tetapi kemudian mereka akan memberikan beberapa fleksibilitas, karena setiap orang Duckbisa terbang, bahkan orang miskin RubberDuck.

Secara teknis, Anda hanya dapat memperluas satu kelas pada satu waktu dan mengimplementasikan beberapa antarmuka, tetapi ketika meletakkan tangan pada rekayasa perangkat lunak, saya lebih suka menyarankan solusi khusus masalah yang umumnya tidak dapat dijawab. Ngomong-ngomong, itu adalah praktik OO yang baik, bukan untuk memperluas kelas konkret / hanya memperluas kelas abstrak untuk mencegah perilaku pewarisan yang tidak diinginkan - tidak ada yang namanya "hewan" dan tidak ada penggunaan objek hewan tetapi hanya hewan beton.

Di Java 8, yang masih dalam tahap pengembangan per Februari 2014, Anda bisa menggunakan metode default untuk mencapai semacam C ++ - seperti multiple inheritance. Anda juga bisa melihat tutorial ini yang menunjukkan beberapa contoh yang seharusnya lebih mudah untuk mulai bekerja daripada dokumentasi resmi.

Aman menyimpan kuda di kandang kuda dengan setengah pintu, karena kuda tidak bisa melewati setengah pintu. Karena itu saya menyiapkan layanan perumahan kuda yang menerima segala jenis kuda jenis dan meletakkannya di kandang dengan setengah pintu.

Jadi, apakah seekor kuda seperti binatang yang dapat terbang, bahkan seekor kuda?

Saya dulu sering berpikir tentang multiple inheritance, namun sekarang saya telah memprogram lebih dari 15 tahun, saya tidak lagi peduli untuk mengimplementasikan multiple inheritance.

Lebih sering daripada tidak, ketika saya telah mencoba untuk mengatasi suatu desain yang mengarah ke multiple inheritance, saya kemudian datang untuk merilis bahwa saya telah kehilangan memahami domain masalah.

ATAU

Jika terlihat seperti bebek dan dukun seperti bebek tetapi membutuhkan baterai, Anda mungkin memiliki abstraksi yang salah .

Java tidak memiliki masalah multiple inheritance, karena tidak memiliki multiple inheritance. Ini adalah desain, untuk menyelesaikan masalah pewarisan berganda nyata (Masalah berlian).

Ada berbagai strategi untuk mengurangi masalah. Yang paling mudah dicapai adalah objek Komposit yang disarankan Pavel (intinya bagaimana C ++ menanganinya). Saya tidak tahu apakah multiple inheritence via linierisasi C3 (atau serupa) ada di kartu untuk masa depan Java, tapi saya ragu.

Jika pertanyaan Anda bersifat akademis, maka solusi yang tepat adalah bahwa Burung dan Kuda lebih konkret, dan salah untuk berasumsi bahwa Pegasus hanyalah gabungan Burung dan Kuda. Akan lebih tepat untuk mengatakan bahwa Pegasus memiliki sifat intrinsik tertentu yang sama dengan Burung dan Kuda (yaitu mereka mungkin memiliki nenek moyang yang sama). Ini dapat dimodelkan secara memadai sebagai jawaban Moritz.

Saya pikir itu sangat tergantung pada kebutuhan Anda, dan bagaimana kelas hewan Anda digunakan dalam kode Anda.

Jika Anda ingin dapat menggunakan metode dan fitur implementasi Kuda dan Burung di dalam kelas Pegasus Anda, maka Anda bisa mengimplementasikan Pegasus sebagai komposisi Burung dan Kuda:

public class Animals {

    public interface Animal{
        public int getNumberOfLegs();
        public boolean canFly();
        public boolean canBeRidden();
    }

    public interface Bird extends Animal{
        public void doSomeBirdThing();
    }
    public interface Horse extends Animal{
        public void doSomeHorseThing();
    }
    public interface Pegasus extends Bird,Horse{

    }

    public abstract class AnimalImpl implements Animal{
        private final int numberOfLegs;

        public AnimalImpl(int numberOfLegs) {
            super();
            this.numberOfLegs = numberOfLegs;
        }

        @Override
        public int getNumberOfLegs() {
            return numberOfLegs;
        }
    }

    public class BirdImpl extends AnimalImpl implements Bird{

        public BirdImpl() {
            super(2);
        }

        @Override
        public boolean canFly() {
            return true;
        }

        @Override
        public boolean canBeRidden() {
            return false;
        }

        @Override
        public void doSomeBirdThing() {
            System.out.println("doing some bird thing...");
        }

    }

    public class HorseImpl extends AnimalImpl implements Horse{

        public HorseImpl() {
            super(4);
        }

        @Override
        public boolean canFly() {
            return false;
        }

        @Override
        public boolean canBeRidden() {
            return true;
        }

        @Override
        public void doSomeHorseThing() {
            System.out.println("doing some horse thing...");
        }

    }

    public class PegasusImpl implements Pegasus{

        private final Horse horse = new HorseImpl();
        private final Bird bird = new BirdImpl();


        @Override
        public void doSomeBirdThing() {
            bird.doSomeBirdThing();
        }

        @Override
        public int getNumberOfLegs() {
            return horse.getNumberOfLegs();
        }

        @Override
        public void doSomeHorseThing() {
            horse.doSomeHorseThing();
        }


        @Override
        public boolean canFly() {
            return true;
        }

        @Override
        public boolean canBeRidden() {
            return true;
        }
    }
}

Kemungkinan lain adalah menggunakan Entity-Component-System alih-alih warisan untuk mendefinisikan hewan Anda. Tentu saja ini berarti, bahwa Anda tidak akan memiliki kelas individu hewan Jawa, tetapi mereka hanya ditentukan oleh komponen mereka.

Beberapa kode pseudo untuk pendekatan Entity-Component-System bisa terlihat seperti ini:

public void createHorse(Entity entity){
    entity.setComponent(NUMER_OF_LEGS, 4);
    entity.setComponent(CAN_FLY, false);
    entity.setComponent(CAN_BE_RIDDEN, true);
    entity.setComponent(SOME_HORSE_FUNCTIONALITY, new HorseFunction());
}

public void createBird(Entity entity){
    entity.setComponent(NUMER_OF_LEGS, 2);
    entity.setComponent(CAN_FLY, true);
    entity.setComponent(CAN_BE_RIDDEN, false);
    entity.setComponent(SOME_BIRD_FUNCTIONALITY, new BirdFunction());
}

public void createPegasus(Entity entity){
    createHorse(entity);
    createBird(entity);
    entity.setComponent(CAN_BE_RIDDEN, true);
}

Anda dapat memiliki hierarki antarmuka dan kemudian memperluas kelas Anda dari antarmuka yang dipilih:

public interface IAnimal {
}

public interface IBird implements IAnimal {
}

public  interface IHorse implements IAnimal {
}

public interface IPegasus implements IBird,IHorse{
}

dan kemudian mendefinisikan kelas Anda sesuai kebutuhan, dengan memperluas antarmuka spesifik:

public class Bird implements IBird {
}

public class Horse implements IHorse{
}

public class Pegasus implements IPegasus {
}

Ehm, kelas Anda bisa menjadi subclass hanya untuk 1 lainnya, tetapi tetap saja, Anda dapat memiliki banyak antarmuka yang diimplementasikan, seperti yang Anda inginkan.

Pegasus sebenarnya adalah seekor kuda (ini adalah kasus khusus dari seekor kuda), yang mampu terbang (yang merupakan "keahlian" dari kuda istimewa ini). Dari sisi lain, Anda dapat mengatakan, Pegasus adalah seekor burung, yang dapat berjalan, dan bertingkat 4 - semuanya tergantung, bagaimana Anda lebih mudah menulis kode.

Seperti dalam kasus Anda, Anda dapat mengatakan:

abstract class Animal {
   private Integer hp = 0; 
   public void eat() { 
      hp++; 
   }
}
interface AirCompatible { 
   public void fly(); 
}
class Bird extends Animal implements AirCompatible { 
   @Override
   public void fly() {  
       //Do something useful
   }
} 
class Horse extends Animal {
   @Override
   public void eat() { 
      hp+=2; 
   }

}
class Pegasus extends Horse implements AirCompatible {
   //now every time when your Pegasus eats, will receive +2 hp  
   @Override
   public void fly() {  
       //Do something useful
   }
}

Antarmuka tidak mensimulasikan banyak pewarisan. Pencipta Jawa menganggap pewarisan berganda salah, jadi tidak ada yang seperti itu di Jawa.

Jika Anda ingin menggabungkan fungsionalitas dua kelas menjadi komposisi objek sekali pakai. Yaitu

public class Main {
    private Component1 component1 = new Component1();    
    private Component2 component2 = new Component2();
}

Dan jika Anda ingin mengekspos metode tertentu, tentukan mereka dan biarkan mereka mendelegasikan panggilan ke controller yang sesuai.

Di sini antarmuka mungkin berguna - jika Component1mengimplementasikan antarmuka Interface1dan Component2mengimplementasikan Interface2, Anda dapat menentukan

class Main implements Interface1, Interface2

Sehingga Anda bisa menggunakan objek secara bergantian di mana konteks memungkinkannya.

Jadi menurut saya, Anda tidak bisa masuk ke masalah berlian.

Seperti yang sudah Anda ketahui, beberapa pewarisan kelas di Java tidak mungkin, tetapi dimungkinkan dengan antarmuka. Anda mungkin juga ingin mempertimbangkan untuk menggunakan pola desain komposisi.

Saya menulis artikel yang sangat komprehensif tentang komposisi beberapa tahun yang lalu ...

/codereview/14542/multiple-inheritance-and-composition-with-java-and-c-updated

1. Tentukan antarmuka untuk menentukan kemampuan. Anda dapat mendefinisikan banyak antarmuka untuk berbagai kemampuan. Kemampuan ini dapat diimplementasikan oleh Hewan atau Burung tertentu .
2. Gunakan warisan untuk membangun hubungan antar kelas dengan membagikan data / metode non-statis dan non-publik.
3. Gunakan Decorator_pattern untuk menambahkan kemampuan secara dinamis. Ini akan memungkinkan Anda untuk mengurangi jumlah kelas & kombinasi warisan.

Lihat contoh di bawah ini untuk pemahaman yang lebih baik

Kapan Menggunakan Pola Penghias?

Untuk mengurangi kompleksitas dan menyederhanakan bahasa, multiple inheritance tidak didukung di java.

Pertimbangkan skenario di mana A, B dan C adalah tiga kelas. Kelas C mewarisi kelas A dan B. Jika kelas A dan B memiliki metode yang sama dan Anda memanggilnya dari objek kelas anak, akan ada ambiguitas untuk memanggil metode kelas A atau B.

Karena kesalahan waktu kompilasi lebih baik daripada kesalahan runtime, java membuat kesalahan waktu kompilasi jika Anda mewarisi 2 kelas. Jadi apakah Anda memiliki metode yang sama atau berbeda, akan ada kesalahan waktu kompilasi sekarang.

class A {  
    void msg() {
        System.out.println("From A");
    }  
}

class B {  
    void msg() {
        System.out.println("From B");
    }  
}

class C extends A,B { // suppose if this was possible
    public static void main(String[] args) {  
        C obj = new C();  
        obj.msg(); // which msg() method would be invoked?  
    }
} 

Untuk memecahkan masalah pewarisan mutiple di antarmuka Java → digunakan

Catatan J2EE (core JAVA) Oleh Tn. KVR Halaman 51

Hari - 27

1. Antarmuka pada dasarnya digunakan untuk mengembangkan tipe data yang ditentukan pengguna.
2. Sehubungan dengan antarmuka kita dapat mencapai konsep multiple inheritans.
3. Dengan antarmuka, kita dapat mencapai konsep polimorfisme, pengikatan dinamis dan karenanya kita dapat meningkatkan kinerja program JAVA dalam ruang memori bergantian dan waktu eksekusi.

Antarmuka adalah konstruksi yang berisi kumpulan metode yang murni tidak ditentukan atau antarmuka adalah kumpulan metode yang sepenuhnya abstrak.

[...]

Hari - 28:

Sintaks-1 untuk menggunakan kembali fitur antarmuka ke kelas:

[abstract] class <clsname> implements <intf 1>,<intf 2>.........<intf n>
{
    variable declaration;
    method definition or declaration;
};

Dalam sintaks di atas, clsname mewakili nama kelas yang mewarisi fitur-fitur dari sejumlah 'n' antarmuka. 'Implements' adalah kata kunci yang digunakan untuk mewarisi fitur antarmuka ke kelas turunan.

[...]

Sintaks-2 mewarisi jumlah antarmuka 'n' ke antarmuka lain:

interface <intf 0 name> extends <intf 1>,<intf 2>.........<intf n>
{     
    variable declaration cum initialization;
    method declaration;
};

[...]

Sintaks-3:

[abstract] class <derived class name> extends <base class name> implements <intf 1>,<intf 2>.........<intf n>
{
  variable declaration;
  method definition or declaration;
};