【09-03】java泛型学习笔记

静态方法的泛型

    /**
     * @description 静态方法的泛型无法使用类定义的泛型，因为类在实例化时才确定具体的泛型类，因此静态方法要使用泛型需要使用泛型方法的方式
     */
    public class GenericityTest {
        /**
         * 泛型方法
         */
        public static <T> T getType(T t) {
            System.out.println(t.getClass().getName());
            return t;
        }
    }

泛型接口

    interface Super<T>{
        void show(T t);
    }
    
    class Sub<T> implements Super<T>{
    
        @Override
        public void show(Object t) {
        }
        
    }

泛型限定

1.使用？

    /**
     * @description 测试泛型限定?
     */
    public class Test {
        /**
         * 泛型限定 --> ? 未知类型
         */
        public static void printCollection(Collection<?> coll) {
            Iterator<?> it = coll.iterator();
            while (it.hasNext()) {
                System.out.println(it.next());
            }
        }
    
        public static void main(String[] args) {
            /**
             * 测试泛型限定 ？
             */
            ArrayList<String> list = new ArrayList<String>();
            for (int i = 0; i < 10; ++i) {
                list.add(i + "");
            }
            printCollection(list);
        }
    }

2.使用？ extends E

    /**
     * @description 测试泛型限定<？ extends E>
     */
    public class Test {
        public static void main(String[] args) {
            /**
             * 测试泛型限定 extends
             */
            ArrayList<Programmer<String>> programmers = new ArrayList<Programmer<String>>();
            for (int i = 0; i < 10; ++i) {
                programmers.add(new Programmer<String>(i + ""));
            }
            printExtendsCollection(programmers);
    
        }
    
        /**
         * 泛型限定 --> ? extends Object 上限限定，未知类型为Object的子类型
         */
        public static <T> void printExtendsCollection(Collection<? extends Super<T>> coll) {
            Iterator<? extends Super<T>> it = coll.iterator();
            while (it.hasNext()) {
                Super<T> t = it.next();
                t.show();
            }
        }
    }
    
    interface Super<T> {
        void show();
    }
    
    class Programmer<T> implements Super<T> {
        private T name;
    
        Programmer(T name) {
            this.name = name;
        }
    
        public T getName() {
            return name;
        }
    
        @Override
        public void show() {
            System.out.println(name);
        }
    
    }

3.使用？ super E

    /**
     * @description 测试泛型限定<? super E>
     */
    public class SuperETest {
        public static void main(String[] args) {
            /**
             * treeSet构造函数原型 <? super E> 说的是比较器可以为E类型的父类型
             */
            /*
             public TreeSet(Comparator<? super E> comparator) { 
                this(new TreeMap<>(comparator));
             }
             */
            SuperETest test = new SuperETest();
            Set<Programmer> programmers = new TreeSet<Programmer>(test.new Comp());
            for (int i = 0; i < 10; ++i) {
                programmers.add(test.new Programmer(10 - i + ""));
            }
            for (Programmer teacher : programmers) {
                System.out.println(teacher.getName());
            }
    
        }
    
        class Person {
            private String name;
    
            Person(String name) {
                this.name = name;
            }
    
            public String getName() {
                return name;
            }
        }
    
        class Programmer extends Person {
            Programmer(String name) {
                super(name);
            }
    
        }
    
        class Comp implements Comparator<Person> {
    
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getName().compareTo(o2.getName());
            }
    
        }
    }

转载于:https://www.cnblogs.com/achievec/p/5838227.html