java8 -- 方法引用

 

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.静态方法引用    格式 类名：：静态方法

     创建静态方法

	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());
		
	}