package java.util.function;

import java.util.Objects;

/**
 *
 * 表示“接受一個參數輸入且沒有任何返回值的操作“。不同於其它的函數式接口，Consumer期望通過方法的實現來執行具體的操作。
 
 */
@FunctionalInterface
public interface Consumer<T> {

    /**
     * 可實現方法，接受一個參數且沒有返回值
     */
    void accept(T t);

    /**
     * 
     * 默認方法，提供鏈式調用方式執行。執行流程：先執行本身的accept在執行傳入參數after.accept方法。
     * 該方法會拋出NullPointerException異常。
     * 如果在執行調用鏈時出現異常，會將異常傳遞給調用鏈功能的調用者，且發生異常後的after將不會在調用。
     * 
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
 
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

package jdk8;

import java.util.function.Consumer;

public class ConsumerTest {

    public static void main(String[] args) {
 
        testConsumer();
        testAndThen();
    }

    /**
     * 一個簡單的平方計算
     */
    public static void testConsumer(){
        Consumer<Integer> square = x -> System.out.println("print square : " + x * x);
        square.accept(2);
    }

    /**
     * 定義3個Consumer並按順序進行調用andThen方法，其中consumer2拋出NullPointerException。
     */
    public static void testAndThen(){
        Consumer<Integer> consumer1 = x -> System.out.println("first x : " + x);
        Consumer<Integer> consumer2 = x -> {
            System.out.println("second x : " + x);
            throw new NullPointerException("throw exception test");
        };
        Consumer<Integer> consumer3 = x -> System.out.println("third x : " + x);

        consumer1.andThen(consumer2).andThen(consumer3).accept(1);
    }
}

print square : 4

first x : 1
second x : 1
Exception in thread "main" java.lang.NullPointerException: throw exception test
	at jdk8.ConsumerTest.lambda$testAndThen$2(ConsumerTest.java:27)
	at java.util.function.Consumer.lambda$andThen$0(Consumer.java:65)
	at java.util.function.Consumer.lambda$andThen$0(Consumer.java:65)
	at jdk8.ConsumerTest.testAndThen(ConsumerTest.java:31)
	at jdk8.ConsumerTest.main(ConsumerTest.java:9)

Process finished with exit code 1

/**
     * Performs the given action for each element of the {@code Iterable}
     * until all elements have been processed or the action throws an
     * exception.  Unless otherwise specified by the implementing class,
     * actions are performed in the order of iteration (if an iteration order
     * is specified).  Exceptions thrown by the action are relayed to the
     * caller.
     *
     * @implSpec
     * <p>The default implementation behaves as if:
     * <pre>{@code
     *     for (T t : this)
     *         action.accept(t);
     * }</pre>
     *
     * @param action The action to be performed for each element
     * @throws NullPointerException if the specified action is null
     * @since 1.8
     */
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }