[Java进阶]学习笔记9：泛型

概念

不使用泛型

使用泛型

定义和使用含有泛型的类

泛型可以接收任意的数据类型，可以使用Integer，String，Student
创建对象时确定泛型的数据类型

GenericClass.java

public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

Demo01Generic.java

public class Demo01Generic {
    public static void main(String[] args) {
        //使用String
        GenericClass<String> gc1 = new GenericClass<>();
        gc1.setName("test");
        System.out.println(gc1.getName());

        //使用Integer
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1109);
        System.out.println(gc2.getName());
    }

}

定义和使用含有泛型的方法

定义在方法的修饰符和返回值类型之间

格式：

修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
    方法体;
}

含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型

GenericMethod.java

public class GenericMethod {
    //定义含有泛型的方法
    public <M> void method01(M m){
        System.out.println("m:"+m);
    }

    //定义含有泛型的静态方法
    public static <S> void method02(S s){
        System.out.println("s:"+s);
    }
}

DemoGeneric.java

public class Demo02Generic {
    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();

        //调用含有泛型的方法
        gm.method01(10);
        gm.method01("马保国");
        gm.method01(true);
        System.out.println("============");

        GenericMethod.method02("老八");
        GenericMethod.method02(100);
        GenericMethod.method02(false);
    }
}

定义和使用含有泛型的接口

GenericInterface.java

public interface GenericInterface<I> {
    public abstract void method(I i);
}

第一种使用方法：

定义接口的实现类，实现接口，指定接口的泛型
GenericInterfaceImpl1.java

public class GenericInterfaceImpl1 implements GenericInterface<String>{

     @Override
     public void method(String s) {
        System.out.println(s);
      }
}

第二种使用方法：

接口使用什么泛型，实现类就是用什么接口

就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
GenericInterfaceImpl2.java

public class GenericInterfaceImpl2<I> implements GenericInterface<I>{

    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

Demo03Generic.java

public class Demo03Generic {
    public static void main(String[] args) {

        //1
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method("laoba");

        //2
        GenericInterfaceImpl2<Integer> gi2_1 = new GenericInterfaceImpl2<>();
        gi2_1.method(1109);
        GenericInterfaceImpl2<Double> gi2_2 = new GenericInterfaceImpl2<>();
        gi2_2.method(11.09);
    }
}

泛型通配符

通配符的使用：
不知道是用什么类型来接收的时候，可以使用？，（？表示位置通配符）

泛型的通配符：
？：代表任意的数据类型

使用方式：
不能创建对象使用
只能作为方法的参数使用

定义一个方法,能遍历所有类型的ArrayList集合
这时候我们不知道ArrayList集合是用什么数据类型，可以使用泛型的通配符？来接收数据类型

注意：泛型没有继承概念的

    public static void printArray(ArrayList<?> list){
        //使用迭代器遍历集合
        Iterator<?> iterator = list.iterator();

        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("老八");
        list02.add("马保国");

        printArray(list01);
        printArray(list02);
    }

泛型通配符的高级使用：

要求看懂即可
泛型的上限限定：? extends E //代表使用的泛型只能是E类型的子类/本身
泛型的下限限定：? extends E //代表使用的泛型只能是E类型的父类/本身