泛型
1. 泛型类:具有一个或多个类型变量的类,称之为泛型类!
class A<T> {
}
泛型方法:具有一个或多个类型变量的方法,称之为泛型方法!
class A<T> {
public T fun(T t1) {}
}
fun()方法不是泛型方法!它是泛型类中的一个方法!
public <T> T fun(T t1) {} --> 它是泛型方法
* 泛型方法与泛型类没什么关系,泛型方法不一定非要在泛型类中!
4. 泛型在类中或方法中的使用
* 泛型类中使用泛型:
> 成员类型
> 返回值和参数类型
> 局部变量的引用上
class A<T> {
private T bean;//泛型可在成员变量上使用
public T fun(T t) {}//泛型可以在类中的方法上(返回值和参数类型)使用!
public void fun2() {//泛型还可以在局部变量的引用类型上使用
T b = ...
new T();//不行的!
}
}
5.1 继承泛型类
* 子类不是泛型类:需要给父类传递类型常量
> 当给父类传递的类型常量为String时,那么在父类中所有T都会被String替换!
* 子类是泛型类:可以给父类传递类型常量,也可以传递类型变量
* 子类不是泛型类:需要给父类传递类型常量
> 当给父类传递的类型常量为String时,那么在父类中所有T都会被String替换!
子类是泛型类:可以给父类传递类型常量,也可以传递类型变量
package cn.itcast;
import org.junit.Test;
public class Demo1 {
@Test
public void fun1() {
AA3<Long> aa3= new AA3<Long>();
aa3.
}
}
class A<T> {
private T t;
public T fun1() {
return t;
}
public void fun2(T t) {
this.t = t;
}
}
class AA3<E> extends A<E> {
}
class AA1 extends A<Integer> {//父类中的T,都会被Integer 替换
}
class AA2 extends A<String> {//父类中的T,都会被String替换
}
例如虽然写成了泛型但是jvm 是不认识的
public class Demo2 {
@Test
public void fun1() {
Object[] objs = new Object[10];
List list = new ArrayList();
String[] strs = new String[10];
List<String> strList = new ArrayList<String>();
里面没有泛型
数组和集合的对比
@Test
public void fun1() {
//对比数组和集合
// 1 数组能实现的集合也能实现
Object[] objs = new Object[10];
List list = new ArrayList();
String[] strs = new String[10];
List<String> strList = new ArrayList<String>();
//2 数据能实现的但是集合不能实现
Object[] objArray = new String[10];
objArray[0] = new Integer(100);//虽然可以识别了,但是会抛出异常 ArrayStoreException
//集合败下阵来,由于泛型虚拟机是不认识的
/*
* List<Object> objList = new ArrayList<String>();//虚拟机会转变为
* List objList = new ArrayList() 所以objList.add(new Integer(100));
* 这个仍然能执行,那就和数组没有区别了,所以虚拟机从一开始
* List<Object> objList = new ArrayList<String>(); 这步就不让执行了
* 所以泛型引用和创建两端,给出的泛型变量必须相同!
*/
}
泛型通配符使用的场景
方法的形参!
这种写法是错误的,由于泛型引用和创建两端,给出的泛型变量必须相同!
所以这种方法就是很不好,只能是重载
如果想调用一个方法怎么办
通配符的使用限制
1 其中的?就是通配符
通配符只能出现在左边!即不能在new时使用通配符!!!
List<?> list = new ArrayList<String>(); // List<?> list = new ArrayList<?>();是错误的
2 通配符的含义
?它表示一个不确定的类型,它的值会在调用时确定下来
这种写法是错的,因为不知道是什么类型是不能直接往里面加字符串,万一人家是
if(t instanceof EventLevelAndEventNumber){
Object s = list.get(0); 只能是通过这种方式调用
public void fun3() {
List<Integer> intList = new ArrayList<Integer>();
print1(intList);
List<Long> longList = new ArrayList<Long>();
print1(longList);
}
/*
* 给通配符添加了限定:
* 只能传递Number或其子类型
* 子类通配符对通用性产生了影响,但使用形参更加灵活
*/
public void print1(List<? extends Number> list) {
/*
* 参数为泛型的方法还是不能使用
*/
// list.add(new Integer(100));
/*
* 返回值为泛型的方法可用了!
*/
Number number = list.get(0);
}
public void fun4() {
List<Integer> intList = new ArrayList<Integer>();
print2(intList);
List<Number> numberList = new ArrayList<Number>();
print2(numberList);
List<Object> objList = new ArrayList<Object>();
print2(objList);
}
/*
* 给通配符添加了限定
* 只能传递Integer类型,或其父类型
*/
public void print2(List<? super Integer> list) {
/*
* 参数为泛型的方法可以使用了
*/
list.add(new Integer(100));
/*
* 返回值为泛型的方法,还是不能使用Integer in = list.get(0); 不能使用
*/
Object obj = list.get(0);
}
2. 通配符的优点
使方法更加通用!
3. 通配符分类
无界通配:?
子类限定:? extends Object
父类限定:? super Integer
4. 通配符缺点
使变量使用上不再方便
无界:参数和返回值为泛型的方法,不能使用!
子类:参数为泛型的方法不能使用
父类:返回值为泛型的方法不能使用
5. 比较通配符
boolean addAll(Collection<E> c)
List<Number> numList = new ArrayList<Number>();
List<Integer> intList = new ArrayList<Integer>();
// 由于是List<Number> numList 调用的是addAll(Collection<E> c) 所以这个方法变为了addAll(Collection<Number> c)
numList.addAll(intList);//addAll(Collection<Number> c), 传递的是List<Integer> 编译不通过
boolean addAll(Collection<? extends E> c)
List<Number> numList = new ArrayList<Number>();
List<Integer> intList = new ArrayList<Integer>();
numList.addAll(intList);//addAll(Collection<? extends Number> c), 传递的是List<Integer> 编译通过了