127、函数接口---supplier<T>

java.util.function.supplier<T> 
一、Supplier<T>接口被称为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会生产什么类型数据。
二、接口仅包含一个无参的方法：T get().用来获取一个泛型参数指定类型的对象数据。
三、supplier一般作用是用来产生一个对象（调用一次get方法，返回一次T所代表的对象）
    supplier用来创建对象的，它和常规new对象不同:
        比如我们有个Person类，如果：
        1、Person p1 = new Person();这里会马上创建一个对象
        2、Supplier<Persion> s1 = Persion::new;这里不会创建对象
            Persion p1 = s1.get(); 这里会创建一个对象,而且会返回Persion对象
            Persion p1 = s1.get(); 继续创建一个Persion对象
四、举例：
    注意：本举例只是一个范例，没有突出supplier<T>的常规用途，常规用途是用来工厂生产对象的（啥叫工厂生产对象，就是你给我一个模子，我调用一次get（）方法，我就给你生产一个<T>类型的对象出来）

public class Demo05Person {
    private String name;
    private int age;
    static int structCnt = 0;

    public Demo05Person() {
        System.out.print("Person无参构造函数,第: ");
        structCnt++;
        System.out.print(structCnt);
        System.out.println(" 次调用");
    }

    public Demo05Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person有参构造函数");
        structCnt++;
        System.out.print(structCnt);
        System.out.println(" 次调用");
    }

    @Override
    public String toString() {
        return "Demo05Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

import java.util.function.Supplier;

/*
    常用的函数式接口
    java.util.function.supplier<T> 接口仅包含一个无参的方法：T get().用来获取一个泛型参数指定类型的对象数据。
    Supplier<T>接口被称为生产型接口，指定接口的泛型是什么类型，那么接口中的get方法就会生产什么类型数据。

    举例：给定数组，获取最大值
 */
public class Demo05Supplier {


    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        //  ****** 测试：先测试Supplier对象工厂的实至名归 ******
        //1、*** 传统方法new,马上创建了对象***
        Demo05Person p1 = new Demo05Person(); //这里已经创建了对象
        System.out.println("================== 1 =====================");
        //  *** 测试：采用Suppplier类创建工厂 ***
        //1、这里不会打印东西，因为没有创建对象
        Supplier<Demo05Person> s1 = Demo05Person::new;//这里实际定位了无参构造方法
        System.out.println("================== 2 =====================");
        //2、这里才是实际创建了对象
        Demo05Person p2 = s1.get();
        s1.get();

        //  ****** 测试：测试Supplier其它应用 ******
        int[] ints = {12,31,323,12,324,434,-123,0};
        //传入一个Supplier接口，并且实现它的抽象方法，使用Lambda表达式
        int maxValue = getMax(()->{
            int max = ints[0];
            for (int anInt : ints) {
                if(anInt > max)
                    max = anInt;
            }
            return max;
        });
        System.out.println("最大数为：" + maxValue);
    }
}

输出结果：

Person无参构造函数,第: 1 次调用
================== 1 =====================
================== 2 =====================
Person无参构造函数,第: 2 次调用
Person无参构造函数,第: 3 次调用
最大数为：434