Java中泛型的使用

泛型

定义：定义的时候表示一种未知的数据类型，在使用的确定其具体的数据类型，如果没有指定那么就是object的类型。

1、定义和使用含有泛型的类

 public class 类名<泛型变量>{
	泛型变量的位置：写任意字母，例如:T,E
}

例子：

public class MyArrayList<E> {
    

}

使用含有泛型的类：常见该类对象的时候，确定该类泛型的的距离数据类型

MyArrayList<String> stringMyArrayList = new MyArrayList<>();

那么泛型的意义是什么？

public class MyArrayList<E> {
    E e;
    public E method(E e){
        return e;
    }
}

当类中的成员变量或者方法的形参类型\返回值类型不确定的时候，就可以把该类定义为含有泛型的类。

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

调用含有泛型方法的时候确定其泛型的具体数据类型,一般字母使用;T

public static void main(String[] args) {
    Integer method = method(100);
    String yxinmiracle = method("yxinmiracle");
    System.out.println(method); // 100
    System.out.println(yxinmiracle); // yxinmiracle
}

// 定义含有泛型的方法
public static <T> T method(T t){
    return t;
}

什么时候会定义含有泛型的方法：

如果一个类中，某个方法的参数类型或者返回值类型不确定，可以把该方法定义为含有泛型的方法。

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

一般字母使用:E

使用含有泛型的接口：确实接口泛型的具体数据类型

• 通过实现类的方式确定接口的泛型的具体数据类型

public class IAImpl implements IA<String>{

    @Override
    public void method(String s) {

    }

    @Override
    public String method1(String s) {
        return s;
    }
}

• 实现类实现接口的时候不确定接口泛型的具体数据类型而是创建实现类对象的时候确定接口泛型的具体数据类型

public class IAImpl2<E> implements IA<E>{

    @Override
    public void method(E e) {
        System.out.println("实现method");
    }
}

main方法：

public class Test {
    public static void main(String[] args) {
        IAImpl2<String> impl2 = new IAImpl2<>();
        impl2.method("yinmiracle");
    }
}

4、通配符的基本使用

怎么使用一个方法接收这四个list？

ArrayList<Object> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
ArrayList<Integer> list3 = new ArrayList<>();
ArrayList<Number> list4 = new ArrayList<>();

可以使用：

 public static void method1(ArrayList list){ 
     
}

或者：

 public static void method2(ArrayList<?> list){ // 不能添加

 }

这两个的区别在于：

    public static void main(String[] args) {
        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<Integer> list3 = new ArrayList<>();
        ArrayList<Number> list4 = new ArrayList<>();

        list2.add("yxinmiracle");
        method1(list2);
        method2(list2);
    }

    // 定义一个方法可以接收以上4个集合
    public static void method1(ArrayList list){ 
        Object obj = list.get(0);
        list.add("nihao");
        System.out.println("obj"+obj);
        System.out.println("list"+list);
    }

    public static void method2(ArrayList<?> list){ // 不能添加
        Object obj = list.get(0);
//        list.add("add"); // 编译报错
        System.out.println("obj"+obj);
        System.out.println("list"+list);
    }

5、通配符高级使用----受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式： 类型名称 <? extends 类 > 对象名称
• 意义： 只能接收该类型及其子类

泛型的下限：

• 格式： 类型名称 <? super 类 > 对象名称
• 意义： 只能接收该类型及其父类型

比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

public class Test {
    public static void main(String[] args) {
        /*
            通配符高级使用----受限泛型:
                上限: <? extends 类名>  只能接收该类类型或者其子类类型
                下限: <? super 类名>   只能接收该类类型或者其父类类型
         */
        // 关系:String继承Object,Integer继承Number,Number继承Objec
        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<Integer> list3 = new ArrayList<>();
        ArrayList<Number> list4 = new ArrayList<>();
        
        method1(list1);
        method1(list2);
        method1(list3);
        method1(list4);
        
        //method2(list1);// 编译报错
        //method2(list2);// 编译报错
        method2(list3);
        method2(list4);


        method3(list1);
        //method3(list2);// 编译报错
        method3(list3);
        method3(list4);
    }

    // 定义一个方法,只可以接收以上list3和list4集合
    public static void method2(ArrayList<? extends Number> list){

    }
    
    // 定义一个方法,只可以接收以上list3和list4,list1集合
    public static void method3(ArrayList<? super Integer> list){

    }
    
    // 定义一个方法,可以接收以上4个集合
    public static void method1(ArrayList<?> list){
       
    }
    // 定义一个方法,可以接收以上4个集合
    public static void method(ArrayList list){

    }
}