Question

是否可以在Java中执行类似的操作？

class Foo { ... };
class Bar { ... };
class Baz { ... };

Object arr[] = {Foo, Bar, Baz};

更新：

这就是我要避免的事情：

        switch (entity) {
        case "Book":
            switch (action) {
            case "create":
                Book.create();
                break;
            case "read":
                Book.read();
                break;
            case "update":
                Book.update();
                break;
            case "destroy":
                Book.destroy();
                break;
            }
            break;
        case "Author":
            switch (action) {
            case "create":
                Author.create();
                break;
            case "read":
                Author.read();
                break;
            case "update":
                Author.create();
                break;
            case "destroy":
                Author.destroy();
                break;
            }
            break;
        case "Publisher":
            switch (action) {
            case "create":
                Publisher.create();
                break;
            case "read":
                Publisher.read();
                break;
            case "update":
                Publisher.update();
                break;
            case "destroy":
                Publisher.destroy();
                break;
            }
            break;
        }

使用Ruby之类的方法似乎很简单：

my_models = [Book, Publisher, Author]

puts "choose a model"
model = # read from stdin
action = #read action from stdin
my_models[model].call_method(action)

我比Java更习惯Ruby。

Answer 1

如果方法不是公共接口的一部分，则可以制作Runnable函数数组，这些函数包装对静态方法的调用。然后只需将包装函数从数组中取出并run：

class A {
    static void someStaticMethod(int i) {
        System.out.println(i);
    }
}

class B {
    static void someOtherStaticMethod(String s) {
        System.out.println(s);
    }
}

public class HelloWorld{

     public static void main(String []args){
        Runnable[] funcs = {() -> A.someStaticMethod(1),
                            () -> B.someOtherStaticMethod("2")};

        Runnable chosenF = funcs[1];  // Grab a method call from the array

        chosenF.run();  // And run it. Prints 2
     }
}

如果您需要获取或返回数据的方法，则可以使用与所需内容匹配的existing Functional Interface，也可以编写自己的方法。

可以说这是Runnable的“滥用”，因为Runnable旨在用于在另一个线程中执行的功能。不过，在这里工作正常，如果需要，您可以编写自己的版本。

Answer 2

我希望用户能够选择一个数字1-3，然后查找数组中的一个类，并在该类上调用静态方法。在脚本语言中，这似乎很普通，尽管在编译/严格类型化的语言中这似乎是不可能的。

是的，当您只有.class时，可以在类上运行静态方法。以下代码显示了一个Class对象数组，只有一个条目，然后调用了它的特定方法。您应该能够对其进行修改，以包含许多类，然后调用所需的任何方法。

import java.lang.reflect.InvocationTargetException;

public class Example {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class[] classes = new Class[]{A.class};
        classes[0].getMethod("print").invoke(null); // run named method from class in array
    }
}

class A {
    public static void print() {
        System.out.println("static print() method called on: " + A.class);
    }
}

这是我在本地运行时的输出：

static print() method called on: class A

Java中是否可以有一组类？

2 个答案: