@FunctionalInterface
public interface Predicate<T> {

  /**
   * Evaluates this predicate on the given argument.
   *
   * @param t the input argument
   * @return {@code true} if the input argument matches the predicate,
   * otherwise {@code false}
   */
  boolean test(T t);

  default Predicate<T> and(Predicate<&#63; super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
  }

  default Predicate<T> negate() {
    return (t) -> !test(t);
  }

  default Predicate<T> or(Predicate<&#63; super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
  }


  static <T> Predicate<T> isEqual(Object targetRef) {
    return (null == targetRef)
        &#63; Objects::isNull
        : object -> targetRef.equals(object);
  }
}

@Test
public void testPredicate(){
  java.util.function.Predicate<Integer> boolValue = x -> x > 5;
  System.out.println(boolValue.test(1));//false
  System.out.println(boolValue.test(6));//true
}

@FunctionalInterface
public interface Consumer<T> {

  /**
   * Performs this operation on the given argument.
   *
   * @param t the input argument
   */
  void accept(T t);

  /**
   * Returns a composed {@code Consumer} that performs, in sequence, this
   * operation followed by the {@code after} operation. If performing either
   * operation throws an exception, it is relayed to the caller of the
   * composed operation. If performing this operation throws an exception,
   * the {@code after} operation will not be performed.
   *
   * @param after the operation to perform after this operation
   * @return a composed {@code Consumer} that performs in sequence this
   * operation followed by the {@code after} operation
   * @throws NullPointerException if {@code after} is null
   */
  default Consumer<T> andThen(Consumer<&#63; super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
  }
}

@Test
public void testConsumer(){
  User user = new User("zm");
  //接受一個(gè)參數(shù)
  Consumer<User> userConsumer = User1 -> User1.setName("zmChange");
  userConsumer.accept(user);
  System.out.println(user.getName());//zmChange
}

@Test
public void test(){
  User user = new User("zm");
  this.change(user);
  System.out.println(user.getName());//輸出zmChange
}

private void change(User user){
  user.setName("zmChange");
}

public class Student {

  String firstName;

  String lastName;

  Double grade;

  Double feeDiscount = 0.0;
  Double baseFee = 2000.0;
  public Student(String firstName, String lastName, Double grade) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.grade = grade;
  }

  public void printFee(){
    Double newFee = baseFee - ((baseFee * feeDiscount)/100);
    System.out.println("The fee after discount: " + newFee);
  }
}

public class PredicateConsumerDemo {

  public static Student updateStudentFee(Student student, Predicate<Student> predicate, Consumer<Student> consumer){
    if (predicate.test(student)){
      consumer.accept(student);
    }
    return student;
  }

}

public class Test {
  public static void main(String[] args) {
    Student student1 = new Student("Ashok","Kumar", 9.5);

    student1 = updateStudentFee(student1,
        //Lambda expression for Predicate interface
        student -> student.grade > 8.5,
        //Lambda expression for Consumer inerface
        student -> student.feeDiscount = 30.0);
    student1.printFee(); //The fee after discount: 1400.0

    Student student2 = new Student("Rajat","Verma", 8.0);
    student2 = updateStudentFee(student2,
        //Lambda expression for Predicate interface
        student -> student.grade >= 8,
        //Lambda expression for Consumer inerface
        student -> student.feeDiscount = 20.0);
    student2.printFee();//The fee after discount: 1600.0

  }
}