JDK8方法引用（双冒号）语法与Lambda表达式及匿名内部类的简单理解

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class JDK_8_Test {
    public static void main(String[] args) {

//        匿名内部类形式实现
        PersonFactory<Person> personFactory2 = new PersonFactory<Person>() {
            @Override
            public Person create(String firstName, String lastName) {
                return new Person(firstName, lastName);
            }
        };
        Person person1 = personFactory2.create("dd", "ddd");

//      简化成Lambda表达式
        PersonFactory<Person> personFactory3 = (f1, f2) -> new Person(f1, f2);
        Person person2 = personFactory3.create("22", "23");

//      使用构造方法引用实现，实现对Lambda表达式的简化
        PersonFactory<Person> personFactory = Person::new;
        Person person = personFactory.create("Peter", "Parker");

        List<Person> list = new ArrayList<>();
        list.add(person);
        list.add(person1);
        list.add(person2);
//      匿名内部类的形式
        list.forEach(new Consumer<Person>() {
            @Override
            public void accept(Person person) {
                System.out.println(person);
            }
        });
        System.out.println("---------第一种Lambda表达式---------");
        list.forEach(pers -> System.out.println(pers));
        System.out.println("---------第二种方法引用-------");
        list.forEach(System.out::println);
//          静态方法引用
        list.forEach(Person::staticTest);
//          普通无参方法引用
        list.forEach(Person::test);
//          普通有参方法引用（需要参数）
//        list.forEach(Person::testPar);//错误代码public void testPar(final Person person)
//        注意有参的普通方法，必须用实例对象来引用
        PersonFactory<Person> personFactory1 = Person::new;
        Person person3 = personFactory1.create("youcan", "youcan");
        list.forEach(person3::testPar);

        //静态引用
        Converter<String, Integer> converter = Integer::valueOf;
        Integer converted = converter.convert("123");
        System.out.println(converted);
    }
}

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

@FunctionalInterface
interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

class Person {
    String firstName;
    String lastName;

    Person() {
    }

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public static void staticTest(final Person person) {

        System.out.println("静态方法引用："+person);
    }

    public void testPar(final Person person) {

        System.out.println("有参方法：" + person);
    }

    public void test() {

        System.out.println("无参方法");
    }

    @Override
    public String toString() {
        return "Person{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                '}';
    }
}