java8 新特新-- 方法引用
java8引入的方法引用：
分4种：
* 1. 构造器引用 -- 类名::new
* 2. 静态方法引用 -- 类名::方法名
* 3. 普通方法引用 -- 实例名::方法名
* 4.引用某个类型的任意对象的实例的普通方法 -- 类名::实例方法名 （比较难理解）其实就是3.普通方法引用
方法引用也是为了 简化代码的繁琐， 和Lambda表达式差不多，学了 Lambda方法引用就好理解多了
使用代码体现下：
1 构造器引用 格式 类名：：new
创建函数接口
/*
* 获取类的实例
*/
@FunctionalInterface
interface function01<T>{
T getObject();
}
创建实体类
package com.xiaodu.java8.methodcite;
public class Person {
private String name;
public Person(){
this.name = "xiaoming";
}
@Override
public String toString() {
return "Person [name=" + name + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void hello(String str){
System.out.println("hello " + str);
}
}测试构造器方法引用
/**
* 构造器引用
* 类名::new (Person::new)
*/
@Test
public void test01() {
// 使用构造器引用
function01<Person> p = Person::new;
Person pserson1 = p.getObject();
System.out.println(pserson1); //Person [name=xiaoming]
// 使用lambda表达式
function01<Person> p2 = () -> new Person();
Person person2 = p2.getObject();
System.out.println(person2); //Person [name=xiaoming]
}2.静态方法引用 格式 类名：：静态方法
扫描二维码关注公众号，回复：
12201675 查看本文章
创建静态方法
private static void printMess(String str){
System.out.println("printMess = " + str);
}
创建 函数接口（函数接口也可以使用java8自带的，不用自己创建）
@FunctionalInterface
interface function02{
void print(String s);
}测试 静态方法引用
/**
* 静态方法引用
* 类名::方法名
*/
@Test
public void test02() {
// 静态方法引用
function02 f1 = TestMethodCite::printMess;
f1.print("xiaohong"); //printMess = xiaohong
// lambda
function02 f2 = mess -> TestMethodCite.printMess(mess);;
f2.print("xiaoming"); //printMess = xiaoming
}普通方法引用 格式： 对象实例：：普通方法
创建普通方法
public int add(int a,int b) {
return a+b;
}创建函数接口
@FunctionalInterface
interface function03{
int operation(int a,int b);
}使用普通方法引用
/**
* 普通方法引用
*/
@Test
public void test03() {
// 普通方法引用
function03 f = new TestMethodCite() :: add;
int operation = f.operation(12, 23);
System.out.println(operation); //35
// lambda
function03 f2 = (a,b) -> a+b;
System.out.println(f2.operation(12, 12)); // 24
}4 . 引用某个类型的任意对象的实例的普通方法，看起来和类名：：静态方法一样，其实本质还是个 对象实例名：：普通方法名
格式 类名：：普通方法名
/**
* 引用某个类型的任意对象的实例的普通方法
* 和类名:: 静态方法一样的格式
* 格式：
* 类名:: 普通方法
*/
@Test
public void test04() {
/* public int compareToIgnoreCase(String str) 是String 的普通方法
/ 接受一个参数，而sort 的第二个参数为Comparator<? super T> c 类型
/ 而comparator 是接受两个参数的函数接口 int compare(T o1, T o2);
* 总结：一个参数的方法，使用了两个参数的函数方法，不合理，原因是，在排序的时候，每个元素已经是对象了，
* 其实底层还是用的 类的实例::普通方法名 这样的模式 -- 也就是普通方法引用只是表面看起来像类名::静态方法这样的引用
*/
Arrays.sort(new String[]{"asd","ddd"}, String::compareToIgnoreCase);
// 是用lambda 表达式 就可以看出来端倪了
Arrays.sort(new String[]{"asd","ddd"},(o1,o2) -> o1.compareToIgnoreCase(o2));
/**
* 第二种分析，
*/
// 创建一个 包含TestMethodCite 的集合
List<TestMethodCite> asList = Arrays.asList(new TestMethodCite());
// 使用方法引用
asList.forEach(TestMethodCite::str);
// 使用lambda o 是从集合中取出来的 对象
asList.forEach(o -> o.str());
}