Java 泛型

一、为什么要有泛型

【1】解决元素存储的安全性问题。
【2】解决获取数据元素时，需要类型强转的问题。

【3】可以统一数据类型，便于操作。
【4】将运行时的异常提前到了编译时，提高了效率。
【5】实现代码的模板化，把数据类型当作参数传递，提高了可重用性。
【6】只要在编译时期没有出现警告，那么运行时期就不会出现 ClassCastException 异常。

 1 public class Demo {
 2     //泛型在使用时必须左右一致，不存在继承；
 3     public static void main(String[] args) {
 4         ArrayList<?> list1 ;
 5         ArrayList<String> list2 = new ArrayList<String>();
 6         ArrayList<Integer> list3 = new ArrayList<Integer>();
 7         ArrayList<Object> list4 = new ArrayList<String>();//泛型在使用时必须左右一致，不存在继承；
 8         list1 = list2;
 9         list1 = list3;//不会报错，使用了通配符，通配符表示任意类型，这是在使用，把？当成任何一种类型，
10                       //？就是任何类型。
11         list2 = list3; //会报错  因为两者在定义时使用泛型，一旦确定了类型就不能够改变类型，
12                       //只能是给定的一种泛型类型。
13     }
14 }

二、泛型类

定义在类上的泛型是在创建对象时确定：

1 public class MyClass1<E> {
2     /** 定义具有泛型的类
3      * 修饰符 class 类名 <范型变量>{
4      * 范型变量一般用E，K，V，T；
5      * }
6      */
7      //......
8 }

三、泛型接口

由实现类对象确定

1 /*
2     泛型接口(接口上含有泛型)
3     格式:
4         public abstract interface 接口名<泛型变量> {}
5  */
6 public interface MyInter<T> {
7    //......
8 }

四、泛型方法

创建在放方法上的泛型是在真正调用方法时确定，一般都由传入的参数确定，包含这个方法的类创建对象时，并不会确定方法上的类型，一定在调用方法时确定。

 1 /*
 2     泛型方法(方法上含有泛型)
 3     格式:
 4         修饰符 <泛型变量> 返回值类型 方法名称(参数列表...) {
 5             //...
 6         }
 7  */
 8 public class MyClass02<T> {
 9     //泛型方法: 泛型E是在方法上自己定义的
10     public <E> E getE(E e){
11         
12     }
13 }

五、通配符<？>

统配符的使用如下：先说说T和?的区别：基本泛型T是用于定义，将数据类型参数化，不能用于实例化。而 ? 则是在实例化对象时不确定泛型具体参数类型的时候泛指 Object的所有子类型。但?不能和 Object等效，?是类型实参而不是类型形参，它用于泛指各种类型实参，当具体类型不确定的时候就可以使用？示例如下：

//使用通配符，调用方法时，就可以传入任何类型的list集合
public static void test(List<?> list) {

}

六、上下界通配符

上下界通配符其实涉及到 Java 的多态属性，上下转型的可行性，子类实例可以转换成父类实例，但是父类实例却不一定能转换成子类实例，只有本身就是该子类实例向上转型的父类实例才可以向下转型为子类实例。
【1】<? extends A>：可以存放A 及其子类（带有子类限定的可以从泛型读取）；

 1 public class EnumTest<T extends B> {
 2     public static void main(String[] args) {
 3         //可以存放B 及其子类 所以 A 是不行的
 4         //EnumTest<A> a = new EnumTest<A>();
 5         EnumTest<B> b = new EnumTest<B>();
 6         EnumTest<C> C = new EnumTest<C>();
 7     }
 8 
 9 }
10 class A{};
11 class B extends A{};
12 class C extends B{};

【2】<? super A>：可以存放A 及其父类（带有超类限定的可以从泛型写入），在泛型类中是不能进行 super 向上转型的。

//设定通配符的下限这并不少见，在TreeSet集合中就有....我们来看一下
public TreeSet(Comparator<? super E> comparator) {
      this(new TreeMap<>(comparator));
}

那它有什么用呢？我们想一下，当我们想要创建一个 TreeSet<String> 类型的变量的时候，并传入一个可以比较 String 大小的Comparator。那么这个 Comparator 的选择就有很多了，它可以是 Comparator<String>，还可以是类型参数是 String 的父类，比如说 Comparator<Objcet>....这样做，就非常灵活了。也就是说，只要它能够比较字符串大小，就行了。

【界限通配符在集合】应用时会影响集合的读写行为：
【1】上界<? extends A> 限制了类型上限，只能向上转型，可以读，但是没法写，因为子类型不确定，没法向下转型；
【2】下界<? super A>限制类型的下限，只能向下转型，可以写，但是没法读，因为父类型不确定，没法向上转型。

 1 public class Test {
 2     public static void main(String[] args) {
 3         //<? extends B> 范围: A类或者A的子类
 4         //由于下限不确定，所以无法向下转型至具体类型
 5         List<? extends B> list1 = new ArrayList<B>(){{add(new B());}};
 6         //list1.add(new B()); //无法添加该类型, 向下转型无法确定目标类型
 7         //list1.add(new C());
 8         //返回类型 A or B
 9         A a = list1.get(0); //正常向上转型
10 
11         //<? super B> 范围: B类或者B的父类
12         //由于上限不确定，所以B类和B类的子类均可以加入，但是B类的父类不行
13         List<? super B> list2 = new ArrayList<>();
14         //list2.add(new A()); //无法向下转型
15         list2.add(new B()); //正常向上转型
16         list2.add(new C());
17         //C c = list2.get(1);//无法向下转型，不加强制转换会报错
18         B b = (B) list2.get(0);
19         C c = (C)list2.get(1);
20     }
21     static class A {};
22     static class B extends A {};
23     static class C extends B {};
24 }

七、注意事项

1）、静态方法中不能使用类的泛型。
2）、如果泛型类是一个接口或抽象类，则不可创建泛型类的对象。
3）、不能在 catch 中使用泛型。
4）、从泛型类派生子类，泛型类型需具体化。

posted @ 2020-11-21 22:54 Java程序员进阶阅读(5) 评论(0) 编辑收藏举报

刷新页面返回顶部

Java程序员进阶