泛型-Java

定义含有泛型的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class GenericClass <E> {
    E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}
 public static void main(String[] args) {
        GenericClass<String> gc = new GenericClass<>();
        gc.setName("hxx");
    }

定义含有泛型的方法

  • 修饰符 <泛型> 返回值类型 方法名(参数列表){ ………. }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class GenericClass{
   public <M> void method(M m){
       System.out.println(m);
   }
   public static <S> void methodB(S s){
   }
}
public static void main(String[] args) {
        GenericClass gc = new GenericClass();
        gc.method("hxx");
        gc.method(true);
        GenericClass.methodB("含有泛型的静态方法通过类名调用");
        
    }

含有泛型的接口

  • 修饰符 interface 接口名 <代表泛型的变量> { }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public interface GenericInterface<I> {
    public abstract void add(I e);
    public abstract I get();
}

public class GenericInterfaceImpl <E>implements GenericInterface <E> {

    @Override
    public void add(E e) {

    }

    @Override
    public E get() {
        return null;
    }
}
 public static void main(String[] args) {
        GenericInterfaceImpl<String> gcI = new GenericInterfaceImpl();
        gcI.add("hxx");
        System.out.println(gcI.get());
        GenericInterfaceImpl <Integer> gc2 = new GenericInterfaceImpl<>();
        gc2.add(100);
        System.out.println(gc2.get());
    }

泛型通配符<?>

  • 代表任意类型，不能定义时使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
        ArrayList<String>list1 = new ArrayList<>();
        list1.add("hxx");
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(22);
        printArray(list1);
        printArray(list2);
    }
    public static void printArray(ArrayList<?> list){
        //使用迭代器遍历
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

通配符高级使用–受限泛型

  • 泛型的上限：只接受该类型及其子类

    类型名 <? extends 类 > 对象名称

  • 泛型的下限：只接受该类型极其父类

    类型名 <? super 类 > 对象名称