Java用户接口

有人可以帮助我理解以下来自Java8函数接口的代码 根据我的理解，accept（）将其作为输入并进行处理，但不返回任何值，然后再讨论它是如何工作的

accept（）方法接受类型T作为输入，不返回任何值

---

defaultconsumer，然后（Consumer为了了解从该API获得的
return
ed是什么，您可以尝试将实现可视化为：

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return new Consumer<T>() { // return the complete Consumer implementation
        @Override
        public void accept(T t) {
            Consumer.this.accept(t); // accept current consumer
            after.accept(t); // and then accept the 'after' one.
        }
    };
}

是一个返回的
使用者
，它确保当前的使用者首先接受

，然后是在之后被称为

的使用者
一个功能界面必须只有一个抽象方法。但是，它可以有您想要的任意多个静态和默认方法。
使用者
的方法有：

accept（T）


这是
Consumer
的单一抽象方法。它接受类型为
T
的单一泛型参数，不返回任何内容（即
void
）。这是由lambda表达式或方法引用实现的方法

第三方（消费者）


这是一个默认的方法。换句话说，它有一个实现，因此是非抽象的。该方法接受一个
消费者
，并返回另一个
消费者
。由于它是一个默认方法，
消费者
的单个抽象方法仍然是
接受（T）

上面解释了为什么
消费者
可以有一个方法返回除
无效
以外的内容。现在，当涉及到
和
的实现时，必须认识到实际上涉及三个
消费者
：

调用了
和
的实例

之后的
引用的实例

实例返回给调用方
如果对代码进行格式化，使所有内容不在同一行上，则可能更容易遵循：

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    // Returns Consumer instance #3. The lambda is the implementation
    // of the 'accept' method.
    return (T t) -> {
        accept(t);       // Invokes 'accept' on Consumer instance #1.
        after.accept(t); // Invokes 'accept' on Consumer instance #2.
    }
}

defaultconsumer和then（Consumer我想我理解您的担忧。您想知道如果
accept（）
返回void，为什么可以在
accept（）之后调用
和then（）

问题是，首先定义一个
消费者
对象，然后在该实例上调用
然后（）调用
方法。例如：

Consumer=s->System.out.println；
然后（s->System.out.println（s.toUpperCase（））；
（T）->{accept（T）；after.accept（T）；}
还是一个
消费者
，它确保当前消费者首先接受
，
之后提到的
是
接受
ed。但是accept方法不返回任何值，那么我们怎么会得到消费者？@NPE返回的值就是全部：
（T）->{accept（T）；after.accept（T）；}
，而不是调用
accept（t）
@Naman
为什么我们必须这样做的结果。这个.accept（t）？我没有得到这个。@如果它只是一个，那么就调用了封闭实例的
accept
方法。没有限定，就调用了当前实例的
accept
方法（
this
）将被调用，导致无限递归。在这种情况下有点混乱，因为我们有一个匿名
消费者
，由另一个
消费者
包围，但它与中给出的示例没有什么不同。
(T t) -> { accept(t); after.accept(t); } 

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    // Returns Consumer instance #3. The lambda is the implementation
    // of the 'accept' method.
    return (T t) -> {
        accept(t);       // Invokes 'accept' on Consumer instance #1.
        after.accept(t); // Invokes 'accept' on Consumer instance #2.
    }
}