【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());
    		}

    	}
    }