Memperluas dari dua kelas

Bagaimana saya bisa melakukan ini:

public class Main extends ListActivity , ControlMenu 

Juga, saya ingin tahu bahwa pendekatan ini baik-baik saja bahwa saya telah membuat menu di kelas yang ControlMenu dan saya memperluas sisa kegiatan.

Anda hanya dapat Perpanjang satu kelas. Dan mengimplementasikan Antarmuka dari banyak sumber.

Memperluas beberapa kelas tidak tersedia. Satu-satunya solusi yang dapat saya pikirkan adalah tidak mewarisi kelas mana pun melainkan memiliki variabel internal masing-masing kelas dan melakukan lebih banyak proxy dengan mengarahkan permintaan ke objek Anda ke objek yang Anda inginkan.

 public class CustomActivity extends Activity {

     private AnotherClass mClass;

     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         mClass = new AnotherClass(this);
     }

     //Implement each method you want to use.
     public String getInfoFromOtherClass()
     {
        return mClass.getInfoFromOtherClass();
     }
 }

ini adalah solusi terbaik yang saya miliki. Anda bisa mendapatkan fungsionalitas dari kedua kelas dan Masih hanya benar-benar satu jenis kelas.

Kekurangannya adalah bahwa Anda tidak dapat masuk ke dalam Cetakan kelas Internal menggunakan gips.

Mengapa Tidak Menggunakan Kelas Batin (Bersarang)

class A extends B {
    private class C extends D {
        //Classes A , B , C , D accessible here 
    }
}

Seperti yang dikatakan semua orang. Tidak bisa. Namun, meskipun orang telah mengatakan berkali-kali selama bertahun-tahun bahwa Anda harus menggunakan banyak antarmuka, mereka belum benar-benar memahami caranya. Semoga ini bisa membantu.

Katakanlah Anda memiliki class Foodan class Barbahwa Anda berdua ingin mencoba memperluas menjadi a class FooBar. Tentu saja, seperti yang Anda katakan, Anda tidak dapat melakukan:

public class FooBar extends Foo, Bar

Orang sudah masuk ke alasan untuk ini sampai batas tertentu sudah. Sebagai gantinya, tulis interfacesuntuk keduanya Foodan Barmencakup semua metode publik mereka. Misalnya

public interface FooInterface {

    public void methodA();

    public int methodB();

    //...
} 

public interface BarInterface {

    public int methodC(int i);

    //...
}

Dan sekarang membuat Foodan Barmengimplementasikan antarmuka relatif:

public class Foo implements FooInterface { /*...*/ }

public class Bar implements BarInterface { /*...*/ }

Sekarang, dengan class FooBar, Anda dapat menerapkan kedua FooInterfacedan BarInterfacesekaligus menjaga Foodan Barobjek dan hanya lewat metode langsung melalui:

public class FooBar implements FooInterface, BarInterface {

    Foo myFoo;
    Bar myBar;

    // You can have the FooBar constructor require the arguments for both
    //  the Foo and the Bar constructors
    public FooBar(int x, int y, int z){
        myFoo = new Foo(x);
        myBar = new Bar(y, z);
    }

    // Or have the Foo and Bar objects passed right in
    public FooBar(Foo newFoo, Bar newBar){
        myFoo = newFoo;
        myBar = newBar;
    }

    public void methodA(){
        myFoo.methodA();
    }

    public int methodB(){
        return myFoo.methodB();
    }

    public int methodC(int i){
        return myBar.methodC(i);
    }

    //...

}

Bonus untuk metode ini, adalah bahwa FooBarobjek cocok dengan cetakan keduanya FooInterfacedan BarInterface. Itu berarti ini baik-baik saja:

FooInterface testFoo;
testFoo = new FooBar(a, b, c);
testFoo = new Foo(a);

BarInterface testBar;
testBar = new FooBar(a, b, c);
testBar = new Bar(b, c);

Semoga ini menjelaskan cara menggunakan antarmuka alih-alih beberapa ekstensi. Bahkan jika saya terlambat beberapa tahun.

Anda ingin menggunakan antarmuka. Secara umum, multiple inheritance buruk karena Masalah Berlian:

abstract class A {
 abstract string foo();
}

class B extends A {
 string foo () { return "bar"; }
}

class C extends A  {
 string foo() {return "baz"; }
}

class D extends B, C {
 string foo() { return super.foo(); } //What do I do? Which method should I call?
}

C ++ dan lainnya punya beberapa cara untuk menyelesaikan ini, mis

string foo() { return B::foo(); }

tetapi Java hanya menggunakan antarmuka.

Java Trails memiliki pengantar yang bagus tentang antarmuka: http://download.oracle.com/javase/tutorial/java/concepts/interface.html Anda mungkin ingin mengikutinya sebelum masuk ke nuansa dalam API Android.

Ya, seperti yang ditulis semua orang, Anda tidak dapat melakukan banyak pewarisan di Jawa. Jika Anda memiliki dua kelas dari mana Anda ingin menggunakan kode, Anda biasanya hanya subkelas satu (katakanlah kelas A). Untuk kelas B, Anda abstrak metode penting itu ke antarmuka BInterface(nama jelek, tetapi Anda mendapatkan ide), lalu katakan Main extends A implements BInterface. Di dalam, Anda dapat membuat instance objek kelas Bdan menerapkan semua metode BInterfacedengan memanggil fungsi yang sesuaiB .

Ini mengubah hubungan "is-a" menjadi hubungan "has-a" seperti Mainsekarang A, tetapi memilikiB . Tergantung pada kasus penggunaan Anda, Anda bahkan dapat membuat perubahan itu secara eksplisit dengan menghapus BInterfacedari Akelas Anda dan sebagai gantinya memberikan metode untuk mengakses objek B Anda secara langsung.

Buat antarmuka. Java tidak memiliki banyak pewarisan.

http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

Java tidak mendukung multiple inheritance, tetapi Anda dapat mencoba mengimplementasikan dua atau lebih antarmuka.

Iya. fitnah benar. Java tidak mengizinkan perluasan dari beberapa kelas.

Apa yang Anda inginkan mungkin public class Main extends ListActivity implements ControlMenu . Saya kira Anda mencoba membuat daftar.

Semoga itu bisa membantu.

Seperti alternatif lain, mungkin Anda dapat menggunakan antarmuka dengan implementasi metode standar. Itu tentu saja tergantung dari apa yang ingin Anda lakukan.

Misalnya, Anda bisa membuat kelas abstrak dan antarmuka:

public abstract class FatherClass {

    abstract void methodInherit() {
        //... do something
    }
}

public interface InterfaceWithDefaultsMethods {
    default void anotherMethod() {
        //... do something
        //... maybe a method with a callable for call another function.
    }
}

Jadi, setelah itu, Anda bisa memperluas dan mengimplementasikan kedua kelas dan menggunakan kedua metode.

public class extends FatherClass implements InterfaceWithDefaultsMethods {

    void methode() {
        methodInherit();
        anotherMethod();
    }
}

Semoga ini bisa membantu Anda ...

Memperluas dari beberapa kelas tidak diperbolehkan di java .. untuk mencegah Deadly Diamond of death !

itu mungkin

public class ParallaxViewController<T extends View & Parallaxor> extends ParallaxController<T> implements AbsListView.OnScrollListener {

//blah
}

Pembuat java memutuskan bahwa masalah multiple inheritance lebih besar daripada manfaatnya, jadi mereka tidak menyertakan multiple inheritance. Anda dapat membaca tentang salah satu masalah terbesar dari multiple inheritance (masalah berlian ganda) di sini .

Dua konsep yang paling mirip adalah implementasi antarmuka dan termasuk objek dari kelas lain sebagai anggota kelas saat ini. Menggunakan metode default di antarmuka hampir persis sama dengan multiple inheritance, namun dianggap praktik yang buruk untuk menggunakan antarmuka dengan metode standar saja.

Anda tidak dapat melakukan banyak pewarisan di java. pertimbangkan menggunakan antarmuka:

interface I1 {}
interface I2 {}
class C implements I1, I2 {}

atau kelas batin:

class Outer {
    class Inner1 extends Class1 {}
    class Inner2 extends Class2 {}
}