Question

假设我有A类和B类以及一个名为Message

的接口

public interface Message{
   public void sendMessage();
}

public class A implements Message{
   @Override
    public void sendMessage(){
      //call the sendMessage() in class B.
    }
}

public class B implements Message{
    @Override
     public void sendMessage(){
       System.out.println("Hola Stack!");
      }

 }

没有直接引用B类，我可以以某种方式从类A调用B类中的sendMessage（）方法吗？

Answer 1

当然可以。

class ClassA {
    private Message message;

    public ClassA(Message message) {
        this.message = message:
    }

    public void sendMessage() {
        message.sendMessage();
    }
}

只需将B的实例传递给A：

Message b = new ClassB();
Message a = new ClassA(b);
a.sendMessage();

Answer 2

你在这里滥用界面。当然，你可以使用

    Message a = new B();
`   a.sendMessage();

这将做你想要的，但不是想要的练习而不是你想要的。如果你想要A和B是可以互换的，你应该创建一个超级类，让B继承它，这样就删掉了界面：

public class A {

    public void sendMessage(){
      //call the sendMessage() in class B.
    }
}

public class B extends A{
    @Override
     public void sendMessage(){
       System.out.println("Hola Stack!");
      }

 }

这样你可以这样做：

A a = new B();
a.sendMessage(); //  prints inside of B, but you tell the JVM to forget it is B, and think it is A

请记住，如果您希望类可以互换，则子类必须具有A的所有功能，并且您不能使用未在A中定义的B的功能（作为具体或抽象方法）

Answer 3

您至少可以使用以下两种设计模式来解决您的问题：

观察者
调解人

根据您的应用程序的使用情况，一个可能会比其他应用程序更好，但是两者都可以解决对象之间的高度耦合问题。它们之间的区别在于，观察者模式将引入“观察者”和“主题”对象，而中介者将封装对象之间的通信。您可以使用以下两个界面将两种模式结合用于解决方案：

import java.util.*; 

public class TestAB {

    public static void main(String args[]) {

        Mediator messageBus = new Mediator();

        ClassA objA = new ClassA();

        ClassB objB = new ClassB();
        messageBus.register("ClassB", objB);

        objA.sendMessage(messageBus, "ClassB", "Hello class B!");
    }
}

class ClassA {

    public void sendMessage(Mediator bus, String dest, String text) {
        // send message to the sendMessage() in class B.
        bus.sendMessage(new Message() {
            public String getDestination() { return dest; }
            public String getText() { return text; }
        });
    }

}

class ClassB implements Observer {

    public void sendMessage(Message msg){
        System.out.println("sendMessage from ClassB received: "+ msg.getText());
    }
    public String getId(){
        return "B";
    }
    public void onMessage(Message msg) {
        // listen to message calls from the message bus (Mediator)
        sendMessage(msg);
    }
}

interface Message {
    public String getDestination();
    public String getText();
}

interface Observer {
    public String getId();
    public void onMessage(Message msg);
}

class Mediator {
    Map<String, Observer> observerList = new HashMap<String, Observer>();
    protected void register(String id, Observer obj) {
        observerList.put(id, obj);
    }
    protected void sendMessage(Message msg) {
        Observer obj = observerList.get(msg.getDestination());
        obj.onMessage(msg);
    }
}

所有想要接收消息的类都需要实现Observer接口，在这种情况下，B实现Observer接口并在某些消息到达时调用其自己的“ sendMessage”方法。最后，我们创建了一个带有中介对象（消息总线）的TestAB类，该对象负责将消息从A对象传递到B对象。

为简单起见，我尝试避免对实现进行一些改进，如果您想进一步了解这些模式，可以在以下链接中获取更多信息

https://sourcemaking.com/design_patterns/mediator

是否可以使用接口与java中的另一个类说话？

3 个答案: