Java学习14-泛型
文章目录
1.泛型概述
泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
2. 在集合中使用泛型
ArrayList<Integer> list = new ArrayList<>();//类型推断
list.add(78);
list.add(88);
list.add(77);
list.add(66);
//遍历方式一：
//for(Integer i : list){
//不需要强转
//System.out.println(i);
//}
//遍历方式二：
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("Tom1",34);
map.put("Tom2",44);
map.put("Tom3",33);
map.put("Tom4",32);
//添加失败
//map.put(33, "Tom");
Set<Entry<String,Integer>> entrySet = map.entrySet();//泛型的嵌套
Iterator<Entry<String,Integer>> iterator = entrySet.iterator();
while(iterator.hasNext()){
Entry<String,Integer> entry = iterator.next();
System.out.println(entry.getKey() + "--->" + entry.getValue());
}
3. 自定义泛型结构
3.1 自定义泛型类、自定义泛型接口
- 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>
- 泛型类的构造器如下：
public GenericClass(){}。
而下面是错误的：
public GenericClass(){} - 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
- 泛型不同的引用不能相互赋值。
尽管在编译时ArrayList和Arra yList是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。 - 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。 经验：泛型要使用一路都用。要不用，一路都不要用。
- 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
- 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
- 在静态方法中不能使用类的泛型。泛型方法可以是静态的。
- 异常类不能声明为泛型类
- 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
- 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 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<Object,Object>{
}
// 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.2 自定义泛型方法
- 方法也可以被泛型化，不管此时定义在其中的类是不是泛型类。 在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型
- 泛型方法的格式：
[ 访问权限] < 泛型> 返回类型 方法名([ 泛型标识 参数名称]) 抛出的异常 - 泛型方法声明泛型时也可以指定上限
- 泛型方法可以声明为static。原因：泛型参数是在调用方法时确定的，并非在实例化类时确定的。
简单例子：
【DAO.class】
import java.util.List;
/**
* DAO：操作数据库的一些通用的操作
*/
public class DAO <T>{
//添加一条记录
public void add(T t){
}
//删除一条记录
public boolean remove(int index){
return false;
}
//修改一条记录
public void update(int index,T t){
}
//查询一条记录
public T getIndex(int index){
return null;
}
//查询多条记录
public List<T> getFoelist(int index){
return null;
}
//泛型方法
public <E> E getValue(){
return null;
}
}
【Customer.class】
/**
* 此类对应数据库中的customers表
*/
public class Customer {
}
【CustomerDAO.class】
public class CustomerDAO extends DAO<Customer> {
}
【DAOTest.class】
import java.util.List;
public class DAOTest {
public void test1(){
CustomerDAO customerDAO = new CustomerDAO();
customerDAO.add(new Customer());
List<Customer> list = customerDAO.getFoelist(10);
}
}
3.3 泛型在继承上的体现
//类A是类B的父类，G<A> 和 G<B> 二者不具备子父类关系，二者是并列关系
List<Object> list1 = null;
List<String> list2 = null;
list1 = list2;//编译不通过，String是Object的子类，但是List<String >并不是List<Object>
的子类。
3.4通配符的使用
- 使用类型 通配符：？
比如：List<?> ，Map<?,?>
List<?>是List<String>、List<Object>等各种泛型List的父类。
- 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。
- 将任意元素加入到其中不是类型安全的：
Collection<?> c = new ArrayList<String>();
c.add(new Object()); // 编译时错误
- 因为我们不知道c的元素类型，我们不能向其中添加对象。add方法有类型参数E作为集
合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知
道那是什么类型，所以我们无法传任何东西进去。 - 唯一 的例外的是null ，它是所有类型的成员。
- 另一方面，我们可以调用get() 方法并使用其返回值。返回值是一个未知的类型，但是我们知道，它总是一个 个Object。
public class GenericTest2 {
public static void main(String[] args) {
GenericTest2 genericTest2 = new GenericTest2();
genericTest2.test1();
}
public void test1() {
List<Object> list1 = null;
List<String> list2 = null;
List<?> list = null;
//List<?> 是 List<Object> 和 List<String>的父类
list = list1;
list = list2;
List<String> list3 = new ArrayList<>();
list3.add("AA");
list3.add("BB");
list3.add("CC");
list = list3;
print(list3);
//除了添加null以外，其余的不能添加
//list.add("DD"); 错误
list.add(null);
//获取list的元素:允许读取数据，读取的数据类型为Object
Object o = list.get(0);
System.out.println(o);//AA
}
public void print(List<?> list) {
Iterator<?> iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
}
}
【注意】：
- 不能用在泛型方法声明上
//注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
public static <?> void test(ArrayList<?> list){
}
- 不能用在泛型类的声明上
//注意点2：编译错误：不能用在泛型类的声明上
class GenericTypeClass<?>{
}
- 不能用在创建对象上
//注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
ArrayList<?> list2 = new ArrayList<?>();
//但是下面的写法是正确的
ArrayList<?> list2 = new ArrayList<>();
有限制的通配符：
- 通配符指定上限：
上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<= - 通配符指定下限：
下限super：使用时指定的类型不能小于操作的类，即>=
举例：
- <? extends Number> ( 无穷小 , Number] 只允许泛型为Number及Number子类的引用调用
- <? super Number> [Number , 无穷大) 只允许泛型为Number及Number父类的引用调用
- <? extends Comparable> 只允许泛型为实现Comparable接口的实现类的引用调用