泛型

最新推荐文章于 2022-05-29 18:01:32 发布

磊哥的小迷妹

最新推荐文章于 2022-05-29 18:01:32 发布

阅读量128

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/qq_48496502/article/details/120132941

版权

笔记专栏收录该内容

112 篇文章 2 订阅

订阅专栏

🌺泛型📄

😜什么是泛型？为什么要使用泛型？

什么是泛型？为什么要使用泛型？

什么是泛型？
是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，而这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。
.
注意： 一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型

若是没有使用泛型，弊端：

public void Test(){
	List arrayList = new ArrayList();
	arrayList.add("aaaa");
	//问题一：类型不安全。
	//集合没有做任何限定，任何类型都可以给其中存放
	arrayList.add(100);

	for(int i = 0; i< arrayList.size();i++){
		//问题二：强转时，可能出现ClassCastException
	    String item = (String)arrayList.get(i);
	    System.out.println("泛型测试","item = " + item);
	}
}

报错：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

为了解决类似这样的问题（在编译阶段就可以解决），在jdk1.5后，泛型应运而生

将第一行声明初始化 ArrayList 的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题

ArrayList<String> arrayList = new ArrayList<>();   //注意，前面填了<String>，后面的<>可以为空
arrayList.add("helloWorld");
arrayList.add("taiziyenezha");
arrayList.add(88);// 在编译阶段，编译器就会报错

😝
泛型的好处：
避免了类型强转的麻烦，它提供了编译期的类型安全

😒泛型的使用举例

1、集合中使用泛型

第一个情况：单列数据 Collection
以ArrayList为例

public void Test(){
	List arrayList<Integer> = new ArrayList<>();
	arrayList.add(55);
	arrayList.add(21);
	arrayList.add(98);
	arrayList.add(60);
	//编译时们就会进行类型检查，保证数据安全
	//arrayList.add("aaa");

	//方式一：
	for(Integer i : arrayList){
		//可以避免强转操作
		int stuScore = i;
	    System.out.println(stuScore);
	}
	
	//方式二：
	Iterator<Integer> iterator = arrayList.iterator();
	while(iterator.hasNext()){
		int stuScore = iterator.next();
		System.out.println(stuScore);
	}
}

第二个情况：双列数据 Map
以HashMap为例

public void Test(){
	Map<String,Integer> map = new HashMap<String,Integer>();
	map.put("AA",11);
	map.put("CC",11);
	map.put("BB",11);
	map.put("FF",11);
	//map.put("XX","AA");
	
	//遍历
	//注意此处的Entry是Map的内部类，所以用Map.Entry
	//若是导入了Map的包，可以直接用Entry
	Set<Map.Entry<String,Integer>> entry = map.entrySet();
	Iterator<Map.Entry<String,Integer>> iterator = entry.iterator();
	while(iterator.hasNext()){
		Map.Entry<String,Integer> entry = iterator.next();
		String key = entry.getKey();
		Integer value = entry.getValue();
		System.out.println(key+"====>"+value);
	}
}

总结：

集合接口或集合类在 JDK 5 时都修改为带泛型的结构
在实例化集合类时，可以指明具体的泛型类型
指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（方法、构造器、属性等）使用到类的泛型的位置，指定为实例化的泛型类型
比如：add ( E e ) ----> 实例化后：add ( Integer e )
泛型的类型是类，不能是基本数据类型，需要用到基本数据类型的位置，拿包装类替换
如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object
泛型类，在实例化对象的时候指明（泛型方法，在方法被调用的时候指明）

2、比较器中使用泛型

有了泛型规定数据类型之后就可以不需要强转

集合的迭代器里面加上泛型，也可以直接输出该类型的数据

第一种情况：实现Comparable ，重写 CompareTo 方法

public class Emploee implements Comparable<Emploee>{
	......
	@Override
	public int CompareTo(Emploee e){
		//有了泛型来规定数据类型之后就可以不需要强转
		return this.name.CompareTo(e.name);
	}
}
class T{
	public void Test1(){
		TreeSet<Emploee> set = new TreeSet<Emploee>();
		......
		Iterator<Emploee> iterator = set.iterator();
		while(iterator.hasNext()){
			Emploee e = iterator.next();
			System.out.println(e);
		}
	}
}

第二种情况：直接实例化 Comparator 工具类对象，重写 Compare 方法

class T{
	public void Test1(){
		TreeSet<Emploee> set = new TreeSet<>(new Comparator<Emploee>(){
			@Override
			public int Compare(Emploee e1,Emploee e2){
				//有了泛型规定数据类型之后就可以不需要强转
				return this.name.CompareTo(e.name);
			}
		});
		......
		Iterator<Emploee> iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
}

3、泛型使用场景

在数据库中有多个表，要对这些不同的表进行操作

//创建一个类，来操作这些数据
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> getList(int index){
		return null;
	}
	
	//泛型方法
	//举例：获取表中多少条记录？获取员工入职时间？
	public <E> E getValue(){
		return null;
	}
}

//此类对应数据库中的Customer表
public class Customer{}
class CustomerDAO extends DAO<Customer>{}   //只可以操作一个表的数据

//此类对应数据库中的Student表
public class Student{}
class StudentDAO extends DAO<Student>{}   //只可以操作一个表的数据

public class Test{
	@Test
	public void Test1(){
		CustomerDAO dao1 = new CustomerDAO();
		dao1.add(new Customer());
		List<Customer> list = dao1.getList(10);
		
		StudentDAO dao2 = new StudentDAO();
		dao2.add(new Student());
		Student student = dao2.getIndex(1);
	}
}

😓自定义泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种集合框架容器类，如：List、Set、Map。

定义格式：

修饰符 class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
	private 泛型标识/*（成员变量类型）*/  var; 
	.....
}

自定义泛型类举例：

/**
 * @param <T> 这里解释下<T>中的T:
 *           此处的T可以随便写为任意标识，常见的有T、E等形式的参数表示泛型
 *           泛型在定义的时候不具体，使用的时候才变得具体。
 *           在使用的时候确定泛型的具体数据类型。即在创建对象的时候确定泛型。
 */
public class Order<T> {
	int age;
    //key这个成员变量的类型为T，T的类型由外部指定
    private T key;
    
    //注意无参构造器没有泛型标识符
    public Order(){};
    
    //泛型构造方法形参t的类型也为T，T的类型由外部指定
    public Order(int age,T key) {
    	this.age= age;
        this.key = key;
    }

    //泛型方法getKey的返回值类型为T，T的类型由外部指定
    public T getKey() {
        return t;
    }
    
    public void setKey(T key){
    	this.key = key;
    }
}

关于自定义泛型类、泛型接口：

如果定义了泛型类型，实例化没有指明类的泛型，则认为此泛型类型为Object类型

public void Test1(){
	//如果定义了泛型类型，实例化没有指明类的泛型，则认为此泛型类型为Object类型
	//要求：定义的类是带泛型的，建议实例化的时候指明类的泛型
	Order order1 = new Order();
	order.setKey(123);
	order.setKey("AA");
	
	//建议：实例化时指明类的泛型
	//传入的实参类型需与泛型的类型参数类型相同
	Order<String> order2 = new Order<String>(18,"AA");
	order.setKey("BB");
}

涉及到继承的两种情况：

第一种：指明父类中泛型的具体类

//SubOrder：子类不是泛型类
public class SubOrder extends Order<Integer>{
}
class Test{
	@Test
	public void Test1(){
		SubOrder sub1 = new SubOrder();
		//由于子类在继承带泛型的父类时，指明了泛型类型，则实例化子类对象时，不再需要指明泛型
		sub1.setKey(123);
	}
}

第二种：未指明父类中泛型的具体类，此时的子类也需要带上泛型的标识符，也是一个泛型类

//SubOrder<T>：子类也是泛型类
public class SubOrder<T> extends Order<T>{
}
class Test{
	@Test
	public void Test1(){
		SubOrder<String> sub1 = new SubOrder<String>();
		sub1.setKey("AA");
	}
}

注意：
- 泛型只在编译阶段有效，泛型信息不会进入到运行时阶段
- 泛型的类型参数只能是类类型（包括自定义类），不可以是基本数据类型
- 若没有指定泛型类型，则默认是Object类型

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    System.out.println("泛型测试","类型相同");
}

执行结果：泛型测试: 类型相同

系统在在编译之后程序会采取 “ 去泛型化 ” 的措施

1、自定义泛型类、泛型接口的注意点

泛型类可能有多个参数，此时应该将多个参数一起放在尖括号内，比如：<E1,E2,E3>
泛型类的构造器如下：public GenereicClass(){};
而这样是错误的：public GenereicClass < E > (){};
实例化之后，操作泛型位置的结构必须与指定的泛型类型一致
泛型不同的引用不可以相互赋值
（尽管在编译时ArrayList<String> 、ArrayList<Integer>是两种类型，但是运行时只有一个ArrayList被加载到JVM中）
泛型如果不指定，将会被擦除，泛型对应的类型均按照Object处理，但不等价与Object。
（泛型要么都用，要么都不用）
如果泛型结构是一个接口或抽象类，则不可以实例化
JDK 7 及以后，反省的简单化操作：
ArrayList<Integer> f = new ArrayList<>();
泛型的制定中不能使用基本数据类型，可以使用包装类替换
在泛型类、泛型接口中，在静态方法中不能使用类的泛型
因为类的泛型的调用实在实例化的时候指明
异常类不能是泛型的
在try-catch结构中也不可以抓 catch 泛型类型异常
创建数组时候，不可以new T[]，可以是T[] e = (T[])new Object[capacity];
父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型
子类不保留父类泛型：没有类型、具体类型
子类保留父类的泛型：全部保留、部分不留

泛型不同的引用不可以相互赋值

@Test
public void Test(){
	ArrayList<String> a1 = new ArrayList<String>();
	ArrayList<Integer> a2 = new ArrayList<Integer>();
	//泛型不同的引用不可以相互赋值
	//a1 = a2;
	//a2 = a1;
}

父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型

分以下几种情况

子类不保留父类泛型：没有类型、具体类型
子类保留父类的泛型：全部保留、部分不留

class son1<A, B> extends Father{}
class son1 extends Father{}
	//子类不保留父类泛型：没有类型，擦除
	//等价于class son extends Father<Object,Object>

class son2<A, B> extends Father<Integer,String>{}
class son2 extends Father<Integer,String>{}
	//子类不保留父类泛型：具体类型

class son3<A, B, T1, T2> extends Father<T1,T2>{}
class son3<T1,T2> extends Father<T1,T2>{}
	//子类保留父类的泛型：全部保留

class son3<A, B, T1> extends Father<T1,T2>{}
class son3<T1> extends Father<T1,T2>{}
	//子类保留父类的泛型：部分不留

😲自定义泛型方法

以下几种方法都不是泛型方法

都是在泛型类中，仅仅是用到了泛型类的泛型

public class Order<T> {
	int age;
    private T key;
    public Order(int age,T key) {
    	this.age= age;
        this.key = key;
    }
    public T getKey() {
        return t;
    }
    public void setKey(T key){
    	this.key = key;
    }
}

泛型方法：

在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系

换句话说，泛型方法所属的类是不是泛型都没有关系

泛型方法在调用时，指明泛型参数类型
泛型类在实例化时，指明泛型参数类型

泛型方法有个泛型标志<E>放在返回值之前，没有实际意义，仅仅是一个标志

public class Order<T> {
	private T key;
	public Order(){}
	public <E> List<E> copyA(E[] arr){
		ArrayList<E> List = new ArrayList<>();
		for(E e : arr){
			list.add(e);
		}
		return list
	}
}
class Test{
	//测试泛型方法
	@Test
	public void Test(){
		Order<String> order = new Order<>();
		Integer[] arr = new Integer[]{1,2,3,4};
		
		//泛型方法在调用时，指明泛型参数类型
		List<Integer> list = order.copyA(arr);
		System.out.println(list);
	}
}

泛型方法所属的类是不是泛型都没有关系，如下：

public class SubOrder extends Order<Integer>{
	public <E> List<E> copyB(E[] arr){
		ArrayList<E> List = new ArrayList<>();
		for(E e : arr){
			list.add(e);
		}
		return list
	}
}

泛型方法可以声明为静态方法

原因：

泛型参数是在调用方法是确定的，并非在实例化类时确定

	//泛型方法可以是静态方法
	//因为泛型方法是在调用时候知名反省
	public static <E> List<E> copyA(E[] arr){
		ArrayList<E> List = new ArrayList<>();
		for(E e : arr){
			list.add(e);
		}
		return list
	}

😜泛型在继承上的体现

1、泛型的子父类关系

刚刚提到，在编译时ArrayList<String> 、ArrayList<Integer>、ArrayList<Object>是三种类型，三者不可以相互赋值

	String a1 = null;
	Object a2 = null;
	//可以赋值，因为是子父类关系
	//子类可以赋值给父类
	a2 = a1;

	ArrayList<Object> a1 = new ArrayList<Object>();
	ArrayList<Integer> a2 = new ArrayList<Integer>();
	//不可以相互赋值，二者没有关系
	//a1 = a2;
	//a2 = a1;

类 A 是类 B 的父类，G< A > 和 G< B > 二者不具备子父类关系，二者是并列关系

但是，A< G > 是 B< G > 的父类

AbstractList<String> list1 = null;  //父类  
List<String> list2 = null;       //接口
ArrayList<String> list3 = null;     //子类、实现类

list1 = list3;
list2 = list3;

2、通配符 ?

类 A 是类 B 的父类，G< A > 和 G< B > 二者没有关系，但是有共同父类 G< ? >

@Test
public void Test(){
	List<Object> a1 = null;
	List<Integer> a2 = null;
	List<?> a3 = null;
	
	//可以直接赋值
	a3 = a1;
	a3 = a2;
	
	//编译通过，但是运行会报空指针异常，因为是null
	//体会通配符的父类地位
	print(a1);
	print(a2);
}
	public void print(List<?> list){
		Iterator<?> iterator = list,iterator();
		while(iterator.hasNext()){
			Object obj = iterator.next();
			System.out.println(obj);
		}
	}

读取与写入

写入：对于 List<?> 不可以向其内部添加数据，但是可以添加null

读取：允许读取数据，读取的数据类型为 Object

	//普通泛型类实例化
	List<Sting> list = new ArrayList<>();
	list.add("AA");
	list.add("BB");
	list.add("CC");
	
	//对于 List<?> 不可以向其内部添加数据，但是可以添加null
	List<?> a3 = null;
	a3 = list;
	//a3.add("DD");
	a3.add(null);
	
	//读取：允许读取数据，读取的数据类型微Object
	Object o = list.get(0);
	System.out.println(o)    // AA

3、有限制条件的通配符

<? extends Person> ：≤ Person，即( -∞ , Person ]
Person类与其子类
<? super Person>： ≥ Person，即 [ Person , +∞ )
Person类与其父类

此处Student类是Person类的子类

public void Test(){
	List<? extends Person> list1 = null;
	List<? super Person> list2 = null;
	
	List<Object> list3 = null;
	List<Person> list4 = null;
	List<Student> list5 = null;
	
	//第一种情况：<? extends Person> Person类与其子类
	//list1 = list3;    编译不通过
	list1 = list4;
	list1 = list5;
	
	//第二种情况：<? super Person> Person类与其父类
	list2 = list3;
	list2 = list4;
	//list2 = list5;    编译不通过
}

G<? super Person>可以作为G<Object>和G<Person>的父类

G<? extends Person>可以作为G<Student>和G<Person>的父类

读取与写入

public void Test(){
	List<? extends Person> list1 = null;
	List<? super Person> list2 = null;
	
	List<Object> list3 = new ArrayList<Object>();
	List<Person> list4 = new ArrayList<Person>();
	List<Student> list5 = new ArrayList<Student>();

	//读取数据：	
	list1 = list5;
	Person p = list1.get(0);
	//Student s = list.get(0);    //编译不通过
	
	list2 = list4;
	Object o = list2.get(0);
	//Person p = list2.get(0);    //编译不通过
	
	//写入数据：
	list2.add(new Person());
	list2.add(new Student());
	
	//list1.add(new Student());    //编译不通过
}

😜综合练习

需求：

定义个泛型类 DAO< T >
定义一个 Map 成员变量， Map 的键微String类型，值为 T 类型
创建以下方法：
public void save(String id, T entity)：保存 T 类型的对象到 Map 成员变量中
public T get(String id)：从 map 中获取 id 对应的对象
public void update(String id , T entity)：替换 map 中键为 id 对应的值，替换为 entity
public List< T > list()：返回 map 中存放的所有 T 对象，即所有键值对中的值
public void delete(String id)：删除指定键为 id 的对象

定义一个 User 类
该类包含：private int id、age，private String name

定义一个测试类
创建 DAO 类的对象，分别调用其 save、get、update、list、delete 方法来操作 User 对象，使用 Junit 单元测试类进行测试

public class DAO<T>{

	//注意这里要先初始化
	private Map<String, T> map = new HashMap<String, T>();
	
	//保存 T 类型的对象到 Map 成员变量中
	public void save(String id, T entity){
		map.put(id, entity);
	}
	
	//从 map 中获取 id 对应的对象
	public T get(String id){
		return map.get(id);
	}
	
	//替换 map 中键为 id 对应的值，替换为 entity
	public void update(String id , T entity){
		if(map.containsKey(id)){
			map.put(id, entity);
		}
	}
	
	//返回 map 中存放的所有 T 对象，即所有键值对中的值
	public List<T> list(){
		Collection<T> values = map.values();

		//错误写法，因为二者没有子父类关系，无法强转
		//return (List<T>)values;
		
		ArrayList<T> arr = new ArrayList<T>();
		for(T t : values){
			arr.add(t);
		}
		return arr;
	}
	
	//删除指定键为 id 的对象
	public void delete(String id){
		return map.remove(id);
	}
}

public class User{
	private int id;
	private int age;
	private String name;
	//重写equals()、hashCode()、toString()
	......
}

public class DAOTest{
	public static void main(String[] args){
		DAO<User> dao = new DAO<>();
		
		dao.save(111, new User(0, 00, "周杰伦"));
		dao.save(222, new User(1, 11, "昆凌"));
	}
}

😜小结

集合接口或集合类在 JDK 5 时都修改为带泛型的结构
泛型类可能有多个参数，此时应该将多个参数一起放在尖括号内，比如：<E1,E2,E3>
有了泛型规定数据类型之后，就可以不需要强转
① 泛型类，在实例化对象的时候指明
② 泛型方法，在方法被调用的时候指明
在泛型类、泛型接口中，在静态方法中不能使用类的泛型
因为类的泛型是在实例化的时候指明
但是！泛型方法可以定义为静态方法
因为泛型方法是在方法调用的时候指明
泛型类的构造器如下：public GenereicClass(){};
而这样是错误的：public GenereicClass < E > (){};
实例化泛型类之后，操作泛型位置的结构必须与指定的泛型类型一致
且内部结构（方法、构造器、属性等）使用到类的泛型的位置，指定为实例化的泛型类型
比如：add ( E e ) ----> 实例化后：add ( Integer e )
泛型不同的引用不可以相互赋值
（尽管在编译时ArrayList<String> 、ArrayList<Integer>是两种类型，但是运行时只有一个ArrayList被加载到JVM中）
泛型如果不指定，将会被擦除，泛型对应的类型均按照java.lang.Object处理，但不等价与Object。
（泛型要么都用，要么都不用）
JDK 7 及以后，泛型的简单化操作：
ArrayList<Integer> f = new ArrayList<>();
泛型的指定中不能使用基本数据类型，可以使用包装类替换
异常类不能是泛型的
在try-catch结构中也不可以抓 catch 泛型类型异常
创建数组时候，不可以new T[]，可以是T[] e = (T[])new Object[capacity];
父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型
子类不保留父类泛型：没有类型、具体类型
子类保留父类的泛型：全部保留、部分不留

类 A 是类 B 的父类
A< G > 是 B< G > 的父类
G< A > 和 G< B > 二者没有关系，但是有共同父类 G< ? >
对于 List<?> 不可以向其内部添加数据，但是可以添加 null
允许读取数据，读取的数据类型为 Object
<? extends Person> ：≤ Person，即( -∞ , Person ]
Person类与其子类
<? super Person>： ≥ Person，即 [ Person , +∞ )
Person类与其父类

磊哥的小迷妹

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
泛型

????目录????????概述????泛型的使用????泛型类????泛型接口小结????概述什么是泛型？为什么要使用泛型？什么是泛型？是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，而这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。.注意：一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型若是没有使用泛型，弊端：List arra
复制链接

扫一扫