Расширение от двух классов

Ответ 1

Вы можете расширить только один класс. И реализуйте интерфейсы из многих источников.

Расширение нескольких классов недоступно. Единственное решение, о котором я могу думать, не наследует ни один из классов, но вместо этого имеет внутреннюю переменную каждого класса и делает больше прокси, перенаправляя запросы к вашему объекту объекту, к которому вы хотите перейти.

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

Это лучшее решение, которое я придумал. Вы можете получить функциональность от обоих классов, и все еще только на самом деле имеют один тип класса.

Недостаток заключается в том, что вы не можете вписаться в форму внутри класса, используя литье.

Ответ 2

Почему бы не использовать внутренний класс (вложенность)

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

Ответ 3

Вы хотите использовать интерфейсы. Как правило, множественное наследование плохо из-за проблемы с алмазом:

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

С++ и другие имеют пару способов решить эту проблему, например

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

но Java использует только интерфейсы.

В Java Trails есть отличное введение в интерфейсы: http://download.oracle.com/javase/tutorial/java/concepts/interface.html Вы, вероятно, захотите следовать этому, прежде чем погрузиться в нюансы в Android API.

Ответ 4

Как говорили все остальные. Нет, ты не можешь. Однако, несмотря на то, что люди много раз говорили на протяжении многих лет, что вы должны использовать несколько интерфейсов, они на самом деле не пошли. Надеюсь, это поможет.

Скажите, что у вас есть class Foo и class Bar, которые вы оба хотите попробовать в class FooBar. Конечно, как вы сказали, вы не можете делать:

public class FooBar extends Foo, Bar

Люди уже в той или иной степени объясняют это. Вместо этого напишите interfaces для Foo и Bar, охватывающих все их общедоступные методы. Например.

public interface FooInterface {

    public void methodA();

    public int methodB();

    //...
} 

public interface BarInterface {

    public int methodC(int i);

    //...
}

И теперь создайте Foo и Bar для реализации относительных интерфейсов:

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

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

Теперь, используя class FooBar, вы можете реализовать как FooInterface, так и BarInterface, сохраняя объект Foo и Bar и просто передавая методы прямо:

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

    //...

}

Бонус для этого метода заключается в том, что объект FooBar соответствует формам как FooInterface, так и BarInterface. Это означает, что это прекрасно:

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

Надеемся, что это поясняет, как использовать интерфейсы вместо нескольких расширений. Даже если я опаздываю на несколько лет.

Ответ 5

Да, как и все остальные, вы не можете выполнять множественное наследование в Java. Если у вас есть два класса, из которых вы хотите использовать код, вы обычно просто подклассифицируете один (скажем, класс A). Для класса B вы абстрагируете важные его методы с интерфейсом BInterface (уродливое имя, но вы получаете идею), а затем скажите Main extends A implements BInterface. Внутри вы можете создать объект класса B и реализовать все методы BInterface, вызвав соответствующие функции B.

Это изменяет отношение "is-a" к отношению "has-a", поскольку ваш Main теперь является A, но имеет B. В зависимости от вашего варианта использования вы можете даже сделать это изменение явным, удалив BInterface из вашего класса A и вместо этого предоставите метод прямого доступа к вашему объекту B.

Ответ 6

Сделайте интерфейс. Java не имеет множественного наследования.

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

Ответ 7

Java не поддерживает множественное наследование, но вы можете попробовать реализовать два или более интерфейса.

Ответ 8

Да. Сланда - это правильно. Java не позволяет распространяться на несколько классов.

Вероятно, вам нужно public class Main extends ListActivity implements ControlMenu. Я предполагаю, что вы пытаетесь составить список.

Надеюсь, что это поможет.

Ответ 9

Расширение от нескольких классов в java запрещено. для предотвращения Смертельный алмаз смерти!

Ответ 10

возможно

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

//blah
}

Ответ 11

Как и другой вариант, возможно, вы можете использовать интерфейс с реализацией метода по умолчанию. Это зависит от того, что вы хотите сделать.

Например, вы можете создать абстрактный класс и интерфейс:

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

Итак, после этого вы можете расширить и реализовать оба класса и используйте оба метода.

public class extends FatherClass implements InterfaceWithDefaultsMethods {

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

Надеюсь, это поможет вам...