Java>泛型>>泛型的类、方法、接口以及泛型通配符的如何使用

实例：

定义一个含有泛型的类：

package JiHe.FinXing;

/*
    定义一个含有泛型的类，模拟ArrayList集合
    泛型是一个未知对的数据类型，当我们不确定什么什么数据类型的时候，可以使用泛型
    泛型可以接收任意的数据类型，可以使用Integer,String,Student...
    创建对象的时候确定泛型的数据类型
 */
public class GenericClass<E> {
    private E name;

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

    public E getName() {
        return name;
    }
}

使用这个泛型类：

package JiHe.FinXing;

public class Demo01GenericClass {
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        GenericClass gc = new GenericClass();
        gc.setName("不写泛型默认为Object类型");
        Object obj = gc.getName();
        System.out.println(obj);

        //创建GenericClass对象，泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(11);
        Integer name = gc2.getName();
        System.out.println(name);

        //创建GenericClass对象，泛型使用String类型
        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("这是一个String类型的字符串");
        String str = gc3.getName();
        System.out.println(str);
    }
}

运行结果：

不写泛型默认为Object类型
11
这是一个String类型的字符串

定义一个含有泛型方法的类：

package JiHe.FinXing;

/*
    定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间

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

    含有泛型的方法，在调用方法的时候确定泛型的数据类型
    传递什么类型的参数，泛型就是什么类型
 */
public class GenericMethod {
    //定义一个含有泛型的方法
    public <M> void method01(M m){
        System.out.println(m);
    }

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

使用这个类：

package JiHe.FinXing;

public class Demo02GenericMethod {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();

        /*
            调用含有泛型的方法method01
            传递什么类型，泛型就是什么类型
         */
        gm.method01(123);
        gm.method01("ashda");
        gm.method01(true);
        gm.method01(6.6);
        System.out.println("============");

        gm.method01("静态方法，不建议创建对象使用");

        //静态方法，通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(56226);
    }
}

运行结果：

123
ashda
true
6.6
============
静态方法，不建议创建对象使用
静态方法
56226

定义一个含有泛型的接口：

package JiHe.FinXing;

/*
    定义含有泛型的接口
 */
public interface GenericInterface<I> {
    public abstract void method03(I i);
}

定义一个实现类GenericInterfaceImpl1使用这个接口：

package JiHe.FinXing;

/*
    含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
 */
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void method03(String s) {

    }
}

定义一个实现类GenericInterfaceImpl2使用这个接口：

package JiHe.FinXing;
/*
    含有泛型的接口第二种使用方式，接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
    就想当与定义了一个含有泛型的类，创建对象的时候确定了泛型的类型
 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
    @Override
    public void method03(I i) {

    }
}

使用实现类：

package JiHe.FinXing;

/*
    测试含有泛型的接口
 */
public class Demo03GenericInterface {
    public static void main(String[] args) {
        //创建GenericInterfaceImpl1对象
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method03("字符串");

        //创建GenericInterfaceImpl2对象
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method03(2626);

        GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
        gi3.method03(6.6);
    }
}

运行结果：

字符串
2626
6.6

泛型的通配符使用方法：

定义一个类：

package JiHe.FinXing;

import java.util.ArrayList;
import java.util.Iterator;

/*
    泛型的通配符：
        ？：代表任意的数据类型
    使用方法：
        不能直接创建对象
        只能作为方法的参数使用
 */
public class Demo04Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(111);
        list01.add(222);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("AAA");
        list02.add("BBB");

        printArray(list01);
        printArray(list02);
    }

    /*
        定义一个方法，能遍历所有类型的ArrayList集合
        这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符？来接收数据类型
        注意：
            泛型没有继承概念的 不能使用Object，只能用通配符？
     */
    public static void printArray(ArrayList<?> list){
        //使用迭代器遍历
        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }

    }
}

使用这个类：

111
222
AAA
BBB