Java之Lambda表达式&方法引用

本片博客主要介绍介绍JDK1.8推出的新特性

接口定义增强

JDK1.8之后接口出现以下两类方法：
a.在接口中使用default定义的普通方法，需要通过接口对象来调用
b.在接口中使用static定义的静态方法，直接使用接口调用。
范例：

interface IInterface{
    //接口中定义的抽象方法
    void test();
    //使用default定义的普通方法
    default void test1(){
        System.out.println("1.********");
    }
    //使用static定义的静态方法
    static void test2(){
        System.out.println("2.&&&&&&&&&&");
    }
}

class InterfaceClass implements IInterface{
    //子类覆写抽象方法
    public void test(){
        System.out.println("3.#########");
    }
}
public class Test {
    public static void main(String[] args){
       IInterface.test2();
       //自动向上转型
       IInterface inte=new InterfaceClass();
       inte.test1();
       inte.test();
    }
}

Lambda表达式

Lambda表达式是函数式编程。
要想使用函数式编程有一个前提条件：接口必须只有一个方法，如果存在两个以上的方法，无法使用函数式编程。
范例：函数式编程

@FunctionalInterface
interface IAdd {
    public void Add(int x,int y) ; // 这是一个接口，接口中的抽象方法必须由子类覆写。
}
public class Test {
    public static void main(String[] args) {
        // 函数式编程的使用
        IAdd add = (x,y) -> System.out.println(x+y);
        IAdd add1=(x,y)-> System.out.println(x+y+10);
        add.Add(1,2);//3
        add1.Add(1,2);//13
    }
}

如果现在某个接口就是为了函数式编程而生的，在定义时只能存在一个方法，因此有一个新的注释**@FunctionalInterface，此注释会检查该接口中是否只能存在一个抽象方法，存在抽象方法两个以上会编译报错**
Lambda表达式语法：
1.方法体只有一行代码时：
（方法参数）->具体的方法体实现
当方法体有返回值时，单行代码的lambda表达式可以省略return语句
范例：方法体有返回值

interface IAdd {
    public int Add(int x,int y) ; // 这是一个接口，接口中的抽象方法必须由子类覆写。
}
public class Test {
    public static void main(String[] args) {
        // 函数式编程的使用
        IAdd add = (x,y) -> x+y;
        int ret=add.Add(1,2);
        System.out.println(ret);//3
    }
}

2.当方法体有多行代码时，
（方法参数）->{
…
…
[return 语句];
};

范例：

interface IAdd {
    public int Add(int x,int y) ; // 这是一个接口，接口中的抽象方法必须由子类覆写。
}
public class Test {
    public static void main(String[] args) {
        // 函数式编程的使用
        IAdd add = (x,y) -> {
            int ret=x+y;
            ret+=20;
            return ret;
        };
        int ret=add.Add(1,2);
        System.out.println(ret);//23
    }
}

方法引用

方法引用只是给现有方法起了个别名
方法引用四种形式：
1.引用类中静态方法
类名称：：static 方法名称
范例：

interface IInterface<P,R>{
    R switchPara(P p);
}
public class Test {
    public static void main(String[] args) {
        //inte和valueOf指向同一个方法体
        IInterface<Integer,String> inte=String::valueOf;
        String str=inte.switchPara(10);
        System.out.println(str.startsWith("1"));//true
    }
}

2.引用某个对象的方法
实例化对象：：普通方法
范例：

interface IUtil<R> {
    public R switchPara() ;
}
public class Test {
    public static void main(String[] args) {
        IUtil<String> iu = "hello" :: toUpperCase ; // 进行方法引用
        System.out.println(iu.switchPara()); // HELLO
    }
}

3.调用类中普通方法
类名称：：普通方法名

interface IUtil<R,P> {
    public R compare(P p1,P p2) ;
}
public class Test {
    public static void main(String[] args) {
        IUtil<Integer,String> iu = String :: compareTo ;
        System.out.println(iu.compare("刘", "霍"));//结果是一个负数
    }
}

4.引用类中的构造方法
类名称：：new

class Person {
    private String name ;
    private int age ;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}
@FunctionalInterface // 是一个函数式编程接口，只允许有一个方法
interface IUtil<R,PN,PA> {
    public R createPerson(PN p1,PA p2) ;
}
public class Test {
    public static void main(String[] args) {
        IUtil<Person,String,Integer> iu = Person :: new;
        System.out.println(iu.createPerson("yuisama", 25)); // 相当于调用Person类的构造方法
    }
}

还有一个内建函数式接口，暂时看不懂…等以后会了再补充~~~~