静态方法的泛型
/**
* @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());
}
}
}