Java编程思想：泛型方法

import java.util.*;

public class Test {
    public static void main(String[] args) {
//        GenericMethods.test();
//        GenericVarargs.test();
        BasicGeneratorDemo.test();
    }
}

/*
    如论合适，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法
    因为它可以使事情更清楚明白。另外，对于一个static的方法而言，无法访问泛型类
    的类型参数，所以，如果static方法需要使用泛型的能力，就必须使其成为泛型方法
 */

class GenericMethods {
    public <T> void f(T x) {
        System.out.println(x.getClass().getName());
    }

    public static void test() {
        GenericMethods gm = new GenericMethods();
//        gm.f("");
//        gm.f(1);
//        gm.f(1.0);
//        gm.f('c');
//        gm.f(gm);
        gm.f(New.map());
    }
}

/*
    需求：
        利用方法的推导功能，简化我们创建集合类时的编码，但是这个工作
        现在已经不需要了，因为IDE和编译器都可以满足自动推导的功能。
 */
class New {
    public static <K,V> Map<K,V> map() {
        return new HashMap<>();
    }
}

/*
    类型推导只对赋值操作有效果，其他时候并不起作用。如果你将一个泛型方法
    调用的结果（例如New.map()）作为参数，传递给另一个方法时，这时候编译
    器并不会执行类型推导。这种情况下，编译器认为：调用泛型方法后，其返回值
    被赋给了一个Object类型的变量
        ——现在好像可以哦
 */
class LimtsOfInference {
    static void f(Map<String, List<? extends Map>> arg) {

    }

    static void test() {
        f(New.map());
    }
}
/*
    泛型方法中，显式指明类型的语法。要显式指明类型，必须在点操作符
    与方法名之间插入尖括号，然后把类型置于尖括号内。
        ——这些知识点，有点不适用了，现在
 */
class LimtsOfInference2 {
    static void f(Map<String, List<? extends Map>> arg) {

    }

    static void test() {
        f(New.<String,List<? extends Map>>map());
    }
}

/*
    15.4.2 可变参数与泛型方法
 */
class GenericVarargs {
    public static <T> List<T> makeList(T... args) {
        List<T> result = new ArrayList<>();
        for (T item : args) {
            result.add(item);
        }
        return result;
    }

    static void test() {
        List<String> ls = makeList("A");
        System.out.println(ls);

        ls = makeList("A", "B", "C");
        System.out.println(ls);

        ls = makeList("adfasdfsafsdf".split(""));
        System.out.println(ls);
    }
}

/*
    15.4.3 用于Generator的泛型方法
 */
interface Generator<T>{
    T next();
}
class Generators {
    //给我一个容器，给我一个生成器，我帮你把容器填满，只省下了几行for循环的代码
    public static <T> Collection<T> fill(Collection<T> coll, Generator<T> gen, int len) {
        for (int i = 0; i < len; i++) {
            coll.add(gen.next());
        }
        return coll;
    }
}

/*
    15.4.4 一个同游的Generator

    下面的程序，可以为任何类构造一个Generator，只要该类具有默认的构造器，为了
    减少类型的声明，它提供了一个泛型的方法，用于生成BasicGenerator。我感觉我
    上一个小节的代码，也可以为任何类构造了一个Generator啊


    我觉得真正的区别会在这儿，以往的Generator，是需要自己去实现next()部分的
    代码的，而这个Generator却不用，你传给它一个Class对象，它就能为你生成许多
    个对象，是真正意义上的简化了操作
 */
class BasicGenerator<T> implements Generator<T> {

    private Class<T> type;

    public BasicGenerator(Class<T> type) {
        this.type = type;
    }

    @Override
    public T next() {
        try {
            return type.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static <T> Generator<T> create(Class<T> type) {
        return new BasicGenerator<>(type);
    }
}

class CounterObject {
    private static long counter = 0;
    private final long id = counter++;

    public long id() {
        return id;
    }

    public String toString() {
        return "Counted Object "+id;
    }
}

class BasicGeneratorDemo {
    static void test() {
        Generator<CounterObject> g = BasicGenerator.create(CounterObject.class);
        for (int i = 0; i < 5; i++) {
            System.out.println(g.next());
        }
    }
}

/*
    15.4.5 简化元组的使用
 */

class TwoTuple<A, B> {
    public final A first;
    public final B second;

    public TwoTuple(A first, B second) {
        this.first = first;
        this.second = second;
    }

    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

/*
    这个方案只是在创建的时候，给简化了一下，统一了一下创建的接口
 */
class Tuple {
    public static <A, B> TwoTuple<A, B> tuple(A a, B b) {
        return new TwoTuple<>(a, b);
    }
}

/*
    问题：
        方法f()返回一个参数化的TwoTuple对象，而f2()返回的是非参数化的
        TwoPuple对象。在这个例子中，编译器并没有f2()的警告信息，因为我们
        并没有将其返回值作为参数化对象使用。在某种意义上，它被“向上转型”为
        一个非参数化的TwoTuple。然而，如果试图将f2()的返回值转型为参数化
        的TwoTuple，编译器就会发出警告
            ——有点尴尬，参数化其实就是指的泛型化
 */
class TupleTest {
    static TwoTuple<String, String> f() {
        return Tuple.tuple("AAA","BBB");
    }

    static TwoTuple f2() {
        return  Tuple.tuple("BBB","CCC");
    }

    static void test(){}
}

/*
    15.4.6 一个Set实用工具

    需求：
        用Set表示集合的各种关系，如交集、并集、、补集
 */
class Sets {
    public static <T> Set<T> union(Set<T> a, Set<T> b) {
        Set<T> result = new HashSet<>(a);
        a.addAll(b);
        return result;
    }

    public static <T> Set<T> intersection(Set<T> a, Set<T> b) {
        Set<T> result = new HashSet<>(a);
        result.retainAll(b);
        return result;
    }

    public static <T> Set<T> difference(Set<T> superset, Set<T> subset){
        Set<T> result = new HashSet<>(superset);
        result.retainAll(subset);
        return result;
    }

    public static <T> Set<T> complement(Set<T> a, Set<T> b) {
        return difference(union(a,b),intersection(a,b));
    }
}


enum Letters{
    A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
}

/*
    EnumSet:
        用来从enum直接创建Set，在这儿，我们向static方法EnumSet.range()传入某个范围的
        第一个元素和最后一个元素，然后它将返回一个Set，其中包括该范围内的所有元素
 */

class LettersDemo {
    static void test() {
        /*
            我看案例中，有一个import static.generics.watercolors.Watercolos.*
            又看到他解释说：为了方便起见（可以直接使用enum中的元素名），下面的实例以
            static的方式引入Watercolors。
                ——这种写法，我从来没有用过，标记一下
         */
        Set<Letters> l1 = EnumSet.range(Letters.A, Letters.D);
        //。。。
    }
}