Java中的函数指针数组
我已经阅读了这个问题 ，我仍然不确定是否有可能在Java中保持数组中方法的指针，如果有人知道这是否可能，那将是一个真正的帮助。 我正试图找到一个优雅的解决方案，保持一个字符串列表和相关的function，而不会写成数百个’if’的混乱。
干杯
Java本身没有函数指针（或C＃用语中的“委托”）。 这类事情往往是使用匿名子类完成的。
public interface Worker { void work(); } class A { void foo() { System.out.println("A"); } } class B { void bar() { System.out.println("B"); } } A a = new A(); B b = new B(); Worker[] workers = new Worker[] { new Worker() { public void work() { a.foo(); } }, new Worker() { public void work() { b.bar(); } } }; for (Worker worker : workers) { worker.work(); } 您可以使用仿函数模式获得相同的结果。 例如，有一个抽象类：
abstract class Functor { public abstract void execute(); }
您的“函数”实际上是派生类中的execute方法。 然后你创建一个仿函数数组并用适当的派生类填充它：
class DoSomething extends Functor { public void execute() { System.out.println("blah blah blah"); } } Functor [] myArray = new Functor[10]; myArray[5] = new DoSomething();
然后你可以调用：
myArray[5].execute();
有可能，您可以使用Method数组。 使用Reflection API抓住它们（编辑：它们不是函数，因为它们不是独立的，必须与类实例相关联，但它们可以完成工作 – 只是不要期望像闭包这样的东西）
Java没有指针（只有引用），它也没有函数（只有方法），所以它不可能有指向函数的指针。 您可以做的是定义一个包含单个方法的接口，让您的类提供这样的方法声明它们实现所述接口，并创建一个引用此类接口的向量，以填充对特定对象的引用你想要调用那个方法。 当然，唯一的约束是所有方法必须具有相同的签名（参数的数量和类型以及返回的值）。
否则，您可以使用reflection/内省（例如Method类），但这通常不是最简单，最自然的方法。
我发现reflection方法最干净 – 我为这个解决方案添加了一个改进，因为大多数生产类都有嵌套类，我没有看到任何演示这个的例子（但我也没有看很长时间）。 我使用reflection的原因是我的下面的“ updateUser() ”方法有一堆冗余代码，只有一行改变了（用户对象中的每个字段）更新用户对象的中间：
NameDTO.java
public class NameDTO { String first, last; public String getFirst() { return first; } public void setFirst(String first) { this.first = first; } public String getLast() { return last; } public void setLast(String last) { this.last = last; } }
UserDTO.java
public class UserDTO { private NameDTO name; private Boolean honest; public UserDTO() { name = new NameDTO(); honest = new Boolean(false); } public NameDTO getName() { return name; } public void setName(NameDTO name) { this.name = name; } public Boolean getHonest() { return honest; } public void setHonest(Boolean honest) { this.honest = honest; } }
Example.java
import java.lang.reflect.Method; public class Example { public Example () { UserDTO dto = new UserDTO(); try { Method m1 = dto.getClass().getMethod("getName", null); NameDTO nameDTO = (NameDTO) m1.invoke(dto, null); Method m2 = nameDTO.getClass().getMethod("setFirst", String.class); updateUser(m2, nameDTO, "Abe"); m2 = nameDTO.getClass().getMethod("setLast", String.class); updateUser(m2, nameDTO, "Lincoln"); m1 = dto.getClass().getMethod("setHonest", Boolean.class); updateUser(m1, dto, Boolean.TRUE); System.out.println (dto.getName().getFirst() + " " + dto.getName().getLast() + ": honest=" + dto.getHonest().toString()); } catch (Exception e) { e.printStackTrace(); } } public void updateUser(Method m, Object o, Object v) { // lots of code here try { m.invoke(o, v); } catch (Exception e) { e.printStackTrace(); } // lots of code here -- including a retry loop to make sure the // record hadn't been written since my last read } public static void main(String[] args) { Example mp = new Example(); } }
你是对的，java中没有指针，因为引用变量与C / C ++中的＆语法相同，只保存对象的引用但没有*，因为JVM可以在必要时重新分配堆，导致指针丢失导致崩溃的地址。 但是一个方法只是一个类对象内部的一个函数，只不过是这样你就错了，说没有函数，因为一个方法只是一个封装在一个对象中的函数。 至于函数指针，java团队认可使用接口和嵌套类都很好，但是作为一个不时使用java的C ++ / C＃程序员，我使用我为java制作的Delegate类，因为我发现当我需要传递一个只需要声明方法委托的返回类型的函数时，它更方便。 这一切都取决于程序员。 我阅读了关于为什么代表不支持的白页，但我不同意并且更喜欢在该主题的框外思考。