java - 减少冗余的设计模式

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):

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);
    }
}