在java中，如何扩展interafce的实现？

我有一个接口，有人答应我提供它的实现

我现在必须设计一个类s.t，我可以扩展“某人的”实现。但是，我不知道该实现的名称

例如

现在，我不知道哪个类将实现X。但我想将这些实现合并到我的代码中

class B extends <Anyclass that implements interface X>
{/*other impl here*/}

B类扩展
{/*此处的其他impl*/}

我该怎么做呢？我知道在泛型中，您可以在使用Comparator时指定。我想知道是否有任何可用于此案例的内容？

这是您的界面：

interface X{ void methodA(int); int methodB();} 

class B extends A {/*other impl here*/}

创建一个抽象的超类：

abstract class A implements X { /*impl code here*/}

现在B（以及扩展A的所有其他类）承诺实现接口：

interface X{ void methodA(int); int methodB();} 

class B extends A {/*other impl here*/}

这是您的界面：

interface X{ void methodA(int); int methodB();} 

class B extends A {/*other impl here*/}

创建一个抽象的超类：

abstract class A implements X { /*impl code here*/}

现在B（以及扩展A的所有其他类）承诺实现接口：

interface X{ void methodA(int); int methodB();} 

class B extends A {/*other impl here*/}

---

因此，您希望X的实例与运行时获得的类具有相同的接口，但允许您指定X的某些方法的行为方式

如果在运行时有一个

A

实例，则可以使用来创建一个对象，该对象实现类实现的所有接口，包括

X

，并重写

X

的某些方法以执行所需操作，并将其余部分委托给该实例

代理类的效率不高，它们提供的动态性通常更容易通过更正常的方式实现，因此不要过度使用它们，但是如果您需要在系统的两个部分之间的边界上使用一点灵活的胶水，它们确实可以帮到您

---

还请注意，生成的对象不是A，它只是实现了与A相同的接口。

因此您需要一个X实例，该实例与您在运行时获得的类具有相同的接口，但允许您指定X的某些方法的行为方式

如果在运行时有一个

A

实例，则可以使用来创建一个对象，该对象实现类实现的所有接口，包括

X

，并重写

X

的某些方法以执行所需操作，并将其余部分委托给该实例

代理类的效率不高，它们提供的动态性通常更容易通过更正常的方式实现，因此不要过度使用它们，但是如果您需要在系统的两个部分之间的边界上使用一点灵活的胶水，它们确实可以帮到您

还要注意，结果对象不是A，它只是实现了与A相同的接口

我现在必须设计一个类s.t，我可以扩展“某人的”实现。但是，我不知道该实现的名称

这是不可能的。Java不允许您

扩展

泛型类型参数。您只能

扩展

命名类

要实现您试图实现的目标，您需要使用某种代理、委托或包装。例如：

public class B implements X {
    private X x;
    public B(X x) {
        this.x = x;
    }

    // delegate each method in the X interface as required; e.g.
    public int someMethod(String s) {
        return x.someMethod(s);
    }

    // add any implementations of B-specific methods.
}

这不完全是“构图”，但我怀疑这是你试图避免的事情。不幸的是（对你来说），没有真正的选择。Java语言和JVM都要求除Object之外的每个类都有一个确定的超类

我现在必须设计一个类s.t，我可以扩展“某人的”实现。但是，我不知道该实现的名称

这是不可能的。Java不允许您

扩展

泛型类型参数。您只能

扩展

命名类

要实现您试图实现的目标，您需要使用某种代理、委托或包装。例如：

public class B implements X {
    private X x;
    public B(X x) {
        this.x = x;
    }

    // delegate each method in the X interface as required; e.g.
    public int someMethod(String s) {
        return x.someMethod(s);
    }

    // add any implementations of B-specific methods.
}

---

这不完全是“构图”，但我怀疑这是你试图避免的事情。不幸的是（对你来说），没有真正的选择。Java语言和JVM都要求除Object之外的每个类都有一个确定的超类。

这里有没有避免组合的原因？如果没有名称，您将无法访问神秘实现。您不能扩展

？扩展X

，但您可以拥有它的一个实例。使用组合时，这相当简单：

interface X
{
 void methodA( int param );
 int methodB();
}

class YourImpl<T extends X> implements X
{
 private T delegate;

 public YourImpl( T delegate )
 {
  this.delegate = delegate;
 }

 void methodA( int param )
 {
  delegate.methodA( param );
 }

 int methodB()
 {
  return delegate.methodB();
 }
}

接口X
{
void methodA（int参数）；
int methodB（）；
}
类YourImpl实现了X
{
私人T代表；
公共项目经理（T代表）
{
this.delegate=委托；
}
void methodA（int参数）
{
代表方法A（参数）；
}
int methodB（）
{
返回delegate.methodB（）；
}
}

在本例中，您不会获得太多好处，但如果您在委派之前/之后进行额外的处理，将获得很多好处

---

一般来说，人们倾向于通过继承来解决他们的问题，即使是在构图更合适的时候。我建议你重新考虑一下作文是否适合你。另一个要考虑的是，神秘的实现是否可以使用你的实现，而不是反之亦然。

< P>你是否有理由避免在这里写文章？如果没有名称，您将无法访问神秘实现。您不能扩展

？扩展X

，但您可以拥有它的一个实例。使用组合时，这相当简单：

interface X
{
 void methodA( int param );
 int methodB();
}

class YourImpl<T extends X> implements X
{
 private T delegate;

 public YourImpl( T delegate )
 {
  this.delegate = delegate;
 }

 void methodA( int param )
 {
  delegate.methodA( param );
 }

 int methodB()
 {
  return delegate.methodB();
 }
}

接口X
{
void methodA（int参数）；
int methodB（）；
}
类YourImpl实现了X
{
私人T代表；
公共项目经理（T代表）
{
this.delegate=委托；
}
void methodA（int参数）
{
代表方法A（参数）；
}
int methodB（）
{
返回delegate.methodB（）；
}
}

在本例中，您不会获得太多好处，但如果您在委派之前/之后进行额外的处理，将获得很多好处

一般来说，人们倾向于通过继承来解决他们的问题，即使是在构图更合适的时候。我建议你重新考虑一下作文是否适合你。另一件需要考虑的是神秘的小鬼。