Lambda表达式

想学习好Lambda吗？？？

那么你就要知道Lambda表达式是什么？？？

Lambda的核心就是他是简化创建匿名类实例对象的

方法引用是简化Lambda的，也是一种Lambda的表现形式，只不过是更加简洁而已

Lambda和方法引用就是创建一个匿名内部类对象 

他和匿名内部类还是有区别的

匿名内部类不用有实例变量或者局部变量所引用就可以创建对象而Lambda和方法引用必须得有实例变量或者局部变量所引用

       否则不会创建对象成功的

/*

 * Lambda表达式
 * Lambda表达式的结果类型称为Lambda表达式的目标类型。
 * Lambda表达式的目标类型为函数式接口类型。确切的说，
 * 目标类型是实现了函数式接口类型的对象。（该对象所属的类实现了函数式接口）
 * 
 * 我们在某种情况下，可以使用Lambda表达式代替匿名类，这样，能够令程序
 * 进一步简洁。
 * 
 * 我们可以将Lambda表达式看成是一个匿名的方法。
 * Lambda表达式的语法：
 * (参数列表)-> {方法体}
 * 1 参数列表的类型可以省略。
 * 2 如果只有一个参数，小括号()可以省略。
 * 3 如果方法具有返回值，并且方法体只有一条语句，则可以将return与{}同时省略。
 * 4 如果方法没有返回值，并且方法体只有一条语句，则可以将{}省略。
 */
public class Lambda {
public Mobile getMobile() {
return new Mobile() {
@Override
public void call() {
System.out.println("匿名类打电话");
}
};
}


public Mobile getMobile2() {
return () -> System.out.println("Lambda打电话");
}


public void test() {
Generator g = new Generator() {
@Override
public int get(int x) {
return x + 2;
}
};


Generator g2 = x -> x + 2;
}
}


@FunctionalInterface
interface Generator {
int get(int x);

}

/*
 * 方法引用
 * 如果在Lambda表达式中，仅仅是调用一个已经存在的方法，那我们
 * 就可以使用方法引用来代替Lambda表达式，通过方法引用可以让
 * 程序进一步的简洁。
 * 
 * 方法引用可以分为如下四种形式：
 * 1 引用静态方法
 * 2 通过对象（引用）引用实例方法
 * 3 通过类型引用实例方法
 * 4 引用构造器
 * 
 * 方法引用是Lambda表达式的一种特例，也是返回实现了函数式接口类型的对象。
 */
public class MethodReference {
public static void main(String[] args) {
Person a = new Person("张三", 23, 120, 30);
Person b = new Person("李四", 25, 130, 40);
Friend f = (p1, p2) -> Person.mkFriend(p1, p2);
// f.makeFriend(a, b);
// 引用静态方法，抽象方法中的参数会依次传递给所引用的静态方法。
f = Person::mkFriend;
f.makeFriend(a, b);


Tool tool = new Tool();
f = (p1, p2) -> tool.mkFriend(p1, p2);
// 通过引用（对象）引用实例方法，抽象方法中的参数会依次传递给所引用的实例方法。
f = tool::mkFriend;


f = (p1, p2) -> p1.mkFriend2(p2);
// 通过类型引用实例方法。第1个参数充当所引用方法的调用者，从2个参数开始（一直到最后），
// 会依次传递给所引用的方法。
f = Person::mkFriend2;


Create c = (name, age, height, weight) -> new Person(name, age, height, weight);
// 引用构造器。抽象方法中的参数会依次传递给构造器。
c = Person::new;
}
}


@FunctionalInterface
interface Friend {
void makeFriend(Person p1, Person p2);
}


@FunctionalInterface
interface Create {
Person get(String name, int age, int height, int weight);
}

public class Test {


public static void main(String[] args) {
// TODO Auto-generated method stub
// MengMengDa m1 = new MengMengDa() {
//
// @Override
// public int mengmengda(People p1, People p2) {
// p1.say(p2);
// return 0;
// }
// };
// m1.mengmengda(new People(1, "111", "你好"), new People(0,"000","喜欢???......"));
//
//-----------------------------------------------------------------------------------//

//Test2
//MengMengDa m2 =(p1,p2)->{p1.say(p2);return 0;};
// m2.mengmengda(new People(1, "111", "你好"), new People(0,"000","喜欢???......"));
// m2.mengmengda(People::new, People::new);


//Test3
//Haha haha = (a,b)->{new People(a,b,"");};
// haha = People::new;//The type People does not define People(int, String) that is applicable here

//Haha haha = (a,b,c)->{new People(a,b,c);};
//编译器检查 People::new是作为接口的匿名内部类方法体中的方法语句
//编译期会检查方法的参数是否能够使语句能够顺利执行，方法的参数会依次传递给 People::new
//参数传递多了不能用，传递少了也不能用
//haha = People::new;


MengMengDa m =(p1,p2)->{
p1.say(p2);
MengMengDa mm = People::say;
};
//m2.mengmengda(new People(1, "111", "你好"), new People(0,"000","喜欢???......"));
MengMengDa m2 = People::say;
m2.mengmengda(new People(1, "111", "你好"), new People(0,"000","喜欢???......"));

}


}
@FunctionalInterface
interface MengMengDa{
void mengmengda(People p1 , People p2);
}
@FunctionalInterface
interface Haha{
 void haha(int a ,String b ,String c);
}


class People{
private int age ;
private String name ;
private String line ;
public People(int age ,String name ,String line){
this.age = age ;
this.name = name ;
this.line =line ;
}



public void say(People p2){
p2.love();
}

public void love() {
System.out.println(line);
}


@Override
public String toString() {
return "name: "+name+"  age: "+age ;
}
}