Question

我有很多类，每个类都实现GeneralInterface，可能还有其他功能接口：

interface GeneralInterface {}

class MyObjectTypeOne implements GeneralInterface { /*...*/}

class MyObjectTypeTwo implements GeneralInterface, InterOne { /*...*/}

class MyObjectTypeThr implements GeneralInterface, InterOne, InterTwo { /*...*/}

我有一个包含这些MyObjectTypeXXX个实例的列表

class ListHolder {

    public static List<GeneralInterface> list = new ArrayList<>();

    ListHolder() {

        list.add(new MyObjectTypeOne());
        list.add(new MyObjectTypeTwo());
        list.add(new MyObjectTypeTwo());
        // add any number of any of the types
    }
}

和20-40个功能接口。以下是两个例子：

@FunctionalInterface
public interface InterOne {

    boolean onInterOne();

    static void iterate() {

        for (GeneralInterface obj : ListHolder.list) {
            if (obj instanceof InterOne) {
                if (((InterOne) obj).onInterOne())
                    System.out.println("yes");
            }
        }
    }
}

和

@FunctionalInterface
public interface InterTwo {

    boolean onInterOne(String string);

    static void iterate(String string) {

        for (GeneralInterface obj : ListHolder.list) {
            if (obj instanceof InterTwo) {
                if (((InterTwo) obj).onInterTwo(string))
                    System.out.println("yes");
            }
        }
    }
}

在代码的不同位置，我需要调用不同的iterate方法：

InterTwo.iterate("S");
InterOne.iterate();

我的问题是我需要为所有功能接口维护iterate方法，同时它们实际上是相同的：检查对象是否实现了该接口，（转换它）并使用给定的方法调用它的唯一抽象方法参数。

是否有一种方法，通过语法或设计，只维护一个方法来执行此操作？我知道，通过反思，有一种不好的方法可以做到这一点（我只是为了表明我做了我的研究，我不想要它）：

static void iterate(Class<?> clazz, Object arg) {

    for (GeneralInterface obj : ListHolder.list) {
        if (clazz.isAssignableFrom(obj.getClass())) {
            Method[] methods = clazz.getMethods();
            Method functional;
            for (Method m : methods) {
                if (m.getModifiers() == Modifier.ABSTRACT) {
                    functional = m;
                    break;
                }
            }
            if ((boolean) functional.invoke(obj, arg)) // cast arg or do some other trick
                System.out.println("yes");
        }
    }
}

Answer 1

我认为您的代码有一些需要改进的要点，但我只专注于为您提供针对您的具体问题的回复。我认为您需要将该常用方法传递给中间抽象类：

abstract class MyObjectTypeAbstract {
   abstract boolean onInter(String ... testString);
   abstract boolean onInter();
   void iterate(String string) {

       for (GeneralInterface obj : ListHolder.list) {
           if (obj instanceof InterTwo) {
               if (onInter(testString))
                   System.out.println("yes");
           }
       }
   }
   void iterate() {

       for (GeneralInterface obj : ListHolder.list) {
           if (obj instanceof InterTwo) {
               if (onInter())
                   System.out.println("yes");
           }
       }
   }
}

这样做是为了让您实现您提供的每个 FunctionalInterface 似乎唯一不同的东西。这是 onInter 方法。这似乎有所不同。所以我提出了这个摘要。其余的是共享的。我还从iterate方法中取出了 static ，以便他们可以访问onInter方法的不同实现。希望你不需要这个是静态的。因此，我提出的解决方案是让您的类扩展此抽象类，并实现接口。

有没有办法将仅涉及功能接口的方法统一为一个？

1 个答案: