设计模式以减少冗余

Question

我目前正在设计一个通过操纵声明的字段来大量利用反射的类.因此,很多方法在它们的身体方面都有一些共同点,这有希望用这个java代码来说明:

import java.lang.reflect.Field;

public class foo {
    public void foo1(/* arguments1 */) {
        for (Field f : getClass().getDeclaredFields()) {
            // do some stuff using arguments1
        }
    }

    public void foo2(/* arguments2 */) {
        for (Field f : getClass().getDeclaredFields()) {
            // do some stuff using arguments2
        }
    }

    public void foo3(/* arguments3 */) {
        for (Field f : getClass().getDeclaredFields()) {
            // do some stuff using arguments3
        }
    }

    //and so on...
}

根据这个类最终包含的方法数量,这可能被视为设计缺陷吗？如果我想使用getFields()而不是getDeclaredFields()例如,我将需要替换每一次出现getDeclaredFields().这对我来说听起来不是一个好的编程习惯.在我的情况下,这可能不是一个非常现实的情况,但为了感兴趣,我想知道是否存在解决此问题的设计模式或概念.

[编辑]

为了避免额外的误解:循环中的操作取决于foo1,foo2等给出的参数.并且这些参数对于每个方法并不总是相同.我很难说明这个事实,sry.我改进了给定的代码以更好地演示它.

Answer 1

您可能想要为循环体定义一个接口:

interface FieldOperation {
    void doSomeStuff(Field f);
}

然后,你可以代替写一个循环方法foo1,foo2以及foo3:

public void foo(/* arguments */, FieldOperation op) {
    for (Field f : getClass().getDeclaredFields()) {
        op.doSomeStuff(f);
    }
}

然后,您可以实例化几个FieldOperation对象:

FieldOperation foo1Operation = new FieldOperation() {
    void doSomeStuff(Field f) {
        // do some stuff that used to be in foo1()
    }
}
// etc.

这可以很好地扩展,并将要访问的字段的逻辑与要在每个字段上执行的操作分开.

编辑如果每个都foo*需要一组不同的参数,我建议将它们打包为类:

class Foo1Args { . . . }
class Foo2Args { . . . }
class Foo3Args { . . . }

然后你可以使你的界面通用:

interface FieldOperation<T> {
    void doSomeStuff(Field f, T args);
}

并定义foo为通用方法:

public <T> void foo(T args, FieldOperation<T> op) {
    for (Field f : getClass().getDeclaredFields()) {
        op.doSomeStuff(f, args);
    }
}