假设我有接口MyInterface和2个实现MyInterface的类A，B。
我声明了2个对象：" MyInterface a = new A()"和" MyInterface b = new B()"。
当我尝试传递给函数函数doSomething(A a){}时，出现错误。

这是我的代码：

public interface MyInterface {}

public class A implements MyInterface{}

public class B implements MyInterface{}

public class Tester {

    public static void main(String[] args){
        MyInterface a = new A();
        MyInterface b = new B();
        test(b);
    }

    public static void test(A a){
        System.out.println("A");
    }

    public static void test(B b){
        System.out.println("B");
    }

}

我的问题是，我从某种可以是各种类的组件接口中获取，我需要为每个类编写函数。

因此，一种方法是获取接口并检查其类型。 (A的实例)

我想知道其他人如何处理这个问题？

解决方案

谢谢

我不清楚我们实际上要问什么，但是问题是我们没有采用类型为MyInterface的参数的方法。我不知道Java中的确切语法是什么，但是我们可以执行if(b is B){test(b as B)}这样的操作，但我不会。如果需要通用，则使用MyInterface类型作为变量类型，否则使用B作为变量类型。我们无法达到使用界面的目的。

我们不仅可以在每个类都实现的接口上有一个方法吗？还是我们无法控制界面？

这样既可以提供多态性，又可以避免定义任何外部方法。我相信这是接口的意图，它允许客户端以非特定于类型的方式对待实现该接口的所有类。

如果无法添加到接口，则最好使用适当的方法引入第二个接口。如果我们既不能编辑接口也不能编辑类，则需要一个以该接口为参数的方法，然后检查具体的类。但是，这应该是最后的选择，它会颠覆接口的使用，并将该方法与所有实现联系起来。

public abstract class Parent {}

  public class A extends Parent {...}

  public class B extends Parent {...}

我认为访客设计模式会在这里为我们提供帮助。基本思想是让类(A和B)自己调用适当的方法，而不是尝试确定要调用的方法。作为Cguy，我希望我的Java能够正常工作：

public interface Visitable {   
   void accept(Tester tester) 
}

public interface MyInterface implements Visitable {    
}

public class A implements MyInterface{
   public void accept(Tester tester){
       tester.test(this);
   }
}

public class B implements MyInterface{
   public void accept(Tester tester){
       tester.test(this);
   }
}

public class Tester {

    public static void main(String[] args){
        MyInterface a = new A();
        MyInterface b = new B();
        a.accept(this);
        b.accept(this);
    }

    public void test(A a){
        System.out.println("A");
    }

    public void test(B b){
        System.out.println("B");
    }

}

我不确定我是否完全理解这个问题，但是似乎一种方法可能是将test()方法移到子类中：

我们可以类似地使用toString()方法并打印结果。但是，从要求来看，我无法完全确定。

public interface MyInterface {    
    public void test();
}

public class A implements MyInterface{
    public void test() {
        System.out.println("A");
    }
}

public class B implements MyInterface{
    public void test() {
        System.out.println("B");
    }
}

public class Tester {

    public static void main(String[] args){
        MyInterface a = new A();
        MyInterface b = new B();
        b.test();
    }
}

听起来我们正在追寻像这样的事情：

但是请注意，这是非常糟糕的形式，表示设计中出现了严重的错误。如果我们无法控制该接口，那么如marcj所建议的那样，添加第二个接口可能是可行的方法。请注意，我们可以在保持二进制兼容性的同时执行此操作。

• 访客模式；我们将需要更改MyInterface类型以包括方法visit(Visitor)，其中" Visitor"类包含用于访问每个子类的许多方法。
• 在方法test(MyInterface)中使用if-else在它们之间进行检查
• 使用链接。也就是说，声明处理程序" ATester"，" BTester"等，它们都实现了具有方法" test(MyInterface)"的接口" ITester"。然后在" ATester"中，在进行填充之前检查类型是否等于A。然后，主要Tester类可以具有一个由这些测试器组成的链，并将每个" MyInterface"实例向下传递，直到到达可以处理它的" ITester"。基本上，这是将if-else块从2转换为单独的类。

我们有3种选择：

就我个人而言，在大多数情况下我会争取2. Java缺乏真正的面向对象。处理吧！围绕它提出各种解决方案通常只会导致难以理解的代码。

听起来我们需要a)通过将方法放在MyInterface上并在A和B中实现来利用多态性，或者b)Composite和Visitor设计模式的某种组合。当事情变得笨拙时，我将从a)开始，然后朝b)前进。

我对访客的广泛想法：

段落数量不匹配

代码数量不匹配