在将扩展类初始化为接口时调用扩展类的方法[重复]

Question

public interface Foo {
}

public class ExtendedFoo implements Foo {
    public void myMethod() {
        System.out.println(1);
    }
}

public class AnotherExtendedFoo implements Foo {
    @Override
    public String toString() {
        return "hello world"
    }
}

public class UnknownImplementedFoo {
    public final Foo foo; // can be either ExtendedFoo OR AnotherExtendedFoo

    public UnknownImplementedFoo(ExtendedFoo f) {
        this.foo = f;
    }

    public UnknownImplementedFoo(AnotherExtendedFoo f) {
        this.foo = f;
    }
}

...
public void myTest() {
    ExtendedFoo f1 = new ExtendedFoo();
    AnotherExtendedFoo f2 = new AnotherExtendedFoo();

    UnknownImplementedFoo ifoo1 = new UnknownImplementedFoo(f1);
    System.out.println(ifoo1.foo.myMethod()); // can't access myMethod!

    System.out.println(ifoo1.type); // prints ExtendedFoo@21599f38
                                    // it knows which type of Foo it is
                                    // so why can't it call its custom methods?

    UnknownImplementedFoo ifoo2 = new UnknownImplementedFoo(f2);
    System.out.println(ifoo2); // prints hello world

}
...

问题显示在最后（myTest 方法），我无法访问扩展接口的类的属性/方法。

有什么解决方法吗？

也就是说，我希望 UnknownImplementedFoo 采用任何实现 Foo 的类（即不仅仅是这两个），同时仍然能够访问公共属性/方法。

Answer 1

警惕The Liskov Substitution Principle。接口是对象的公开声明契约，应该能够在同一段代码中交换接口的不同实现，而不会破坏程序/令人惊讶的副作用。

Java 使想要调用未在接口上声明的方法的情况，但只有其中一个实现变得困难，特别是因为想要这样做标志着一个 OO 设计问题。因此，我强烈鼓励您重新设计您正在使用的类，以便在接口上声明所有公开需要的方法。

也就是说，如果您真的必须解决问题（并且在某些情况下可能需要），那么这里可以采取一些方法。

• 方法一：使用 instanceof 和强制转换 （警告：这会导致代码脆弱，并且经常被 OO 纯粹主义者和负责维护代码的人所反对）

  if ( x instanceof ExtendedFoo ) { ((ExtendedFoo) x).myMethod(); }

• 接近二：Double Dispatch/Visitor Pattern/Command Pattern （警告：这会导致代码需要花费更多精力来遵循和理解，并且它仅在希望每个类具有不同行为时才有效，但它确实具有比使用 instanceof 和强制转换提供更多编译时安全性的优势。技术，但不要过度使用）

  在接口Foo中添加一个方法'public void visit(Visitor v)'。

  访客应该这样声明：

  公共界面访客{ 公共无效访问ExtendedFoo（ExtendedFoo f）； public void visitAnotherExtendedFoo(AnotherExtendedFoo f);
  }

  visit(Visitor) 的实现随后被编码以调用 Visitor 上的适当方法。

• 方法三：Java 8 'default' keyword

  Java 8 现在允许我们向接口上的方法添加实现。这有助于我们将方法添加到接口上，而不必强制为该接口的每个实现添加自定义实现。当方法适合接口的 OO 设计时非常有用，但不要试图根据standard OO advice 添加概念上不属于接口的方法。

• 方法四：反思

  使用 Java 反射在运行时调用方法。这类似于使用 instanceof 和强制转换，主要区别在于一个在编译时执行检查，另一个在运行时执行。

再一次，只有在您已经排除、双重排除和三重排除后才使用上述任何一种技术，并通过同行评审对 OO 设计进行更改（特别是将方法添加到原始界面和/或挑战目的）以及接口的作用）。

Answer 2

你真的在与像 java 这样的强类型语言的工作方式作斗争。

接口的目的之一是通过捕获不同类之间的共同功能来实现多态性。

您正在寻求一种方法来访问一组共享一个通用标记（空）接口的类的非通用特性。

您可以使用反射来询问类实例以获取类型信息，甚至调用方法，但我不知道这将如何为您提供可行的解决方案。

您想研究解决这种情况的四种模式之一。一个例子是命令模式，它抽象了客户端知道在对象上调用了哪些方法的需要：

Command 类包含以下的一些子集：一个对象，一个 要应用于对象的方法，以及要传递的参数 应用该方法时。命令的“执行”方法然后导致 拼凑在一起。

Answer 3

你做一件事给 Foo 接口做一个函数签名。

public interface Foo{
   public void myMethod();
}

Answer 4

使用 Java 泛型获得类型安全的版本。

public class UnknownImplementedFoo<FooType extends Foo> {
    public final FooType foo; // can be either ExtendedFoo OR AnotherExtendedFoo

    public UnknownImplementedFoo(FooType f) {
        this.foo = f;
    }
}

好像理解的有点问题。不知道为什么有 2 票没有评论。

正确使用：

ExtendedFoo f1 = new ExtendedFoo();
AnotherExtendedFoo f2 = new AnotherExtendedFoo();

UnknownImplementedFoo<AnotherExtendedFoo> ifoo1 = new UnknownImplementedFoo<>(f2);
// syntax error
// ifoo1.foo.myMethod()); 

UnknownImplementedFoo<ExtendedFoo> ifoo2 = new UnknownImplementedFoo<>(f1);
// valid
ifoo2.foo.myMethod();