Question

我正在尝试创建一个具有以下内容的工作队列类（FooQueue）：

一组做功的成员（do *）。每个参数都有一个参数，具有相同的类型（FooItem）。
a＆＃39;添加＆＃39;带有2个参数的函数：上述函数之一和FooItem。最重要的是，add函数应该只能接受FooQueue类的成员函数，而不是具有类似签名的另一个类的成员函数

当do函数是静态时，代码编译，但是当函数是非静态函数时，编译时，即使根据this实例函数成员的定义是正确的。

应该更改什么才能使其编译/运行？

public class App {
    public static void main( String[] args ) {
        FooQueue q = new FooQueue();
        q.add( FooQueue::dos, new FooItem() );    // this compiles
        q.add( q::do1, new FooItem() );           // this does not:
                                                  // does not consider q::do1 'delegate'
                                                  // as taking 2 parameters,
                                                  // with q being the first one
        FooQueue q2 = new FooQueue2();
        q.add( FooQueue2::dos, new FooItem() );   // want this to give compiler error
        q.add( FooQueue2::do1, new FooItem() );   // want this to give compiler error
    }
}

public class FooQueue {
    public static void dos( FooQueue q, FooItem item ) {
        System.out.println( "FooQueue:sdo" );
    }
    public void do1( FooItem item ) {
        System.out.println( "FooQueue:do1" );
    }
    public void add( java.util.function.BiConsumer<FooQueue,FooItem> func, FooItem wi ) {
        System.out.println( "FooQueue:addWorkItem2" );
        func.accept( this, wi );
    }
}
public class FooItem {
}
public class FooQueue2 {
    public static void dos( FooQueue2 q2, FooItem item ) {
        System.out.println( "FooQueue2:sdo" );
    }
    public void do1( FooItem item ) {
        System.out.println( "FooQueue2:do1" );
    }
}

Answer 1

它与静态/非静态方法无关，也与泛型无关，只与BiConsumer定义有关。

BiConsumer需要两个参数，因此您需要需要两个参数且不返回任何参数的lambda。

要解决此问题，请使用实例方法参考：

FooQueue q = new FooQueue();
q.add(FooQueue::do1, new FooItem());

不要将它与静态方法引用混淆。 FooQueue::do1是lambda的合成糖：

(qInstance, item) -> qInstance.do1(item));

此方法允许您仅接受来自FooQueue的方法。

请注意，q:do1与BiConsumer不兼容，因为它已转换为：

(item) -> q.do1(item)

详细了解Instance method reference

包含不同类的完整示例

public class App {
    public static void main(String[] args) {
        FooQueue q = new FooQueue();
        FooQueue2 q2 = new FooQueue2();

        q.add(FooQueue::do1, new FooItem());
        // Equals to:
        q.add((qInstance, item) -> qInstance.do1(item), new FooItem());

        // q.add(FooQueue2::do1, new FooItem());  // not compile
    }
}

class FooQueue {
    void do1(FooItem item) {
        System.out.println("FooQueue:do1");
    }

    void add(BiConsumer<FooQueue, FooItem> func, FooItem wi) {
        System.out.println("FooQueue:addWorkItem");
        func.accept(this, wi);
    }
}

// class that pretends to be FooQueue
class FooQueue2 {
    void do1(FooItem item) {
        System.out.println("FooQueue2:do1");
    }
}

class FooItem {
}

在java中传递和强制执行成员函数

1 个答案: