在Java中，是否可以将一行代码作为方法参数？

我似乎在谷歌上找不到任何关于这方面的信息，我也不确定这是否可能。我想做的是，将一行Java代码作为参数传递给一个方法。Google只显示将cmd行参数传递给方法的结果，但我想传递一行实际的代码

基本上我想把methodA传递给methodB，除了methodA不是一个方法，而是一行代码。下面是使用反射将方法传递给方法的完整示例

public class Relation<T> {

protected Set<Pair<T,T>> pairs = null;

public Relation() {
    this.pairs = new LinkedHashSet<Pair<T,T>>();
}

    /* Next 2 methods are methods for sending methods to methods useing java.lang.reflect.Method */
    public Method getMethod(String name) {
        try {   return Relation.class.getDeclaredMethod(name);
        } catch (Exception e) {} 
        return null;
    }

    public boolean execute(Method method, Object... params) {
        try {   return (Boolean) method.invoke(this, params);
        } catch (Exception e) {}
        return false;
    }

    /* The method I reuse several times so I just put methods inside of it */   
    public boolean pairsTFIterator(Method method)  {
        for(Pair<T,T> x : pairs) {
            boolean bool = false;
            for(Pair<T,T> y : pairs) {
                if(execute(method, x,y))    
                    bool = true; break;
            }
            if(!bool) return false;
        }
        return true;
    }

    /* To be replaced by the line of code*/   
    public static <T> boolean isSymmetricPairs(Pair<T,T> a, Pair<T,T> b) {
        return a.getFirst().equals(b.getSecond()) && a.getSecond().equals(b.getFirst()) ? true :false;
    }

    /* Method that calls others */
    public boolean isSymmetric() {
        return pairsTFIterator(getMethod("isSymmetricPairs"));
    }
}

---

我很确定这是不可能的，但如果有办法的话，那就太好了

听起来你想要的是“一流的函数”。有些语言将函数视为变量，也就是说，可以将它们指定给变量，并将它们作为参数传递给其他函数。Java8将引入lambda表达式的概念，它将支持这种类型的功能

还有其他JVM语言已经提供了这一功能，其中包括Scala和Groovy，这是两种比较流行的语言

为了让您了解它的外观，在Groovy中，您可以通过调用each（）方法并向其传递闭包（本质上是一个函数），在集合的每个元素上执行任意函数

---

将代码放入匿名操作系统内部类可能会满足您的要求：

    interface PairFilter<T>{
        boolean filter(Pair<T, T> a, Pair<T,T> b);
    }

接口配对过滤器{
布尔滤波器（对a、对b）；
}

在迭代器方法中：

    public boolean pairsTFIterator(PairFilter filter) {
        for(Pair<T,T> x : pairs) {
            boolean bool = false;
            for(Pair<T,T> y : pairs) {
                if(filter.filter(x,y))    
                    bool = true; break;
                }
                if(!bool) return false;
        }
        return true;
    }

公共布尔pairstfilter（PairFilter过滤器）{
用于（对x:对）{
布尔布尔布尔=假；
用于（y对：对）{
if（filter.filter（x，y））
bool=true；break；
}
如果（！bool）返回false；
}
返回true；
}

那就叫它：

    pairsTFIterator(new PairFilter<T>(){
        public boolean filter(Pair<T, T> a, Pair<T,T> b){
            return a.getFirst().equals(b.getSecond()) && a.getSecond().equals(b.getFirst()) ? true :false;
        }
    });

pairstfilter（新的PairFilter（））{
公共布尔过滤器（对a、对b）{
返回a.getFirst（）.equals（b.getSecond（））和&a.getSecond（）.equals（b.getFirst（））？true:false；
}
});

否，这不可能直接实现。您可以解析该行并生成相应的代码。有些表达式语言就是这样做的，这就是Java。实现这一点的惯用方法（直到）是创建一个接口并匿名实现它，就像在Java中处理任何其他事件一样。我不太理解您的规范。refelection是一个需求，或者您可以知道如何使用v8lambda或（8之前的）Functor来封装您想要的内容吗？函子是一个“函数”，但一行代码显然可以封装成一行…假设您不打算“动态”编写代码。我昨天刚刚写了这个：。如果我理解你的意思，这个答案（实际上是一篇完整的博客文章）应该会有帮助。

    public boolean pairsTFIterator(PairFilter filter) {
        for(Pair<T,T> x : pairs) {
            boolean bool = false;
            for(Pair<T,T> y : pairs) {
                if(filter.filter(x,y))    
                    bool = true; break;
                }
                if(!bool) return false;
        }
        return true;
    }

    pairsTFIterator(new PairFilter<T>(){
        public boolean filter(Pair<T, T> a, Pair<T,T> b){
            return a.getFirst().equals(b.getSecond()) && a.getSecond().equals(b.getFirst()) ? true :false;
        }
    });