本文详细介绍了Java中的泛型概念，包括为什么需要泛型、在集合中使用泛型的示例、自定义泛型类和方法的注意事项、泛型在继承上的体现以及通配符的使用。通过具体的代码示例，展示了泛型如何提高代码的安全性和可读性，以及在实际开发中的应用。
目录
01 为什么要有泛型
泛型：标签
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>，List<E>，ArrayList<E>这个E就是类型参数，即泛型。
1.1 泛型的概念
所谓 泛型 就是允许在定义类 、 接口 时 通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型 。 这个类型 参数 将 在使用时 （例如继承或实现这个接口 用这个类型声明变量 、 创建对象时）确定即传入实际的类型参数 也称为类型实参 。
从JDK1.5以后，Java引入了“参数化类型（Parameterizedtype）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List<String>，这表明该List只能保存字符串类型的对象。
JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。
1.1.1 为什么要有泛型
Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。
集合中使用泛型之前
public class Generic {
//在集合中使用泛型之前
@Test
public void test(){
ArrayList list = new ArrayList();
// 存放学生成绩
list.add(78);
list.add(85);
list.add(96);
list.add(82);
list.add(90);
// 问题一：类型不安全，会导致后续出问题
list.add("Tom");
for (Object score : list) {
// 问题二：强转时可能出现类型转换异常（Tom）
int stuScore = (Integer) score; //
System.out.println(score);
}
}02 在集合中使用泛型
2.1 在List中使用泛型
@Test
public void test1(){
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(78); //这里只会让添加数值类型
list.add(85);
list.add(96);
list.add(82);
list.add(90);
//如果增添其他类型，在编译时会进行类型检查
// list.add("Tom");
// 遍历操作一
for (Integer score : list) {
int stuSco = score;
System.out.println(score);
}
// 遍历操作二
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next()); //next()也会返回泛型
}
}注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
2.2 在Map中使用泛型
@Test
public void Test2(){
HashMap<String,Integer> map = new HashMap<String,Integer>();
map.put("Tom",18); //强类型要求
map.put("Jerry",20);
map.put("Eric",20);
// Entry是Map接口下的方法，泛型的嵌套
Set<Map.Entry<String,Integer>> entry = map.entrySet();
//遍历Map
Iterator<Map.Entry<String,Integer>> iterator = entry.iterator();
while(iterator.hasNext()){
Map.Entry<String,Integer> e = iterator.next();
System.out.println(e.getKey() + "-------" + e.getValue());
}
}
03 自定义泛型结构
3.1 自定义泛型类举例
order类
/*
如何自定义泛型结构： 泛型类，泛型接口，泛型方法（Oder类）
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) {
OrderT = orderT;
}
//静态方法中不能使用泛型
public void show(){
System.out.println(OrderT);
}
//
public static void show1(){
// System.out.println(OrderT); //报错
}
// 泛型方法的定义：在方法中出现了泛型的结构，泛型参数与类的泛型没有任何关系
// 泛型方法所属的类是不是泛型类都没有关系
// 泛型方法可以设置为静态的，原因：泛型参数是在调用方法时确定的，并非实例化类时确定
public static <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
// 遍历
for(E e:arr){
list.add(e);
}
return list;
}
}subOrder类
public class SubOrder extends Order<Integer>{ //继承一个Integer类型的泛型，不是一个泛型类
}SubOrder1类
public class SubOrder1<T> extends Order<T>{ //仍然是泛型类
}
GenericTest类
public class GenericTest {
@Test
public void test(){
// 如果定义了泛型类，实例化时没有指明类的泛型，则认为此泛型类型为Object类型
Order oder = new Order<>();
oder.setOrderT(123);
oder.setOrderT("ABC");
//建议实例化时指明泛型
Order<String> order1 = new Order<String>("orderaa",1001,"order:AA" );// orderT String类型
order1.setOrderT("AA"); // 重新赋值只有String类型
}
@Test
public void test1(){
SubOrder sub1 = new SubOrder();
// 由于父类指明了泛型类型，实例化其子类时，不再需要进行泛型声明，且只能时Integer类型
sub1.setOrderT(1122);
SubOrder1<String> sub2 = new SubOrder1<>();
sub2.setOrderT("Oder2");
}
}3.2 自定义泛型类的注意点
3.2.1 泛型的声明
3.2.2 泛型的实例化
3.2.3 注意点
3.2.4 代码演示
OrderTest类
/**
* 自定义泛型类
*/
public class OrderTest<T> {
String orderName;
int orderId;
//类的内部结构就可以使用类的泛型
T orderT;
public OrderTest(){
//编译不通过
// T[] arr = new T[10];
//编译通过
T[] arr = (T[]) new Object[10];
};
public OrderTest(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 static void show(T orderT){
// System.out.println(orderT);
// }
public void show(){
//编译不通过
// try{
//
//
// }catch(T t){
//
// }
}
}
不同类型泛型之间不能相互赋值
@Test
public void test2(){
ArrayList<String> list1 = null;
ArrayList<Integer> list2 = null;
// list1 = list2 不能相互赋值
Order o1 = null;
Order o2 = null;
o1 = o2; // 没有泛型声明可以赋值
}3.3 继承中使用泛型
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> {}
3.4 自定义泛型方法
-
方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
-
[访问权限] <泛型> 返回类型 方法名([泛型标识参数名称]) 抛出的异常 如：public static <E> List<E> copyFromArrayToList(E[] arr) throws Exception{ }代码演示
OrderTest类
import java.util.ArrayList;
import java.util.List;
/**
* 自定义泛型类
*/
public class OrderTest<T> {
/**
* 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
* 换句话说，泛型方法所属的类是不是泛型类都没有关系。
* 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
*/
public static <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
测试
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
public class GenericTest1 {
//测试泛型方法
@Test
public void test4(){
OrderTest<String> order = new OrderTest<>();
Integer[] arr = new Integer[]{1,2,3,4};
//泛型方法在调用时，指明泛型参数的类型。
List<Integer> list = order.copyFromArrayToList(arr);
System.out.println(list);
}
}
04 泛型在继承上的体现
1. 泛型在继承方面的体现
* 虽然类A 是 类B 的子类， 但 list<A> 和 list<B>不具备子父类关系，就是两个并列的结构
* 补充：类A是 类B的子类， A<G> 和 B<G>public class GenericTest {
@Test
public void test(){
Object obj = null;
String str = null;
obj = str;
// 多态展示
Object[] arr1 = null;
String[] arr2 = null;
arr1 = arr2;
List<Object> list1 = null;
List<String> list2 = null;
// list1 和list2 不具有子父类关系，编译不通过
//list1 = list2; 报错
}
@Test
//补充：类A是 类B的子类， A<G> 和 B<G> 具有子父类关系
public void test1(){
AbstractList<String> list1 = null;
ArrayList<String> list2 = null;
list1 = list2; //可以赋值
}05 通配符的使用
通配符的使用: ? G<A> 和 G<B> 没有子父类关系， 二者共同的父类是 G<?>
另一方面，我们可以调用get()方法并使用其返回值。返回值是一个未知的类型，但是我们知道，它总是一个Object。
@Test
public void test2(){
List<Object> list1 = null;
List<String> list2 = null;
List<?> list = null;
list = list1;
list = list2; //相当于list作为list1 2 的通用父类
print(list1);
print(list2);
//
List<String> list3 = new ArrayList<>();
list3.add("AA");
list3.add("AA");
list3.add("AA");
list = list3;
// 添加： 对于 list<?> ,不能向其内部添加数据，除了添加null之外
// list.add("DD") 会报错，使用通配符，不能添加对象
list.add(null);
// 读取: 赋值给Object
Object o = list.get(0);
}
public void print(List<?> list){ // 打印list
Iterator<?> iterator = list.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
System.out.println(obj);
}
}5.1 有限制条件的通配符
@Test
public void test4(){
List<? extends Person> list1 = null; //小于等于，extends指定上限
List<? super Person> list2 = null; //大于等于，super指定下限
List<Stundent> list3 = null;
List<Person> list4 = null;
List<Object> list5 = null;
list1 = list3;
list1 = list4;
// list1 = list5; extends 小于等于
// list2 = list3; super 大于等于
list2 = list4;
list2 = list5;
// 读取数据
//读取返回值必须包含所有的可能
list1 = list3;
Person p = list1.get(0);//不能写Student
list2 = list4;
Object obj = list2.get(0);
// 写入数据
// list1.add(new Stundent());不能添加，父类不能赋值给子类
list2.add(new Stundent()); //可以添加，子类可以赋值给父类
}06泛型应用举例
6.1 泛型嵌套
public static void main(String[] args) {
HashMap<String, ArrayList<Citizen>> map= new HashMap<String, ArrayList<Citizen>>();
ArrayList<Citizen> list= new ArrayList<Citizen>();
list.add(new Citizen("刘恺威"));
list.add(new Citizen("杨幂"));
list.add(new Citizen("小糯米"));
map.put("刘恺威", list);
Set<Entry<String, ArrayList<Citizen>>> entrySet= map.entrySet();
Iterator<Entry<String, ArrayList<Citizen>>> iterator= entrySet.iterator();
while(iterator.hasNext()) {
Entry<String, ArrayList<Citizen>> entry= iterator.next();
String key= entry.getKey();
ArrayList<Citizen> value= entry.getValue();
System.out.println("户主："+ key);
System.out.println("家庭成员："+ value);
}
}
6.2 实际案例
/*
题目中class Person 是一个泛型类，依据不同的信息类型需要构建不同的信息类
*/
interface info{ //定义一个信息接口，不同的信息实现这个接口
}
class Introduction implements info{
private String name;
private int age;
private boolean gender;
public Introduction() {
}
public Introduction(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isGender() {
return gender;
}
public void setGender(boolean gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Introduction{" +
"name='" + name + '\'' +
", age=" + age +
", gender=" + gender +
'}';
}
}
class Contact implements info{
private String tel;
private String mail;
public Contact(String tel, String mail) {
this.tel = tel;
this.mail = mail;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
public String getMail() {
return mail;
}
public void setMail(String mail) {
this.mail = mail;
}
@Override
public String toString() {
return "Contact{" +
"tel='" + tel + '\'' +
", mail='" + mail + '\'' +
'}';
}
}
class Person<T>{
private T info;
public Person(T info) {
this.info = info;
}
public T getInfo() {
return info;
}
public void setInfo(T info) {
this.info = info;
}
@Override
public String toString() {
return "Person{" +
"info=" + info +
'}';
}
}
public class GenericPerson {
public static void main(String[] args){
Person<Contact> p1 = new Person<Contact>(new Contact("13395667733","12344565@163.com"));
System.out.println(p1);
Person<Introduction> p2 = new Person<Introduction>(new Introduction("张三",17,true));
System.out.println(p2);
}
}练习二
User类
public class user {
private int id;
private int age;
private String name;
public user(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "user{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
user user = (user) o;
return id == user.id && age == user.age && name.equals(user.name);
}
@Override
public int hashCode() {
return Objects.hash(id, age, name);
}
}DAO类
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class DAO <T>{
private Map<String, T> map = new HashMap<String, T>();
public DAO(Map<String, T> map) {
this.map = map;
}
public DAO() {
}
public Map<String, T> getMap() {
return map;
}
public void setMap(Map<String, T> map) {
this.map = map;
}
public void save(String id, T entity){
map.put(id,entity);
}
public T get(String id){
T t = map.get(id);
return t;
}
public void update(String id, T entity){
if(map.containsKey(id)){ //这里要先判断是否存在，否则就是添加了一个id
map.put(id,entity);
}
}
public List<T> list(){
List<T> list = new ArrayList<T>();
//list = (List<T>) map.values(); //错误写法
for(T t : map.values()){ // 转换成list要这样写，遍历values
list.add(t);
}
return list;
}
public void delete(String id){
map.remove(id);
}
@Override
public String toString() {
return "DAO{" +
"map=" + map +
'}';
}
}Test
import org.testng.annotations.Test;
import java.util.List;
import java.util.Set;
public class DAOTest {
@Test
public void test(){
DAO<user> dao = new DAO<user>();
dao.save("1001",new user(1001,35,"张三"));
dao.save("1002",new user(1004,27,"李四"));
dao.save("1003",new user(1005,18,"王五"));
// 遍历map
Set<String> set = dao.getMap().keySet();
for(String s : set){
System.out.print(s + "\t");
System.out.println(dao.get(s));
}
System.out.println(dao.get("1001"));
dao.update("1001",new user(1002,25,"张三"));
dao.delete("1002");
System.out.println(" ");
List<user> list = dao.list();
list.forEach(System.out :: println);
}
}
扫一扫
2439
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
