Java——泛型设计

最新推荐文章于 2024-07-10 22:13:59 发布
最新推荐文章于 2024-07-10 22:13:59 发布
阅读量183 收藏 1
点赞数
文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40543015/article/details/132778557
版权

一、泛型简介

为集合提供编译时（静态）类型安全，并消除了大多数类型转换的需要

（由于泛型是在编译时起作用，所以在运行时动态生成的反射可以绕过泛型限制）

1、泛型的特点

  • 泛型可以将类型作为参数进行传递，即类型可以像参数一样实现参数化。

  • 在编译的时候检查类型安全。

  • 所有的强制转换都是自动和隐式的。

  • Java引入泛型是安全简单的，并能提高代码的重用。

2、泛型引入前

在没有泛型的时候，基于通用性的考虑，早期的集合类存储的都是Object类型，一个集合便可以存储任意类型的对象，因为所有对象都是Object的子类型

那么这样做会存在什么样的问题呢，我们先看一个不使用泛型的例子

image-20230715085003849

例如这个程序代码段里就有一个list集合，假设在这个集合里放的是整形对象，而我们很可能不小心把字符串对象放到里面，这时编译器却无法发现其中的错误，直到程序运行时才会发现错误，但为时已晚，这种情况甚至在应用系统已经部署之后才会发生。而利用泛型就可以提前发现这些错误

3、泛型引入后

在编译期就已经报错了，程序员可以提前解决这问题

image-20230715085211410

二、泛型类

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别称为泛型类、泛型接口和泛型方法。

1、什么是泛型类

泛型类就是一个具有多种类型变量的类，泛型类可以拥有一个类型，也可以拥有多个类型

[访问修饰符] class 类名<T,U,...> {
    T 泛型成员1 ;
    U 泛型成员2;
    ...
}

类型参数使用大写形式，且比较短，这是最常使用的

2、常用泛型标识符

Java泛型类中常用泛型通配符有：

通配符说明
T (type)表示具体的一个java类
K V (key value)分别代表java键值中的Key Value
E (element)一般在集合中使用，表示集合中的元素类型
？表示不确定的 java 类型，经常出现在集合类中

本质上这些个都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。比如上述代码中的 T ，我们可以换成 A-Z 之间的任何一个 字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些

3、示例
package com.woniuxy;
​
public class Test<T> {
    private T value;
    
​
    public Test(T value) {
        super();
        this.value = value;
    }
​
​
    public static void main(String[] args) {
        Test<String> t1 = new Test<String>("tom");
        System.out.println(t1.value);
        
        Test<Integer> t2 = new Test<Integer>(22);
        System.out.println(t2.value);
​
    }
​
}
4、示例

此时的Key即可以是整形还可以是字符串类型，也或以是其它类型

public class Student<K, V> {
    private K id;
    private V name;
​
    public Student(K id, V name) {
        super();
        this.id = id;
        this.name = name;
    }
​
    public static void main(String[] args) {
        Student<Integer, String> student = new Student<Integer, String>(1001, "tom");
        System.out.println(student.id);
        System.out.println(student.name);
        Student<String, String> student2 = new Student<String, String>("s1001", "tom");
        System.out.println(student2.id);
        System.out.println(student2.name);
    }
​
}
5、泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型

泛型方法的声明格式：

修饰符 返回类型 方法名(参数列表){ //方法体 }。例如：
public T/void/... hello([T t]){
    return t;
}

示例

package com.woniuxy;
​
public class Student<K, V> {
    private K id;
    private V name;
​
    public Student(K id, V name) {
        super();
        this.id = id;
        this.name = name;
    }
    
​
    public K getId() {
        return id;
    }
​
​
    public void setId(K id) {
        this.id = id;
    }
​
​
    public V getName() {
        return name;
    }
​
​
    public void setName(V name) {
        this.name = name;
    }
​
​
    public static void main(String[] args) {
        Student<Integer, String> student = new Student<Integer, String>(1001, "tom");
        student.setName("jerry");
        System.out.println(student.getName());      
    }
​
}

三、泛型接口

用于接口中，在接口名末尾对泛型进行声明；

关系型数据库是由表组成的，一张数据表一般保存一类信息，那么张数据表在Java中就对应一个简单Java类(vo类),而且我们会定义一个接口来规范操作这张数据表的实现类开发。

对于实体的操作的只有接口的名称以及每个方法的参数类型不一样，方法的名称以及形式都是一样的，如果有一百张数据表就意味着要定义一百个这样的接口。此时就出现了代码重复的现象，最好的做法是使用一个接口实现多张数据表的数据操作。要实现这样的操作需要使用泛型接口。之前每个接口只能操作一种类型的数据，现在使用泛型接口之后，把要操作的数据类型使用占位符标记，具体使用接口的时候再根据需求指定泛型的类型

1、定义泛型接口
package com.woniuxy.generate;
​
import java.util.List;
​
public interface IBaseDao<K, T> {
    /**
     * 查询全部
     * @return
     */
    public List<T> getAll();
    /**
     * 根据id查询 
     * @param k
     * @return
     */
    public T queryById(K k);
    /**
     * 添加
     * @param t
     * @return
     */
    public int add(T t);
    /**
     * 修改
     * @param t
     * @return
     */
    public int update(T t);
    /**
     * 删除
     * @param k
     * @return
     */
    public int delete(K k);
​
}
2、定义员工的实现类
package com.woniuxy.generate.impl;
​
import java.util.List;
​
import com.woniuxy.entity.Employee;
import com.woniuxy.generate.IBaseDao;
​
public class EmployDaoImpl implements IBaseDao<Integer, Employee> {
​
    @Override
    public List<Employee> getAll() {
        // TODO Auto-generated method stub
        return null;
    }
​
    @Override
    public Employee queryById(Integer k) {
        // TODO Auto-generated method stub
        return null;
    }
​
    @Override
    public int add(Employee t) {
        // TODO Auto-generated method stub
        return 0;
    }
​
    @Override
    public int update(Employee t) {
        // TODO Auto-generated method stub
        return 0;
    }
​
    @Override
    public int delete(Integer k) {
        // TODO Auto-generated method stub
        return 0;
    }   
​
}
​
3、定义部门的实现类
package com.woniuxy.generate.impl;
​
import java.util.List;
​
import com.woniuxy.entity.Dept;
import com.woniuxy.generate.IBaseDao;
​
public class DeptDaoImpl implements IBaseDao<Integer, Dept> {
​
    @Override
    public List<Dept> getAll() {
        // TODO Auto-generated method stub
        return null;
    }
​
    @Override
    public Dept queryById(Integer k) {
        // TODO Auto-generated method stub
        return null;
    }
​
    @Override
    public int add(Dept t) {
        // TODO Auto-generated method stub
        return 0;
    }
​
    @Override
    public int update(Dept t) {
        // TODO Auto-generated method stub
        return 0;
    }
​
    @Override
    public int delete(Integer k) {
        // TODO Auto-generated method stub
        return 0;
    }
    
​
}
​

四、泛型进阶（了解）

除了用 <T> 表示泛型外，还有 <?> 这种形式。<?> 被称作无限定的通配符

1、<?>无界通配符

T 是一个 确定的 类型，通常用于泛型类和泛型方法的定义。

？是一个 不确定 的类型，通常用于泛型方法的调用代码和形参，不能用于定义类和泛型方法

可以查看API,看到Class类中有大量的应用

static 类<?>forName(String className) 返回与给定字符串名称的类或接口相关联的 类对象。
static 类<?>forName(String name, boolean initialize, ClassLoader loader) 使用给定的类加载器返回与给定字符串名称的类或接口相关联的 类对象。

先看以下示例：

public class MainApp {
​
    public static void main(String[] args) {
        List<Integer> intlist = new ArrayList<Integer>();
        intlist.add(11);
        intlist.add(22);
        intlist.add(33);
        List<String> strlist = new ArrayList<String>();
        strlist.add("aa");
        strlist.add("bb");
        strlist.add("cc");
        printList(intlist);
​
    }
​
    private static void printList(List<Integer> list) {
        for (Integer integer : list) {
            System.out.println(integer);
        }
        
    }
​
}

此时，printList方法只能打印List<Integer>，那如果我们还想打印List<String> strlist,这时该怎么办？

这时我们就需要通过<?>通配符来实现

public class MainApp {
​
    public static void main(String[] args) {
        List<Integer> intlist = new ArrayList<Integer>();
        intlist.add(11);
        intlist.add(22);
        intlist.add(33);
        List<String> strList = new ArrayList<String>();
        strList.add("aa");
        strList.add("bb");
        strList.add("cc");
        printList(strList);
​
    }
   /**
     *  定义一个方法，接收所有的集合元素
     * @param  list
     */
    private static void printList(List<?> list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
        
    }
​
}
List<?>`是一个未知类型的`List`，不能向`List<?>`中添加元素，但可以把`List<String>`，`List<Integer>`赋值给`List<?>

很多人认为List<?>和List<Object >是一样的，其实这是不对的，<Object>表示任意类型，<?>表示未知类型，可以向List<Object>中添加元素，但是不能把List<String>赋值给List<Object> 参考

2、上界通配符 < ? extends E>

上界（上限）：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

<U> 类<? extends U>asSubclass(类<U> clazz) 类这个 类对象来表示由指定的类对象表示的类的子类。
<A extends Annotation>AgetAnnotation(类<A> annotationClass) 返回该元素的，如果这样的注释 ，否则返回null指定类型的注释

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：

  • 如果传入的类型不是 E 或者 E 的子类，编译不成功

  • 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用

package com.woniuxy.generate;
​
import java.util.ArrayList;
import java.util.List;
​
public class MainApp {
​
    public static void main(String[] args) {
        List<Apple> applelist = new ArrayList<Apple>();
        applelist.add(new Apple());
        applelist.add(new Apple());
        applelist.add(new Apple());
        List<String> strList = new ArrayList<String>();
        strList.add("aa");
        strList.add("bb");
        strList.add("cc");
        printList(applelist);
​
    }
   /**
     *  定义一个方法，可以接收Fruit,以及Fruit所有的子类的集合元素
     * @param  list
     */
    private static void printList(List<? extends Fruit> list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
        
    }
    
    class Fruit {
        public void eat() {
            System.out.println("eat fruit");
        }
​
        @Override
        public String toString() {
            return "Fruit []";
        }   
​
  }
    class Apple extends Fruit {
        private String name;
​
​
        @Override
        public String toString() {
            return "Apple []";
        }
    
​
    }
​
}
3、下界通配符 < ? super E>

下界: 用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object

在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。

类<? super T>getSuperclass() 返回 类表示此所表示的实体（类，接口，基本类型或void）的超类 类 。
package com.woniuxy.generate;
​
import java.util.ArrayList;
import java.util.List;
​
public class MainApp {
​
    public static void main(String[] args) {
        List<Fruit> applelist = new ArrayList<Fruit>();
        applelist.add(new Fruit());
        applelist.add(new Fruit());
        applelist.add(new Fruit());
        List<String> strList = new ArrayList<String>();
        strList.add("aa");
        strList.add("bb");
        strList.add("cc");
        printList(applelist);
​
    }
    /**
     *  定义一个方法，可以接收Apple,以及Apple所有的父类集合
     * @param list 
     */
    private static void printList(List<? super Apple> list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
        
    }
    
    class Fruit {
        public void eat() {
            System.out.println("eat fruit");
        }
​
        @Override
        public String toString() {
            return "Fruit []";
        }   
​
  }
    class Apple extends Fruit {
        private String name;
​
​
        @Override
        public String toString() {
            return "Apple []";
        }
    
​
    }
​
}
4、泛型擦除

Java语言的泛型实现方式是擦拭法（Type Erasure）。

所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

public class MainApp2 {
    public static void main(String[] args) throws Exception{
        //Java泛型只在编译阶段起作用，实际运行中不起作用
        List<String> strList = new ArrayList<>();       
        List<Integer> intList = new ArrayList<>();
        intList.add(11);
        intList.add(22);
        //intList.add("hello");
        System.out.println(strList.getClass());// 输出：class java.util.ArrayList
        System.out.println(intList.getClass());// 输出：class java.util.ArrayList
        System.out.println(strList.getClass() == intList.getClass());// 输出：true
        //通过java反射的方式可以绕过泛型，
        Class<? extends List> clazz = intList.getClass();
        Method method = clazz.getMethod("add", Object.class);
        method.invoke(intList, "hello");
        System.out.println(intList);
    }
​
}

如上述代码所示，最终系统返回结果是true，说明List<Integer> 和List<String>只是在编译期间有效果，当代码在实际运行时，会自动转化成class java.util.ArrayList

程序猿正式役
关注
Java 泛型设计（泛型简单定义、类型擦除）与泛型使用的局限性
一只青年痴呆
07-27 1137
从Java 5引入。泛型程序设计意味着编写的代码可以对多种不同类型的对象重用。 在Java中增加泛型类之前，泛型程序设计是用继承实现的。ArrayList类只维护一个 Object 引用的数组。 定义简单泛型类 public class Pair<T> { private T first; private T second; ... ... } 泛型方法 class ArrayArg { public static <T> T getM.
Java基础 —— 泛型（二）限制类型参数
能量老8的博客
03-03 983
List
java泛型设计_Java泛型设计
weixin_35225264的博客
02-16 278
Java中的泛型(genericity)设计实际上和C++中的模板设计是一种概念下面介绍java当中的几种泛型1、 泛型类和泛型接口①定义格式：只是在定义类或接口时，在类名或接口名后面加上即可 ②这里的类型参数的个数是任意的，根据实际需要进行设定类型参数的定义形式有三种：<1> 类型变量标示符<2> 类型变量标示符 extends 父类型<3> 类型变...
Java 中的泛型（超全详解）
最新发布
weixin_65752158的博客
07-10 7660
泛型的出现就是为了统一集合当中数据类型的尖括号 <> 中的 泛型标识被称作是类型参数，用于指代任何数据类型。T ：代表一般的任何类。E ：代表 Element 元素的意思，或者 Exception 异常的意思。K ：代表 Key 的意思。V ：代表 Value 的意思，通常与 K 一起配合使用。S ：代表 Subtype 的意思，文章后面部分会讲解示意。自己实现集合/*E: 表示不确定的类型,该类型在类名后面已经定义过了e: 形参的名字,变量名*/
Java泛型程序设计
知行流浪
08-17 1008
泛型的基本概念         泛型是java se1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。         java语言引入泛型的好处是安全简单。         在java se1.5之前，没有泛型的情况下，通过对类型Object的引用来实现参数的“任意化”，“任意化
【java核心技术】泛型设计
linbomm的博客
04-26 559
一、泛型类 代码示例： public class Generic <T>{ private T num; public T getNum() { return num; } public void setNum(T num) { this.num = num; } } public class GenericT...
Java泛型设计
Guitarf的博客
04-23 280
Java泛型设计 为什么要去设计泛型？ 为了可以编写被很多不同类型对象所重用的代码 泛型是如何定义？ 1. 泛型类： class ClassName T是一个类型变量，可以是任意的类型，也可以有多个类型比变量。 类型变量使用大写形式，使用E表示集合的元素类型，K和V分别表示关键字和值得类型，是一个Map关系。T（需要时还可以用临近的字母U和S）表示任意类型 2. 泛型方法： T ...
Java——泛型
Yawn
05-17 206
1. 简介 首先，我们先来说说“语法糖”。 语法糖（Syntactic Sugar）是一个专业性的术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。 Java中最常用的语法糖主要有泛型、变长参数、条件编译、自动拆装箱、内部类等。虚拟机并不支持这些语法，它们在编译阶段就被还原回了简单的基础语法结构，这个过程成为解语法糖。 什么是泛型： 简单来说，泛型就是一种模版 泛型中的类型在使用时指定，主要用于集合中 适用于多种数据类型执行相同的代码 泛型类型变量不能是基本数据类
Java——泛型之泛型概述、泛型定义格式、泛型好处、泛型类、泛型方法、泛型接口、类型通配符、可变参数
smile4548656的博客
04-19 193
Java——泛型
Java高级——泛型
ou_yang_mu_ling的博客
09-11 501
泛型一、为什么要有泛型？1.1 泛型1.2 问题一——类型不安全1.2 问题二——强转时可能出现报错1.3 引出泛型二、在集合中使用泛型2.1 在ArrayList中使用泛型2.2 在HashMap中使用泛型总结三、自定义泛型结构3.1自定义泛型类3.2自定义泛型方法四、泛型在继承上的体现五、通配符的使用六、泛型应用举例 一、为什么要有泛型？ 1.1 泛型 可以理解为生活中的标签 把元素的类型设计成一个参数,这个参数就是泛型 所谓泛型，就是允许在定义类、接口时通过一个标识符表示类中某个属性的类型或者是某个
Java基础——泛型
weixin_50458070的博客
05-17 225
泛型的类型参数只能是类类型（包括自定义类），不能是简单类型//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型//在实例化泛型类时，必须指定T的具体类型//key这个成员变量的类型为T,T的类型由外部指定public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定return key;
Java中的泛型程序设计
u014021258的专栏
10-25 739
泛型程序设计（Generic programming）意味着编写的代码可以被很多不同的类型的对象所重用。 使用泛型机制编写的程序代码要比那些杂乱地使用Object变量然后再进行强制类型转换的代码具有更好的安全性和可读性。泛型对于集合类特别有用，像ArrayList就是一个无处不在的集合类。泛型提供了一个很好的方案： 类型参数（type parameters）ArrayList类有一个类型参数来指
泛型DAO设计（转本站的yongtree,谢谢）
wsrjzhsy0493的博客
11-24 126
  泛型是JDK1.5的一个新的特性，使用泛型机制编写的程序代码要比那些杂乱的使用Object变量，然后再进行强制类型转换的代码具有更好的安全性和可读性。如果你的系统运行在JDK1.5以上的版本上，建议多使用泛型来代替无休止的对象转换。          在软件设计中我们开始对系统进行三层甚至是多层架构了，目的是职责更加的明确，功能更加的分离。而常常使用的三层架构就是将表现层、业务逻辑层和持久层进...
泛型设计
java
05-12 489
c++的开创了泛型设计的先河，现在java也紧随其后，相信java会越来越强大。学好泛型会对编程能力有很大帮助。 
java泛型设计---学习笔记
weixin_41670928的博客
05-14 407
泛型程序设计需要重点理解的内容：声明：代码借用的“莫等闲”的，博客地址：https://blog.csdn.net/sunxianghuang/article/details/51982979。尊重原创和著作权。泛型类型：用于通用型程序的设计。 //泛型类型 class Pair&lt;T&gt; { private T value; ...
【java核心技术】Java知识总结 -- 泛型程序设计一
分享学习编程中的遇到的问题,总结平时的笔记
09-15 664
Java核心技术中的泛型详解
java泛型的设计思想
狂风的博客
08-11 395
java泛型的设计思想1. 什么是泛型？为什么要使用泛型？1.1 使用泛型前1.2 使用泛型后2. 泛型的使用2.1 泛型类 1. 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？ 顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参）...
.NET独有的精巧泛型设计模式
weixin_34269583的博客
04-23 86
在.NET发展史中，2.0是具有里程碑意义的一个版本。从这个版本，.NET青出于蓝(Java)，而胜于蓝。在.NET 2.0带来的诸多新特性中，我认为泛型是最重要，没有之一。 虽然泛型出现已有多年，连Java都早已借鉴引入了泛型（虽然是语法糖），可是用泛型的编程思维方式并没有得到相应的普及。一方面是由于过去大量的Framework仍然是在非泛型时代写成的，另一方面泛型的设计模式没有得到发展，改变...
Java泛型深度解析：原因、类与方法
3.How——泛型的使用 3.1 泛型类 泛型类是在类声明时添加类型参数，如ArrayList的例子所示。例如，`ArrayList<T>`中的`T`就是一个类型参数，代表某种未知的具体类型。当我们实例化泛型类时，需要提供具体的类型，如`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值