双冒号::为引用运算符，而它所在的表达式被称为方法引用。
/**
* 定义一个打印的函数式接口
*/
@FunctionalInterface
public interface Printable {
//定义一个字符串的抽象方法
void print(String s);
}
//定义一个方法，参数传递printable接口，对字符串进行打印
public static void printString(Printable p){
p.print("hello world");
}
public static void main(String[] args) {
//调用printString方法，方法的参数printable是一个函数式接口，所以可以传递lambda表达式
printString((s)->{
System.out.println(s);
});
/**
* 分析：lambda表达式的目的，打印参数传递的字符串，把参数s传递给了System.out对象，
* 调用out对象中的方法println对字符串进行了输出
* 注意：System.out对象是已经存在的；println方法也是已经存在的。所以我们可以使用
* 方法引用来优化lambda表达式，可以使用System.out方法直接引用（调用）println方法
*/
printString(System.out::println);
}
（1）通过对象名引用成员方法
/**
* 定义一个打印的函数式接口
*/
@FunctionalInterface
public interface Printable {
//定义一个字符串的抽象方法
void print(String s);
}
public class Demo02Method {
//定义一个成员方法，传递字符串，把字符串按照大写输出
public void peintUpperCaseString(String str){
System.out.println(str.toUpperCase());
}
}
/**
* 通过对象名引用成员方法，使用前提是对象名已经存在的，成员方法也是已经存在的
*
*/
public class Demo02ObjectMethod {
//定义一个方法，方法的参数传递printable接口
public static void printString(Printable p){
p.print("hello");
}
public static void main(String[] args) {
//调用printString方法，方法的参数Printable是一个函数式接口，所以可以传递lambda表达式
printString((s)->{
//创建Demo02Method对象
Demo02Method obj = new Demo02Method();
//调用Demo02Method对象中的成员方法printUpperCaseString，把字符串按照大写输出
obj.peintUpperCaseString(s);
});
/**
* 使用方法引用优化lambda，对象是已经存在的Demo02Method，
* 成员方法也是已经存在的peintUpperCaseString,
* 所以我们可以使用对象名引用成员方法
*/
Demo02Method obj = new Demo02Method();
printString((obj::peintUpperCaseString));
}
}
（2）通过类名引用静态成员方法
前提：类已经存在，静态成员方法也已经存在，就可以通过类名直接引用静态成员方法。
@FunctionalInterface
public interface Calcable {
//定义一个抽象方法，传递一个整数，对整数进行绝对值计算并返回
int calsAbs(int number);
}
public class Demo03StaticMethodReference {
//定义一个方法，方法的参数传递要计算绝对值的整数和函数式接口Calcable
public static int method(int number, Calcable c){
return c.calsAbs(number);
}
public static void main(String[] args) {
//调用method方法，传递计算绝对值的整数和lambda表达式
int num = method(-10,(n)->{
//对参数进行绝对值的计算并返回结果
return Math.abs(n);
});
System.out.println(num);
/**
* 使用方法引用优化lambda表达式
* Math类是存在的
* abs计算绝对值的静态方法也是存在的
* 所以我们可以直接通过类名引用静态方法
*/
int num2 = method(-10, Math::abs);
System.out.println(num2);
}
}
（3）通过super引用成员方法
/**
* 定义见面的函数式接口
*/
@FunctionalInterface
public interface Greetble {
//定义一个见面的方法
void greet();
}
/**
* 定义父类
*/
public class Human {
//定义一个sayHello的方法
public void sayHello(){
System.out.println("Hello,我是父类");
}
}
public class Man extends Human {
@Override
public void sayHello() {
System.out.println("hello,我是man");
}
//定义一个方法，参数传递Greetable接口
public void method(Greetble g){
g.greet();
}
public void show(){
//调用method方法，方法的参数Greetable接口是一个函数式接口，所以可以传递lambda
method(()->{
Human h = new Human();
h.sayHello();
});
//因为有子父类关系，所以存在一个关键字super，代表父类，
// 所以我们可以直接使用super调用父类的成员方法
method(()->{
super.sayHello();
});
/**
* 使用super引用父类的成员方法，super是已经存在的，父类的成员方法sayHello也是存在的
* 所以可以直接调用super引用父类的成员方法
*/
method(super::sayHello);
}
public static void main(String[] args) {
new Man().show();
}
}
（4）通过this引用成员方法
/**
* 定义一个富有的函数式接口
*/
public interface Richable {
//定义一个想买什么就买什么的方法
void buy();
}
/**
* 通过this引用本类的成员方法
*/
public class Husband {
//定义一个买房子的方法
public void buyHouse(){
System.out.println("北京二环内买一套四合院");
}
//定义一个结婚的方法，参数传递Richable接口
public void marry(Richable r){
r.buy();
}
//定义一个非常高兴的方法
public void soHappy(){
//调用结婚的方法
marry(()->{
this.buyHouse();
});
/**
* 使用放啊引用优化lambda表达式
* this是已经存在的，本类的成员方法buyHouse也是已经存在的，
* 所以可以直接使用this引用本类的成员方法
*/
marry(this::soHappy);
}
public static void main(String[] args) {
new Husband().soHappy();
}
}
（5）类的构造器的引用
构造器的引用使用类名称::new的格式表示
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
public Person() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* 定义一个创建person对象的函数式接口
*/
public interface PersonBuilder {
//定义一个方法，根据传递的姓名，创建person对象返回
Person builderPerson(String name);
}
/**
* 类的构造器引用
*/
public class DemoPerson {
//定义一个方法，参数传递姓名和PersonBuilder接口，方法中通过姓名创建Person对象
public static void printName(String name, PersonBuilder pb){
Person person = pb.builderPerson(name);
System.out.println(person.getName());
}
public static void main(String[] args) {
//调用printName方法，方法的参数PersonBuilder接口是一个函数式接口，可以传递lambda
printName("迪丽热巴", (name)->{
return new Person(name);
});
/**
* 使用方法引用优化lambda表达式
* 构造方法new Person(String name)已知
* 创建对象已知new
* 就可以使用Person引用new创建对象
*/
printName("古力娜扎",Person::new);//使用Person的带参构造方法，通过传递的姓名创建对象
}
}
数组构造器的引用
/**
* 定义一个创建数组的函数式接口
*/
@FunctionalInterface
public interface ArrayBuilder {
//定义一个创建int类型数组的方法，参数传递数组的长度，返回创建好的int类型数组
int[] builderArray(int length);
}
/**
* 数组的构造器引用
*/
public class Demo {
//定义一个方法，方法的参数传递创建数组的长度和ArrayBuilder接口
//方法内部根据传递的长度使用ArrauBuilder中的方法创建数组并返回
public static int[] createArray(int length, ArrayBuilder ab){
return ab.builderArray(length);
}
public static void main(String[] args){
//调用createArray方法，传递数组的长度和lambda表达式
int[] arr1 = createArray(10, (len)->{
//根据数组的长度，创建数组并返回
return new int[len];
});
System.out.println(arr1.length);
/**
* 使用方法引用优化lambda表达式
* 已知创建的就是int[]数组
* 数组的长度也是已知的
* 就可以使用方法引用
* int[]引用new,根据参数传递的长度来创建数组
*/
int[] arr2= createArray(10,int[]::new);
System.out.println(arr2.length);
}
}
