JDK 1.8 新特性记录

package newFeatures8;

import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;

public class Express {

	public static void main(String[] args) {
		//第一种方法引用是构造器引用，它的语法是ClassName::new，或者更一般的Class< T >::new
		//final Supplier< Car > supplier=Car::new;//请注意:这种写法只适合无参构造函数
		/*如果硬是要创建一个有参构造函数，我思来想去 ，可以这么办
			public static Car create( final Supplier< Car > supplier,Object...prarameters) {
		    	Car car=supplier.get();//类型已经明确无需强转
		    	car.setXXX();
		    	car.setXXX();
		    	car.setXXX();
		        return car;
    		}  
		 */
		final Car carInstance = Car.create( Car::new );
		final List< Car > cars = Arrays.asList( carInstance );
		//除此之外可以使用ClassName::methodName 来指定方法引用
		//也可以使用instanceName::methodName 来指定方法引用
		cars.forEach( Car::collide );//静态有参方法，接收一个Car类型的参数
		//The method repair() from the type Car should be accessed in a static way 
		//Car的repair方法应该以静态的方式进行访问
		
		//静态无参方法没有什么意义，所以方法引用不支持静态无参方法
		//cars.forEach(Car::repair);编译错误
		cars.forEach( carInstance::follow );//接收一个Car类型的参数
		
		//->后面的内容就是对Consumer.accept(Car t) 方法的重写(覆盖)
		
		/*new Consumer<T>() {
			@Override
			public void accept(T t) {
				//做你要做的事
			}
		 }.accept(t);
		  Lambda 表达式就是用来替代匿名类(子类)的
		 */
		
		cars.forEach((Car c)->c.follow(Car.create( Car::new )));
		//其实::前面的System.out就是一个名称为out的PrintStream的一个实例
		//后面的println就是其无参方法
		//所以就是一个instanceName::methodName的方法引用
		cars.forEach(System.out::println);
		
	}
}

  class Car {
	 
    public static Car create( final Supplier< Car > supplier ) {
        return supplier.get();
    }  
         
    public static void collide( final Car car ) {//静态有参方法
        System.out.println( "Collided " + car.toString() );
    }
    
    //静态无参方法没有什么意义，所以方法引用不支持静态无参方法
    //只支持静态有参方法
    public static void repair() {
        System.out.println( "Repaired " );
    }   
    
    public void follow( final Car another ) {
        System.out.println( "Following the " + another.toString() );
    }
         
   
  
}