从两个类扩展 - 开卷题库

小开

创建一个接口 Java 没有多重继承。

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

小开

是的。 slandau 是对的。 Java 不允许从多个类进行扩展。

你想要的可能是 public class Main extends ListActivity implements ControlMenu。我猜你是想列一个清单。

希望能帮上忙。

小开

一般来说，多重继承是不好的，因为钻石问题:

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 + + 和其他语言有一些方法来解决这个问题，例如

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

但 Java 只使用接口。

Java Trails 对接口有很好的介绍: < a href = “ http://download.oracle.com/javase/lessons/Java/views/interface.html”rel = “ noReferrer”> http://download.oracle.com/javase/tutorial/Java/concepts/interface.html 在深入研究 Android API 的细微差别之前，您可能需要遵循这一点。

小开

最佳答案

您只能扩展一个类，并从多个源实现接口。

不能扩展多个类。我能想到的唯一解决方案是不继承任何一个类，而是使用每个类的一个内部变量，并通过将请求重定向到您的对象到您希望它们去的对象来执行更多的代理操作。

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

这是我想到的最好的解决办法。您可以从这两个类获得功能，而且仍然实际上只属于一个类类型。

缺点是您无法使用强制转换来适应内部类的模具。

小开

是的，就像其他人写的那样，你不能用 Java 做多重继承。如果您有两个希望使用代码的类，那么通常只需要子类一个(比如类 A)。对于类 B，您将它的重要方法抽象为一个接口 BInterface(名字很难听，但是您已经明白了) ，然后说 Main extends A implements BInterface。在内部，您可以实例化类 B的一个对象，并通过调用 B的相应函数来实现 BInterface的所有方法。

这将“ is-a”关系改为“ has-a”关系，因为您的 Main现在是 A，但是有 B。根据您的用例，您甚至可以通过从 A类中删除 BInterface而提供一个直接访问 B 对象的方法来显式地进行更改。

小开

Java 不支持多重继承，但你可以尝试实现两个或多个接口。

小开

为什么不使用内部类(嵌套)

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

小开

在 java 中不允许从多个类扩展。阻止死亡之钻！

小开

有可能

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


//blah
}

小开

大家都这么说。不，你不能。然而，尽管多年来人们已经多次表示应该使用多个接口，但他们并没有真正深入研究如何使用多个接口。希望这个能帮上忙。

假设您有 class Foo和 class Bar，您都想尝试扩展到 class FooBar。当然，正如你所说，你不能:

public class FooBar extends Foo, Bar

人们已经在一定程度上探讨了这种现象的原因。相反，为涵盖所有公共方法的 Foo和 Bar编写 interfaces。例如。

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

希望这篇文章能阐明如何使用接口而不是多个扩展，即使我晚了几年。

小开

与另一种选择一样，也许您可以使用具有方法的默认实现的接口。这当然取决于你想做什么。

例如，您可以创建一个抽象类和一个接口:

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

希望这个能帮到你。

小开

Java 的创建者认为多重继承的问题大于好处，所以他们没有包括多重继承。你可以阅读其中一个最大的问题的多重继承(双钻石问题)。

两个最相似的概念是接口实现，并将其他类的对象作为当前类的成员。在接口中使用默认方法几乎与多重继承完全相同，但是只使用默认方法的接口被认为是不好的做法。

小开

你不能在 java 中做多重继承，可以考虑使用接口:

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

或内部课程:

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