java - 如何在 Java 中 DRY 这些代码块？

Question

来电者:

switch (type){
            case "creature":
                Creature returnActor2 = getNextCreature();
                boolean isEat2 = actOnNearby(getRightChromosome(Config.HardCode.creature), returnActor2.getLocation());
                if (isEat2) {
                    actOnCreature(returnActor2);
                }
                break;
            case "monster":
                Monster returnActor3 = getNextMonster();
                boolean isEat3 = actOnNearby(getRightChromosome(Config.HardCode.monster), returnActor3.getLocation());
                if (isEat3) {
                    actOnMonster(returnActor3);
                }
                break;
}

它将调用以下2个方法:

    private Monster getNextMonster() {
        ArrayList<Actor> nearbyActors = getActors();
        Monster mine = new Monster();
        for (Actor a : nearbyActors) {
            if (a instanceof Monster) {
                mine = (Monster) a;
            }
        }
        return mine;
    }


private Creature getNextCreature() {
    ArrayList<Actor> nearbyActors = getActors();
    Creature mine = new Creature();
    for (Actor a : nearbyActors) {
        if (a instanceof Creature) {
            mine = (Creature) a;
        }
    }
    return mine;
}

问题
可以看到，getNextXXXXX()方法都差不多，只是返回不同的对象，逻辑是一样的，如何DRY？ actOnXXXX() 似乎也属于 DRY 类别，但它们都差不多，对不同的对象使用相同的逻辑。如何解决？

Answer 1

让它接受一个类类型:

private <T> T getNext(Class<T> type) {
    for (Actor a : getActors()) {
        if (type.isAssignableFrom(a.getClass())) {
            return (T) a;
        }
    }
    return null; //or type.newInstance(); if you want a guaranteed object, but this restricts your constructor.
}

或者使用 Java 8:

private <T> T getNext(Class<T> type) {
    return (T) getActors().stream()
                .filter(a -> type.isAssignableFrom(a.getClass()))
                .findFirst().orElse(null);
}

但是用法是一样的:

Monster next = getNext(Monster.class);

分解问题，你知道两类事情:

你需要什么:

• t 的下一个对象类型。
• 一种确定对象是否为 t 的方法类型

你有什么:

• 类型t你要
• 一组对象，其中一个可能是 t类型
• 如果不存在则通过无参数构造函数(或 null)创建一个新对象

此外，所有这些方法之间的唯一区别是一件事:它是哪种类型。所以我们从字面上“使它成为一个变量”，因此它成为一个方法参数。

分解它我们只需要以实现此目的的方式组织代码:

method: //receives a "type" as a parameter
    iterate the list of possible `t`s //our list of objects
        if some_t == type //our comparison, previously `a instanceof Type`
            return some_t //our result is found
    return null //or a new object, but essentially our "default"

这里唯一的主要区别是:

1. 替换 some_t instanceof Type与 type.isAssignableFrom(some_t.getClass())

原因是这就是您在使用 Class<T> 时如何确定它

1. 我们的默认值可以是 null 或一个新对象

通过反射动态生成对象会限制您的选择并且有异常需要处理。返回null或一个空的 Optional<T>将有助于表示您没有结果，并且调用者可以采取相应的行动。您也可以只传递默认对象本身，然后返回到 instanceof检查。

问自己同样的假设“我需要什么，我能提供/拥有什么”，将帮助您将问题分解成更小的步骤，并解决更大的难题。