Java新特性之接口定义加强、lambda表达式、方法引用

一、接口定义加强

问题：当多个子类实现同一个接口中的一个方法，实现的内容相同。

JDK1.8中接口定义加强：使用default修饰普通方法，通过对象调用；使用static修饰静态方法，通过接口名调用。

package com.xunpu.newproperties;

interface Demo{
    //普通方法用default修饰,通过对象调用
    public default void fun(){
        System.out.println("hello interface");
    }
    public void print();
    //静态方法用static修饰，通过接口名调用
    public static int add(int x,int y){
        return x+y;
    }
}

class Son implements Demo{

    @Override
    public void print() {
        System.out.println("我是子类");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //定义一个对象
        Demo demo1=new Son();
        demo1.print();
        demo1.fun();//通过对象调用普通方法
        System.out.println(Demo.add(1,2));
    }
}

说明：这个看起来和抽象类有点像，但是区别是接口的子类可以实现多继承，而抽象类仍然是单继承。

注意：此操作不属于标准操作，而是挽救操作。

二、lambda表达式

在JDK1.8出现，是一个函数式编程。面向对象编程语法的最大缺陷：要求结构必须完整。而函数式编程则克服了这个缺点。

使用前提：接口中只有一个方法。

注解：@FunctionalInterface  函数式编程接口，只允许有一个抽象方法。

语法：(参数列表)->{实现内容}

如果只有输出一句话或者只返回一个值，则写法为(参数)->单行语句或者(参数)->返回值的表达式

如果输出多句话，语法为：(参数)->{}   如果参数只有一个，圆括号可以省略。

package com.xunpu.newproperties;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

/**
 * lambda表达式
 * 使用前提：接口中只有一个方法，输出一条语句。
 */
@FunctionalInterface
interface IDemo2{
    public void fun();
}
public class Demo2 {
    public static void main(String[] args) {
        IDemo2 iDemo2=new IDemo2() {
            @Override
            public void fun() {
                System.out.println("子类实现方法的完整写法");
            }
        };
        iDemo2.fun();
        //lambda表达式
        IDemo2 iDemo3= () -> System.out.println("lambda表达式写法");
        iDemo3.fun();
    }

}

package com.xunpu.newproperties;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

/**
 * lambda表达式
 * 使用前提：接口中只有一个方法,输出多条语句。
 */
@FunctionalInterface
interface IDemo2{
    public void fun();
}
public class Demo2 {
    public static void main(String[] args) {
        IDemo2 iDemo2=new IDemo2() {
            @Override
            public void fun() {
                System.out.println("子类实现方法的完整写法");
                System.out.println("hello,object");
            }
        };
        iDemo2.fun();
        //lambda表达式
        IDemo2 iDemo3= () -> {
            System.out.println("lambda表达式写法");
            System.out.println("hello,lambda");
        };
        iDemo3.fun();
    }

}

package com.xunpu.newproperties;

/**
 * 返回一个值
 */
@FunctionalInterface
interface IDemo3{
    int operation(int x,int y);
}
public class Demo3 {
    public static void main(String[] args) {
        IDemo3 iDemo1=new IDemo3() {
            @Override
            public int operation(int x, int y) {
                return x+y;
            }
        };
        System.out.println(iDemo1.operation(1,2));
        IDemo3 iDemo2= (x, y) -> x+y;
        System.out.println(iDemo2.operation(2,3));
    }
}

三、方法引用

最初，引用只针对引用类型，即类、接口、数组才具备引用操作。在JDK1.8中追加了方法引用这一特性，引用的本质就是别名。方法的引用就是别名的使用。

方法引用的类型：

1)引用静态方法：类名称::static 方法名

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

3)引用某个特定类的方法：类名称::普通方法

4)引用构造方法：类名称::new

package com.xunpu.newproperties.methodQuote;

/**
 * 1.引用静态方法
 */

//P,R为泛型，其中P为参数类型，R为返回值类型。
@FunctionalInterface
interface IDemo1<P,R>{
    public R fun(P p);
}
interface Demo2<P,R> {
    public R fun(P p);
}
public class Demo1 {
    public static void main(String[] args) {
        //特定类的方法引用  将Integer-->String
        IDemo1<Integer,String> iDemo1=String::valueOf;
        String str=iDemo1.fun(100);
        System.out.println(str.length());
        //String-->Integer
        Demo2<String,Integer> demo2=(p)->{
            return Integer.parseInt(p);
        };
        System.out.println(demo2.fun("12")+1);
    }
}

package com.xunpu.newproperties.methodQuote;

/**
 * 2.引用对象方法
 * 对象名::方法名
 */
interface IDemo22<R>{
    public R fun();
}
public class Demo22{
    public static void main(String[] args) {
        IDemo22 iDemo22="hello"::toUpperCase;
        System.out.println(iDemo22.fun());
    }
}

package com.xunpu.newproperties.methodQuote;

/**
 * 3.引用类中普通方法
 * 类名称::方法名
 */
@FunctionalInterface
interface IDemo3<P,R>{
    public R fun(P p1,P p2);
}

public class Demo3 {
    public static void main(String[] args) {
        IDemo3<String,Integer> iDemo3=String::compareTo;
        System.out.println(iDemo3.fun("abc","Abc"));
    }

}

package com.xunpu.newproperties.methodQuote;

/**
 * 4.引用构造方法
 */
class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
interface IDemo4<R,PA,PB>{
    public R createPerson(PA pa,PB pb);
}
public class Demo4 {
    public static void main(String[] args) {
        IDemo4<Person,String,Integer> iDemo4=Person::new;
        Person p=iDemo4.createPerson("张三",20);
        System.out.println(p);
    }
}