Java8 Function Interface （函数式接口）和 Lambda表达式

关于java 8的函数式接口，好多文章可以用来学习，而且都总结的非常好。
比如这一篇，其实这一个系列对于初学者都是很有益的。
    - 函数式接口(Functional Interface)就是一个具有一个方法的普通接口。
    - 函数式接口可以被隐式转换为lambda表达式。
    - 函数式接口可以现有的函数友好地支持 lambda。

我的理解呢，这主要还是方便程序的实现，同时也方便维护。

这里有个例子，其实也是修改的例子：

import java.util.function.Predicate;
import java.util.function.Consumer;

class Student{
    String firstName;
    String lastName;
    Double grade;
    Double feeDiscount = 0.0;
    Double baseFee = 20000.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);
    }
}

class MyPredicate implements Predicate<Student>{
    public boolean test(Student s){
        return (s.grade > 6.0)? true : false;
    }
}

class MyConsumer implements Consumer <Student> {
    public void accept(Student s){
        s.feeDiscount = 20.0;
    }
}

public class TestConsume {
    public static Student updateStudentFee(Student student, Predicate<Student> predicate, Consumer<Student> consumer){
     if ( predicate.test(student)){
            consumer.accept(student);
     }
     return student;
    }
    public static void main(String[] args) {
        /* way 1 */
        Student student1 = new Student("Ashok","Kumar", 9.5);
        student1 = updateStudentFee(student1,
                                 student -> student.grade > 8.5,
                                 student -> student.feeDiscount = 30.0);
        student1.printFee();
        Student student2 = new Student("Rajat","Verma", 8.0);
     student2 = updateStudentFee(student2,
                                 student -> student.grade >= 8,
                                 student -> student.feeDiscount = 20.0);
        student2.printFee();

     /* way 2 */
        Student student3 = new Student("Tom","TT", 6.0);
        MyPredicate myPredicate3 = new MyPredicate();
        MyConsumer  myConsumer3 = new MyConsumer();
        student3=updateStudentFee(student3, myPredicate3, myConsumer3);
        student3.printFee();

     /* way 3 */
        Student student4 = new Student("Tom","TT", 6.0);
        student4=updateStudentFee(student4,
                 new Predicate<Student>() {
             public boolean test(Student s){
                                         return (s.grade > 5.0)? true : false;
             }
     },
                 new Consumer<Student>(){
                                     public void accept(Student s){
                                            s.feeDiscount = 10.0;
                                        }
     }
     );
        student4.printFee();
    }
}

对于第一种方法：
    - 可以看到通过Lambda表达式，可以很方便的配合函数式接口进行编程。而且逻辑很清晰，方便维护。

对于第二种方法：
    - 这应该是非常传统的写法。
    - 如果要达到第一种的结果（比如：两种评判标准），要写多个类。很繁琐。

对于第三种方法：
   - 算是一种过渡的方法吧。对于不使用Lambda表达式的人来说，比较容易接受。