Java 第十章.泛型
Java 第十章.泛型
- 1.为什么要有泛型
- 2.在集合中使用泛型
- 3.自定义泛型结构
-
- 3.1使用
- 3.2注意点
- 3.3泛型方法
- 3.4泛型方法的使用情景
- 4.泛型在继承上的体现
- 5.通配符的使用
-
- 5.1概述
- 5.2使用
- 5.3有限制条件的通配符的使用
1.为什么要有泛型
泛型的概念
1. 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
2. 从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象。
3. JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。
为什么要有泛型
那么为什么要有泛型呢，直接Object不是也可以存储数据吗？
1. 解决元素存储的安全性问题，好比商品、药品标签，不会弄错。
2. 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别。
//不在集合中使用泛型
@Test
public void test1(){
ArrayList list = new ArrayList();
//需求：存放学生成绩
list.add(88);
list.add(74);
list.add(87);
list.add(78);
list.add(98);
//问题一：类型不安全
list.add("Tom");
for (Object obj : list){
//问题二：强转时，可能会出现异常
int score = (int)obj;
System.out.println(score);
}
}
2.在集合中使用泛型
1. 集合接口或集合类在jdk5.0时都修改为带泛型的结构
2. 在实例化集合类时，可以指明具体的泛型类型
3. 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（方法，构造器，属性）使用到泛型的位置，都指定为实例化的泛型类型。
add(E e)------>add(Integer e)
4. 注意点：泛型的类型必须是类，不能是基本数据类型。如需要用到基本数据类型，拿相应的包装类代替
5. 如果实例化时，没有指明泛型的类型。默认类型是java.lang.object类型。
//在集合中使用泛型的情况
@Test
public void test2() {
ArrayList<Integer> list = new ArrayList<Integer>();//不能用基本数据类型，只能用包装类
list.add(12);
list.add(92);
list.add(82);
list.add(25);
//编译时就会进行类型检查，保证数据安全
//list.add("Tom");
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
//在集合中使用泛型的情况
@Test
public void test3() {
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("周星驰", 20);
map.put("刘德华", 18);
map.put("王祖贤", 19);
map.put("邱淑贞", 10);
Set<Map.Entry<String, Integer>> entries = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
while (iterator.hasNext()) {
//System.out.println( iterator.next());
Map.Entry<String, Integer> next = iterator.next();
String key = next.getKey();
Integer value = next.getValue();
System.out.println( key + "----------" + value);
}
}
3.自定义泛型结构
3.1使用
public class Order<T> {
String orderName;
int orderId;
//类的内部结构就可以使用类的泛型
T orderT;
public Order() {
}
public Order(String orderName, int orderId, T orderT) {
this.orderName = orderName;
this.orderId = orderId;
this.orderT = orderT;
}
public T getOrderT() {
return orderT;
}
public void setOrderT(T orderT) {
this.orderT = orderT;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + '\'' +
", orderId=" + orderId +
", orderT=" + orderT +
'}';
}
}
----------------------------------------------------------------------------------------------------
public class SubOrder extends Order<Integer>{ // SubOrder不是泛型类
}
----------------------------------------------------------------------------------------------------
public class SubOrder1<T> extends Order<T> { //SubOrder1是泛型类
}
----------------------------------------------------------------------------------------------------
@Test
public void test4() {
//如果定义了泛型类，实例化没有指明类的泛型，则此泛型类型为Object类型
//要求：如果大家定义了类是带泛型的，建议在实例化时指明类的泛型
Order order = new Order();
order.setOrderT(123);
order.setOrderT("Tom");
Order<String> order1 = new Order<String>();
order1.setOrderT("林欢");
}
@Test
public void test5(){
SubOrder sub = new SubOrder();
//由于子类在继承带泛型的父类时，指明了泛型类型，则实例化子类对象时，不需要指明泛型
sub.setOrderT(7485);
SubOrder1<String> sub1 = new SubOrder1<>();
sub1.setOrderT("78型弹道导弹");
}
3.2注意点
1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>
2. 泛型类的构造器如下：public GenericClass(){}。而下面是错误的：public GenericClass<E>(){}
3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
4. 泛型不同的引用不能相互赋值。
尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。
5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
7. jdk1.7，泛型的简化操作：ArrayList<Fruit> flist = new ArrayList<>();
8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型(只有在创建对象时，才知道<T>,而类要先创建好的，所以矛盾)
10. 异常类不能是泛型的
11. 不能使用E[] e = new E[]。但是可以：E[] e = (E[])new Object[c];参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
12.父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
子类不保留父类的泛型：按需实现
没有类型 擦除
具体类型
子类保留父类的泛型：泛型子类
全部保留
部分保留
结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自
己的泛型
3.3泛型方法
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}
-----------------------------------------------------------------------------------------------------------------
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}
3.4泛型方法的使用情景
4.泛型在继承上的体现
1.类A是类B的父类，但G< A > 和 G < B >二者不具备子父类关系，二者是并列关系
2.类A是类B的父类，A< G > 和 B< G >具备子父类关系
@Test
public void test1() {
List<Object> list1 = null;
List<String> list2 = null;
//编译错误，二者不具备子父类关系
//list1 =list2;
List<String> list3 = null;
ArrayList<String> list4 = null;
list3 = list4;//可以
}
5.通配符的使用
5.1概述
通配符：？
使用：类A是类B的父类，G < A >和G < B >是没有关系的，二者共同的父类是：G < ?>
5.2使用
@Test
public void test2() {
List<?> list1 = null;
List<String> list2 = new ArrayList<>();
list2.add("aaa");
list2.add("bbb");
list2.add("ccc");
list1 = list2;
//添加： 对于List就不能想起内部添加数据（null除外）
//list1.add("dd"); //出错
//读取：允许读取数据，读取数据的类型为Object
java.lang.Object o = list1.get(0);
System.out.println(o);
}
5.3有限制条件的通配符的使用
? entends Person:(<=)
G,可以作为G和G的父类，B是A的子类
? super Person:(>=)
G,可以作为G和G的父类，B是A的父类