方法引用
________________________________________
方法引用是Lambda表达式的一个简化写法。所引用的方法其实是Lambda表达式的方法体的实现，其语法结构为:
ObjectRef::methodName
左边可以是类名或者实例名，中间是方法引用符号”::”，右边是相应的方法名。方法引用被分为三类：
1. 静态方法引用
在某些情况下，我们可能写出这样的代码：
public class ReferenceTest {
    public static void main(String[] args) {
        Converter<String ,Integer> converter=new Converter<String, Integer>() {
            @Override
            public Integer convert(String from) {
                return ReferenceTest.String2Int(from);
            }
        };
        converter.convert("120");

    }


    @FunctionalInterface
    interface Converter<F,T>{
        T convert(F from);
    }

    static int String2Int(String from) {
        return Integer.valueOf(from);
    }
}
这时候如果用静态引用会使的代码更加简洁：
Converter<String, Integer> converter = ReferenceTest::String2Int;
converter.convert("120");
2. 实例方法引用
我们也可能会写下这样的代码：
public class ReferenceTest {
    public static void main(String[] args) {

        Converter<String, Integer> converter = new Converter<String, Integer>() {
            @Override
            public Integer convert(String from) {
                return new Helper().String2Int(from);
            }
        };
        converter.convert("120");
    }


    @FunctionalInterface
    interface Converter<F, T> {
        T convert(F from);
    }

    static class Helper {
        public int String2Int(String from) {
            return Integer.valueOf(from);
        }
    }
}
同样用实例方法引用会显得更加简洁：
  Helper helper = new Helper();
  Converter<String, Integer> converter = helper::String2Int;
  converter.convert("120");
3. 构造方法引用
现在我们来演示构造方法的引用。首先我们定义一个父类Animal:
class Animal{
        private String name;
        private int age;

        public Animal(String name, int age) {
            this.name = name;
            this.age = age;
        }

       public void behavior(){

        }
    }
接下来，我们在定义两个Animal的子类：Dog、Bird
public class Bird extends Animal {

    public Bird(String name, int age) {
        super(name, age);
    }

    @Override
    public void behavior() {
        System.out.println("fly");
    }
}

class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void behavior() {
        System.out.println("run");
    }
}
随后我们定义工厂接口：
interface Factory<T extends Animal> {
        T create(String name, int age);
    }
接下来我们还是用传统的方法来创建Dog类和Bird类的对象：
Factory factory=new Factory() {
            @Override
            public Animal create(String name, int age) {
                return new Dog(name,age);
            }
        };
        factory.create("alias", 3);
        factory=new Factory() {
            @Override
            public Animal create(String name, int age) {
                return new Bird(name,age);
            }
        };
        factory.create("smook", 2);
两个对象就写了十多号代码，现在我们用构造函数引用试试：
  Factory<Animal> dogFactory =Dog::new;
  Animal dog = dogFactory.create("alias", 4);

  Factory<Bird> birdFactory = Bird::new;
  Bird bird = birdFactory.create("smook", 3);
这样代码就显得干净利落了。通过Dog::new这种方式来穿件对象时，Factory.create函数的签名选择相应的造函数。

我来占层楼啊