泛型(Generic)
为什么要有泛型
泛型：标签 jdk5.0开始有的
在jdk5之前，只能把元素类型设计为：Object，5之后使用泛型来解决，因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>，List<E>，ArrayList<E>这个<E>就是类型参数，即泛型。
概念
所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参)。
在集合中使用泛型
泛型是类型，不能是基本数据类型，需要使用其包装类
总结：
-
集合接口或集合类在jdk5.日时都修改为带泛型的结构。
-
在实例化集合类时，可以指明具体的泛型类型
-
指明完以后，在集合类或接口中凡是定义类或接口时，内部结构(比如：方法，构造器，属性等)使用到类的泛型的位置，内部结构使用到类的泛型的位置，都指定为实例化的泛型类型。eg：add(E e) -------> 实例化以后：add(Integer e)
-
注意点：泛型的类型必须是类，不能是基本数据类型、需要用到基本数据类型的地方，拿包装类替换
-
-
如果实例化时，没有指名泛型的类型，默认类型为java.lang.Object类型
public class GenericTest {
//在集合中使用泛型之前的情况
@Test
public void test1(){
ArrayList list = new ArrayList();
//需求：存放学生成绩
list.add(78);
list.add(87);
list.add(98);
list.add(68);
//问题一，类型不安全
//list.add("Tom");
for (Object score : list){
//问题二：强转时可能出现ClassCastException异常
int stuScore = (Integer) score;
System.out.println(stuScore);
}
}
//在集合中使用泛型的情况 以ArrayList举例
@Test
public void test2(){
ArrayList<Integer> list = new ArrayList<>();
list.add(78);
list.add(88);
list.add(68);
list.add(98);
//问题一，编译就不通过
// list.add("Tom");
//方式二：使用迭代器遍历
Iterator<Integer> integerIterator = list.iterator();
while (integerIterator.hasNext()){
System.out.println(integerIterator.next());
}
// //方式一：增强for循环遍历
// for (Integer score : list){
// //避免了强转操作
// int stuScore = score;
// System.out.println(stuScore);
// }
}
//在集合中使用泛型的情况 以HashMap举例
@Test
public void test3(){
//jdk7新特性，类型推断
Map<String, Integer> map = new HashMap<>();
map.put("Tom",18);
map.put("Mike",28);
map.put("Jreey",38);
map.put("Mary",48);
//报错
//map.put(15,78);
//泛型的嵌套
Set<Map.Entry<String, Integer>> entry = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
// while (iterator.hasNext()){
// System.out.println(iterator.next());
// }
while (iterator.hasNext()){
Map.Entry<String, Integer> e = iterator.next();
String key = e.getKey();
Integer value = e.getValue();
System.out.println(key + "-----------------" + value);
}
}
}
自定义泛型结构
-
泛型类
-
泛型接口
-
泛型方法
泛型类与泛型接口 Day08
如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型，但不等价于Object
要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
建议：实例化时指明类的泛型
由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型
泛型不同的引用不能相互赋值。
如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象
泛型类的构造器如下: public GenericClass()。
jdk1.7，泛型的简化操作: ArrayList<Fruit> flist = new ArrayList<>() 类型推断
静态方法中不能使用类的泛型
类的泛型是在造对象(实例化)的时候指定的，而静态结构要早于对象的创建所以不能使用
异常类不能是泛型的
不能使用new E[]。但是可以:E[]elements =(E[])new Object[capacity];参考:ArrayList源码中声明:Object[] elementData，而非泛型参数类型数组。
父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型:
-
子类不保留父类的泛型:按需实现
-
没有类型，擦除
-
具体类型
-
-
子类保留父类的泛型:泛型子类
-
全部保留
-
部分保留
-
结论:子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型
泛型方法
定义：泛型方法:在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。换句话说，泛型方法所属的类是不是泛型类都没有关系。
泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
泛型在继承上的体现
类A是类B的父类，G<A>和G<B>二者不具备子父类关系，二者是并列关系。
@Test
public void test1(){
Object obj = null;
String str = null;
obj = str;
Object[] obj1 = null;
String [] str2 = null;
obj1 = str2;
//编译不通过
// Date date = new Date();
// str = date;
List<Object> list1 = null;
List<String> list2 = new ArrayList<>();
//此时的List1和List2的类型不具有子父类关系
//编译不通过
//list1 = list2;
/*
* 反证法
* 假设list1 = list2;
list1.add( 123);导致混入非String的数据。出错。
* */
show(list1);
show1(list2);
}
public void show1(List<String> list){
}
public void show(List<Object> list){
}补充:类A是类B的父类，A<G>是B<G>的父类
@Test
public void test2(){
AbstractList<String> list = null;
List<String> list1 = null;
ArrayList<String> list3 = null;
list1 = list3;
list = list3;
}通配符的使用
public void show1(List<String> list){
} public void show(List<Object> list){
}因为list<String> 与 list<Object> 不是子父类关系，所以要写两个方法，太麻烦了，通配符用来简化
通配符:?
类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是:G<?>
@Test
public void test3(){
List<Object> list1 = null;
List<String> list2 = null;
List<?> list = null;
list = list1;
list = list2;
print(list1);
print(list2);
}
public void print(List<?> list){
Iterator<?> iterator = list.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
System.out.println(obj);
}
}添加(写入)：对于List<?>就不能向其内部添加数据。(除了null)
获取(读取)：允许读取数据，读取的数据类型为Object。
有限制条件的通配符的使用
-
通配符指定 上限extends:使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
-
通配符指定 下限super:使用时指定的类型不能小于操作的类，即>=
举例：?extends Number>(无穷小，Number] <? super Number>[Number,无穷大)
<? extends Comparable> 只允许泛型为实现Comparable接口的实现类的引用调用
@Test
public void test4(){
List<? extends Person> list1 = null;
List<? super Person> list2 = null;
List<Student> list3 = new ArrayList<Student>();
List<Person> list4 = new ArrayList<Person>();
List<Object> list5 = new ArrayList<Object>();
list1 = list3;
list1 = list4;
// list1 = list5;
// list2 = list3;
list2 = list4;
list2 = list5;
//读取数据：
list1 = list3;
Person p = list1.get(0);
//编译不通过
//Student s = list1.get(0);
list2 = list4;
Object obj = list2.get(0);
编译不通过
// Person obj = list2.get(0);
//写入数据：
//编译不通过
// list1.add(new Student());
//编译通过
list2.add(new Person());
list2.add(new Student());
}
1099
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
