如何在Java中干掉这些代码块?

前端之家收集整理的这篇文章主要介绍了如何在Java中干掉这些代码块?前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。
呼叫者:
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;
}

它将调用以下两种方法

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()方法非常相似,只返回不同的对象,逻辑相同,如何干? actOnXXXX()似乎也属于DRY类别,但它们大致相同,对不同的对象使用相同的逻辑.怎么解决这个?

解决方法

让它接受一个classtype:
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类型
>通过no-args构造函数的新对象(如果没有,则为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"

这里唯一的主要区别是:

>用type.isAssignableFrom(some_t.getClass())替换some_t instanceof类型

这里的原因是,当您使用Class< T>时,这就是您如何确定这一点的原因.

>我们的默认值可以是null或新对象

通过反射动态制作对象会限制您的选项并具有处理异常.返回null或空可选< T>将有助于表明您没有结果,并且呼叫者可以采取相应行动.您也可能只是传递默认对象本身,然后返回到instanceof检查.

问自己这个相同的假设“我需要什么,我能提供什么/有什么”,这将有助于你将问题分解为更小的步骤,并解决更大的难题.

原文链接:https://www.f2er.com/java/121410.html

猜你在找的Java相关文章