Java Multiple Inheritance


168

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.


6
Saya pikir Anda dapat membuat kelas secara manual dan menyimpannya sebagai anggota (komposisi bukan warisan). Dengan kelas Proxy ( docs.oracle.com/javase/7/docs/api/java/lang/reflect/Proxy.html ) ini mungkin menjadi pilihan, meskipun Anda juga memerlukan antarmuka.
Gábor Bakos

4
@RAM maka itu seharusnya tidak memperpanjang Bird melainkan memiliki perilaku yang akan memungkinkannya untuk mengambil penerbangan. : Masalah D diselesaikan
Yogesh

11
Persis. Bagaimana dengan antarmuka CanFly. :-)
Surprised Coconut

28
Saya pikir ini pendekatan yang salah. Anda memiliki binatang - Kuda, Burung. Dan Anda memiliki properti - Terbang, Karnivora. Pegasus bukan Kuda. Kuda itu bisa terbang. Properti harus dalam antarmuka. Jadi public class Pegasus extends Horse implements Flying.
Boris the Spider

12
Saya mengerti mengapa Anda berpikir itu salah dan tidak mematuhi aturan biologi dan menghargai perhatian Anda tetapi sehubungan dengan program yang perlu saya bangun yang sebenarnya ada hubungannya dengan bank, ini adalah pendekatan terbaik bagi saya. Karena saya tidak ingin memposting masalah saya yang sebenarnya karena itu akan melanggar aturan, saya sedikit mengubah contoh. Terima kasih ...
Sheli

Jawaban:


115

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.


9
Yang ... persis seperti yang dikatakan OP, mereka tahu bisa Anda lakukan di Q.
Brian Roach

4
Karena Pegasus sudah menjadi Kuda (yang terbang), saya pikir Anda bisa menggunakan kembali lebih banyak kode jika memperpanjang Kuda dan mengimplementasikan Avialae.
Pablo Lozano

8
Saya tidak yakin, saya belum melihat Pegasus. Namun, dalam hal ini saya lebih suka menggunakan AbstractHorse, yang juga dapat digunakan untuk membangun Zebra atau binatang seperti kuda lainnya.
Moritz Petersen

5
@MoritzPetersen Jika Anda benar-benar ingin menggunakan kembali abstraksi dan memberikan nama yang bermakna, mungkin AbstractEquidaeakan lebih cocok daripada AbstractHorse. Akan aneh untuk memiliki zebra memperpanjang kuda abstrak. Jawaban yang bagus.
afsantos

3
Menerapkan itik mengetik juga akan melibatkan Duckimplementasi kelas Avialae?
mgarciaisaia

88

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.


Alternatif serupa mungkin juga menggunakan kelas tipe, meskipun itu tidak begitu alami untuk digunakan di Jawa (Anda harus menggunakan metode konverter dan sebagainya), pengantar ini mungkin berguna untuk mendapatkan ide: typeclassopedia.bitbucket.org
Gábor Bakos

1
Ini adalah solusi yang jauh lebih baik daripada pendekatan yang direkomendasikan dalam jawaban yang diterima. Misalnya, jika nanti saya ingin menambahkan "paruh warna" ke antarmuka Bird, saya punya masalah. Pegasus adalah komposit, mengambil elemen dari kuda dan burung tetapi tidak sepenuhnya kuda atau burung. Menggunakan komposisi masuk akal dalam skenario ini.
JDB masih ingat Monica

Tetapi getFlier()harus diterapkan kembali untuk setiap jenis burung.
SMUsamaShah

1
@ LifeH2O Membagi mereka menjadi beberapa blok fungsi bersama kemudian memberi mereka itu. yaitu Anda mungkin memiliki MathsTeacherdan EnglishTeacherkedua mewarisi Teacher, ChemicalEngineer, MaterialsEngineerdll mewarisi Engineer. Teacherdan Engineerkeduanya mengimplementasikan Component. The Personkemudian hanya memiliki daftar Components, dan Anda dapat memberikan mereka hak Components untuk itu Person. yaitu person.getComponent(Teacher.class),, person.getComponent(MathsTeacher.class)dll.
Tim B

1
Ini jawaban terbaik. Sebagai patokan, warisan mewakili "adalah" dan antarmuka mewakili "bisa." Pegasus ADALAH Hewan yang bisa Terbang dan Berjalan. Seekor Burung adalah Hewan yang Bisa Terbang. Seekor Kuda adalah Hewan yang bisa Berjalan.
Robear

43

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

24
Ini akan berhasil, tetapi saya tidak suka pendekatan semacam itu (Wrappper) karena sepertinya Pegasus MEMILIKI seekor kuda, sebaliknya itu ADALAH seekor kuda.
Pablo Lozano

Terima kasih. Saya tidak bisa menahan diri untuk memposting ide itu. Saya agak tahu itu bodoh, tapi saya tidak melihat MENGAPA itu bodoh ...
Pavel Janicek

3
Ini hampir seperti versi pendekatan komposisi yang tidak dibalas dari jawaban Tim B.
Stephan

1
Ini kurang lebih cara yang diterima untuk melakukannya, meskipun Anda juga harus memiliki sesuatu seperti IJumps dengan metode "lompatan" yang diterapkan oleh Horse dan Pegasus dan IFlies dengan metode "terbang" yang diterapkan oleh Bird dan Pegasus.
MatsT

2
@Pablo no, a Pegasus HAS horseFeatures dan HAS birdFeatures. +1 untuk jawabannya karena menjaga kode tetap sederhana, tidak seperti solusi Java clunkier, class-spawning, dan tepat.
JaneGoodall

25

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.


19

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.


13

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.


1
Perlu diketahui bahwa jika Burung dan Kuda Anda berdua memiliki metode default, Anda masih akan menghadapi masalah berlian, dan harus menerapkannya secara terpisah di kelas Pegasus Anda (atau mendapatkan kesalahan kompilator).
Mikkel Løkke

@Mikkel Løkke: Kelas Pegasus harus mendefinisikan override untuk metode yang ambigu tetapi dapat mengimplementasikannya dengan hanya mendelegasikan ke metode super (atau keduanya dalam urutan yang dipilih).
Holger

12

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 .


Jika saya membaca analogi Anda dengan benar, Anda mengatakan bahwa pada awalnya antarmuka tampak hebat, karena mereka membiarkan Anda menyelesaikan masalah desain, misalnya Anda dapat menggunakan API orang lain dengan memaksa kelas Anda melalui antarmuka mereka. Tetapi setelah beberapa tahun, Anda menyadari bahwa masalahnya adalah desain yang buruk untuk memulai.
CS

8

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.


6

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

4

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

1
Atau dia bisa saja: Kelas publik Pegasus memperluas Animal Implements Horse, Bird
Batman

OP sudah mengetahui solusi ini dia sedang mencari cara alternatif untuk melakukannya
Yogesh

@Batman, tentu saja dia bisa tetapi jika dia ingin memperpanjang hierarki dia harus mengikuti pendekatan ini
richardtz

IBirddan IHorseharus menerapkan IAnimalbukannyaAnimal
oliholz

@Yogesh, kamu benar. Saya mengabaikan tempat dia menyatakannya. Sebagai seorang "pemula" apa yang harus saya lakukan sekarang, hapus jawabannya, atau tinggalkan di sana ?, terima kasih.
richardtz

4

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

3

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.


Tidak salah dengan cara yang sama dengan pointer memori langsung, tipe yang tidak ditandatangani, dan kelebihan operator tidak salah; tidak perlu menyelesaikan pekerjaan. Java dirancang sebagai bahasa ramping yang mudah untuk diambil. Jangan mengada-ada dan berharap yang terbaik, ini adalah bidang pengetahuan, bukan tebakan.
Gimby


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


2

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

2

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;
};
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.