public class GenericDemo {

    public static void main(String[] args) {

        // 未使用泛型，则可以添加任意Object类型的数据

        List noGrnerics = new ArrayList<>();

        noGrnerics.add(1);

        noGrnerics.add("hello");

        noGrnerics.add("1L");

        noGrnerics.add(new GenericDomain(1L,"Generic"));

        // 由于没有使用泛型，在取出数据时必须要知道某个位置上的某个数据的数据类型，并加以强制转换，否则要出错,除非用Object接收。

        Integer integer = (Integer) noGrnerics.get(0);

        System.out.println("integer = " + integer);

        // 由于不知道某个位置上的数据类型，用Object接收

        Object objIndex1 = noGrnerics.get(1);

        System.out.println("objIndex1 = " + objIndex1);

        Object objeIndex3 = noGrnerics.get(3);

        System.out.println("objeIndex3 = " + objeIndex3);

        // 虽然可以通过类对象来知道类属性，但是这样不是太麻烦了吗？？

        System.out.println("objeIndex3.getClass() = " + objeIndex3.getClass());

        // 使用泛型

        List<String> strs = new ArrayList<>();

        strs.add("str1");

        strs.add("str2");

        strs.add("str3");

        // 因为指定了这个List中只能放置String类型的数据，当这里放置其他类型的数据时就会报错，因为不能装进去

        // 从某种角度上可以认为泛型解决了强制类型转换，使数据特征更明显，拥有一致性

//        strs.add(1);

        String str = strs.get(0);

        System.out.println("str = " + str);

    }

}

public class GenericDemo2 {

    /**

     * 程序目标，向一个List<String>的泛型数组中添加Integer类型的数据

     *

     * @param args

     */

    public static void main(String[] args) {

        List<String> strs = new ArrayList<>();

        strs.add("str1");

        strs.add("str2");

        strs.add("str3");

        strs.add("str4");

        // 这里是添加不进去的，因为指定了泛型类型，且没有泛型擦除

        // strs.add(new Integer(1));

        System.out.println("Before add a Integer value : " + strs);

        // 通过泛型在运行时擦除的原理，利用反射向泛型中添加Integer数据

        Class<List<String>> clazz = (Class<List<String>>) strs.getClass();

        try {

            // 这里在利用反射获取add方法时，如果参数类型指定为String.class，

            // 则说明add方法为，java.util.ArrayList.add(java.lang.String)

            // 而我们传入了一个Integer类型的数据，则显然不能添加成功，会抛出 java.lang.NoSuchMethodException

            clazz.getDeclaredMethod("add", String.class).invoke(strs, new Integer(1));

            // 这里原因一样，java.util.ArrayList.add(java.lang.Integer) 但是用的int，

            // 请记住，java是强类型语言,这里不存在自动装箱和拆箱

            clazz.getDeclaredMethod("add", Integer.class).invoke(strs, 2);

            // 这里也是不正确的，因为Class<List<String>>指定了放String

            clazz.getDeclaredMethod("add", Integer.class).invoke(strs, new Integer(4));

            //同上

            clazz.getDeclaredMethod("add", int.class).invoke(strs, 5);

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            //正确做法

            try {

                clazz.getDeclaredMethod("add", Object.class).invoke(strs, 3);

                System.out.println("strs = " + strs);

                // 只有Object能行

                clazz.getDeclaredMethod("add", String.class).invoke(strs, "4");

                System.out.println("strs = " + strs);

            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException

                    | NoSuchMethodException | SecurityException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

        System.out.println("After add a Integer value : " + strs);

    }

}

public class GenericTypeDemo {

    public static void main(String[] args) {

        // 这里的字节码类型为ArrayList

        List<String> strings = new ArrayList<>();

        // 这里的字节码类型也为ArrayList

        List<Integer> integers = new ArrayList<>();

        System.out.println("strings.getClass() = " + strings.getClass());

        System.out.println("integers.getClass() = " + integers.getClass());

        System.out.println("integers.getClass() == strings.getClass() = "

        + (integers.getClass() == strings.getClass()));

    }

}

public class GenericDemo3 {

    public static void main(String[] args) {

        // 需求：定义一个方法，该方法用于打印出任意参数类型化的集合中的所有数据。

        List<String> strings = new ArrayList<>();

        strings.add("a");

        strings.add("b");

        strings.add("c");

        strings.add("f");

        printCollectionElements(strings);

        printStringCollectionElements(strings);

        List<Integer> integers = new ArrayList<>();

        integers.add(1);

        integers.add(2);

        integers.add(3);

        integers.add(4);

        printCollectionElements(integers);

        // 这里就不能用了

//        printStringCollectionElements(integers);

    }

    /**

     * 定义一个方法，该方法用于打印出任意参数类型化的集合中的所有数据。

     * 这种是通配方法，能够打印所有的，其通配之处就在与?，?可以引用其他各种参数化的类型

     * @param collection

     */

    public static void printCollectionElements(Collection<?> collection) {

        collection.forEach(System.out::println);

    }

    /**

     * 打印String类型的集合数据，由于制定了泛型类型为String，则只能打印String类型的集合

     * @param collection

     */

    public static void printStringCollectionElements(Collection<String> collection) {

        collection.forEach(System.out::println);

    }

}