观察多个可观察对象同时避免java中的instanceof运算符？

发布于 2024-10-05 22:35:40 字数 169 浏览 1 评论 0 原文

如果我有一个对象，我希望能够观察其他几个可观察对象，而不是所有对象都是同一类型。例如，我希望 A 能够观察 B 和 C。B 和 C 完全不相关，除了它们都实现了 Observable。

显而易见的解决方案就是在更新方法中使用“if instanceof”，但这很快就会变得混乱，因此我想知道是否还有其他方法？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

醉南桥 2024-10-12 22:35:40

一个干净的解决方案是在 A 中使用（匿名）内部类来充当观察者。例如：

class A {
    public A(B b, C c) {
        b.addObserver(new BObserver());
        c.addObserver(new CObserver());
    }

    private class BObserver implements Observer {
        // Logic for updates on B in update method
    }

    private class CObserver implements Observer {
        // Logic for updates on C in update method
    }
}

这将允许您将 BObserver/CObserver 实例添加到任意数量的 B 和 C 中其实很想看。它还有一个额外的好处，即 A 的公共接口不太混乱，并且您可以轻松添加新的内部类来处理类 D、E 和F。

A clean solution would be to use (anonymous) inner classes in A to act as the Observers. For example:

class A {
    public A(B b, C c) {
        b.addObserver(new BObserver());
        c.addObserver(new CObserver());
    }

    private class BObserver implements Observer {
        // Logic for updates on B in update method
    }

    private class CObserver implements Observer {
        // Logic for updates on C in update method
    }
}

This will allow you to add BObserver/CObserver instances to however many Bs and Cs you actually want to watch. It has the added benefit that A's public interface is less cluttered and you can easily add new inner classes to handle classes D, E and F.

回复收藏 0 原文

冰雪梦之恋 2024-10-12 22:35:40

与之前的建议类似，您可以更改更新。

public void update(Observable o, Object arg) {
  try{
    Method update = getClass().getMethod(o.getClass(), Object.class);
    update.invoke(this, o, arg);
  } catch(Exception e) {
    // log exception
  }
}

添加一个方法

public void update(A a, Object arg);
public void update(B b, Object arg);
public void update(C c, Object arg);

通过这种方式，您可以为您想要观察的每种类型。不幸的是，您需要知道 Observable 的确切具体类型。但是，您可以更改反射以允许接口等。

Similar to previous suggestions you could change you update to.

public void update(Observable o, Object arg) {
  try{
    Method update = getClass().getMethod(o.getClass(), Object.class);
    update.invoke(this, o, arg);
  } catch(Exception e) {
    // log exception
  }
}

This way you can add one method

public void update(A a, Object arg);
public void update(B b, Object arg);
public void update(C c, Object arg);

for each type you want to observe. Unfortunately you need to know the exact concrete type of the Observable. However you could change the reflections to allow interfaces etc.

回复收藏 0 原文