java - 有没有更好的方法来短路 instanceof 链？

Question

我的类(class)最初是从几个单独的 addAListener() addBListener() 和 removeAListener 等开始的。这对一个来说还不错类，但当该类被另一个类在内部使用并且扩展的监听器传播出去时，它确实向外爆炸。

一个简单的解决方案是使用单一接口(interface)并使用instanceof 对监听器进行分类:

public interface Listener {
}

public class ListenerA extends Listener {
}

public class ListenerB extends Listener {
}

public class ListenerC extends Listener {
}

List<ListenerA> ofListenersA = new List<>();
List<ListenerB> ofListenersB = new List<>();
List<ListenerC> ofListenersC = new List<>();

void addListener(Listener listener) {
    if (listener instanceof ListenerA) {
        ofListenersA.add(listener);

        return;
    }

    if (listener instanceof ListenerB) {
        ofListenersB.add(listener);

        return;
    }

    if (listener instanceof ListenerB) {
        ofListenersB.add(listener);

        return;
    }
}

void removeListener(Listener listener) {
    if (listener instanceof ListenerA) {
        ofListenersA.remove(listener);

        return;
    }

    if (listener instanceof ListenerB) {
        ofListenersB.remove(listener);

        return;
    }

    if (listener instanceof ListenerB) {
        ofListenersB.remove(listener);

        return;
    }
}

但现在我必须单独评估每个 instanceof，因为你不能在一个类上 switch。

这不是要求优化的尝试，因为我没有多种类型的监听器可供检查；而是一个问题，即在面向对象设计方面，这是否是一种糟糕的方法。

更新

在接口(interface)中使用枚举的短路方法:

enum ListenerType {
    ListenerTypeA,
    ListenerTypeB,
    ListenerTypeC
}

public interface Listener {
    ListenerType getType();
}

public class ListenerA extends Listener {
    ListenerType getType() {
        return ListenerType.ListenerTypeA;
    }
}

public class ListenerB extends Listener {
    ListenerType getType() {
        return ListenerType.ListenerTypeB;
    }
}

public class ListenerC extends Listener {
    ListenerType getType() {
        return ListenerType.ListenerTypeC;
    }
}

List<ListenerA> ofListenersA = new List<>();
List<ListenerB> ofListenersB = new List<>();
List<ListenerC> ofListenersC = new List<>();

void addListener(Listener listener) {
    switch (listener) {
        case ListenerTypeA: {
            ofListenersA.add(listener);

            return;
        }
        case ListenerTypeB: {
            ofListenersB.add(listener);

            return;
        }
        case ListenerTypeC: {
            ofListenersC.add(listener);

            return;
        }
    }
}

void removeListener(Listener listener) {
    switch (listener) {
        case ListenerTypeA: {
            ofListenersA.remove(listener);

            return;
        }
        case ListenerTypeB: {
            ofListenersB.remove(listener);

            return;
        }
        case ListenerTypeC: {
            ofListenersC.remove(listener);

            return;
        }
    }
}

Answer 1

我建议您添加一个类型来指定您感兴趣的监听器类型。您也可以将键更改为其他内容，例如带有 hashCode 和 equals 的常规类。

enum ListenerType {
    TYPE_A, TYPE_B, TYPE_C
}

interface Listener {

}

Map<ListenerType, Set<Listener>> listeners = new ConcurrentHashMap<>();

public void addListener(ListenerType type, Listener listener) {
    listeners.computeIfAbsent(type, k -> Collections.newSetFromMap(new ConcurrentHashMap<>())).add(listener);
}

public void removeListener(ListenerType type, Listener listener) {
    listeners.computeIfPresent(type, (k, v) -> v.remove(listener) && v.isEmpty() ? null : v);
}

public Set<Listener> getListeners(ListenerType type) {
    return listeners.getOrDefault(type, Collections.emptySet());
}