java新特性_day03

/**
 * Lambda语法：
 * Lambda表达式可以认为是一种特殊的匿名内部类
 *  （[形参列表，不带数据结构]） ->{
 *  //执行语句
 *  [return ...;]
 *  };
 *  
 *  1.如果形参列表是空的，只需要保留()即可
 *  2.如果没有返回值，只需要在{}里面写执行语句即可
 *  3.如果接口的抽象方法只有一个形参，可以省略(),只需要参数的名称即可
 *  4.如果执行语句只有一行，可以省略{}
 *  5.形参列表的数据类型自动推断，只要参数名称
 *  6.如果函数式借口的方法有返回值，必须给定返回值，如果执行语句只有一行代码，
 *  可以省略大括号，但必须同时省略return
 *  7.和匿名内部类一样，如果访问局部变量，要求局部变量必须是final的
 * @author User
 * 
 * 方法的引用：
 *     引用实例方法
 *         自动把调用方法的时候的参数，全部传给引用的方法
 *          函数式接口 变量名 = 实例 ：： 方法名
 *         //自动把实参全部传给引用的实例方法
 *         <变量名>.<接口方法名>（[实参]）;
 *     引用类方法
 *         全部参数传给引用的方法
 *          函数式接口 变量名 = 类名 ：： 方法名
 *        //自动把实参传递给引用的方法
 *         <变量名>.<接口方法名>（[实参]）;
 * 
 *     引用类的实例方法
 *         定义，调用接口的方法的时候，需要多一个参数，并且参数的类型和引用实例
 * 方法的类型必须一致。
 *         把第一个参数作为用的实例，后面的每个参数全部传递给引用的方法。
 *         interface 函数式接口{
 *        <返回值> 方法名（类名 名称，其他类型参数 参数名）; 
 *         }
 * 
 *         函数式接口 变量名 = 类名：：实例方法；
 *         变量名.方法名（类实例，其他参数）
 * 
 * 构造器的引用
 *         把方法的所有参数全部传递给用用的构造器，根据参数的类型推断调用的构造器
 *         类名：：new
 *
 */

package day02;

/**
 * 为什么要只有Lambda只能用于函数式接口：
 * 因为lambda没有指明实现那个方法，所以只能实现一个方法
 * 
 * @author User
 *
 */

public class Test {
    public static void main(String[] args) {
        // 引用类方法
        TestClassMethod t = output :: outputTest;
        t.test("a", 1);
        
        
        System.out.println("========");
        TestClassMethod t1 = (x,y) -> {
            System.out.println("Lambda"+x);
            System.out.println("Lambda"+y);
        };
        
        t1.test("a", 2);
        
        // 实例方法的引用：
        TestClassMethod2 test2 = System.out :: println;
        test2.test1("a");
        
        //普通的lambda表达式
        TestClassMethod3 test3 = () -> {
            return new User();
        };
        User u = test3.getUser();
        System.out.println(u);
        
        
        //构造器引用
        TestClassMethod3 test4 = User :: new ;
        User user4 = test4.getUser();
        System.out.println(user4);
        
        
        //匿名内部类
        TestClassMethod3 test5 = new TestClassMethod3(){
            public User getUser(){
                System.out.println("User方法");
                return new User();
            }
            
        };
        
        System.out.println(test5);
        
        System.out.println("=========");
        TestClassMethod4 test6 = TestClassMethod3 :: getUser;
        //把函数式接口的第一个参数，作为类的一个实例
        User user6 = test6.getUser(test5);
        System.out.println(user6);
    }
    
}
 

 

package day02;

public interface TestClassMethod {
    void test(String str,int i);

}
 

package day02;

@FunctionalInterface
public interface TestClassMethod2 {
    void test1(String str);

}

 

package day02;

public interface TestClassMethod3 {
    User getUser();

}
 

package day02;

@FunctionalInterface
public interface TestClassMethod4 {
    User getUser(TestClassMethod3 testUser);

}
 

package day02;

public class User {
    public User(){
        System.out.println("User的构造器");
    }

}

 

package day02;

public class output {
    public static void outputTest(String a,int b){
        System.out.println("类方法"+a+":"+b);
    }

}