JAVA泛型详解 --- 学习笔记

最新推荐文章于 2021-09-10 23:03:00 发布
最新推荐文章于 2021-09-10 23:03:00 发布
阅读量543 收藏
点赞数
分类专栏： 学习笔记 文章标签： 泛型

原文请戳此处！！！


1. 普通泛型

class Point<T>{                  //此处可以随便写标识符号，T只是Type的简称
    private T var;               // var的类型由T指定，也就是：由外部指定
    public T getVar(){           //返回值得类型也是由外部决定的
        return var;
    }
    public void setVar(T var){    //设置的类型也由外部决定
        this.var = var;
    }
}
public class GenericsDemo01{
    public static void main(String args[]){
        Point<String> p = new Point<String>();   //此处决定了类Point<T>里面的var类型为String类型
        p.setVar("forfan06");      //设置字符串
        System.out.println(p.getVar().length());  //此处分两步，一是取得字符串；二是获得字符串长度
    }
}

-----------------------------------------------------------------------------------------------------------

class Notepad<K, V>{    //指定了两个泛型类型T和V，当然，此处的T和V可以换成其他字符。但是为了方便识别，一般取一个有意义单词的大写首字母
    private K key;      // 此处的T和V均是由外部决定的
    private V value;
    public K getKey(){
        return this.key;
    }
    public V getValue(){
        return this.value;
    }
    public void setKey(K key){
        this.key = key;
    }
    public void setValue(V value){
        this.value = value;
    }
}
public class GenericsDemo02{
    public static void main(String args[]){
        Notepad<String, Integer> t = null;        //定义了两个泛型类型的对象。
        t = new Notepad<String, Integer>();       //里面的key和value分别为String和Integer类型。
        t.setKey("饭饭");                          //设置对象t的内容
        t.setValue(20);
        
        System.out.print("姓名：" + t.getKey());      //获取对象t的属性
        System.out.println("， 年龄：" + t.getValue());
    }
}

2. 通配符

class Info<T>{
    private T var;     //定义泛型变量，由外部决定
    public void setVar(T var){
        this.var = var;
    }
    public T getVar(){
        return this.var;
    }
    public String toString(){   //直接打印
        return this.var.toString();
    }
}
public class GenericsDemo03{
    public static void main(String args[]){
        Info<String> i = new Info<String>();  //使用String类型为泛型类型
        i.setVar("forfan06");
        fun(i);
    }
    public static void fun(Info<?> info){    //此处Info<?>里面没有明确指明泛型类型，说明可以接受任意的泛型对象。
        System.out.println("内容是：" + info);
    }
}

更好的验证通配符的作用：增加Info<Integer>如下代码：也可以正常运行！！！

class Info<T>{
    private T var;     //定义泛型变量，由外部决定
    public void setVar(T var){
        this.var = var;
    }
    public T getVar(){
        return this.var;
    }
    public String toString(){   //直接打印
        return this.var.toString();
    }
}
public class GenericsDemo03{
    public static void main(String args[]){
        Info<String> i = new Info<String>();  //使用String类型为泛型类型
        i.setVar("forfan06");
        fun(i);
        Info<Integer> s = new Info<Integer>();
        s.setVar(28);
        fun(s);
    }
    public static void fun(Info<?> info){    //此处Info<?>里面没有明确指明泛型类型，说明可以接受任意的泛型对象。
        System.out.println("内容是：" + info);
    }
}

上面程序若修改为：

class Info<T>{
    private T var;     //定义泛型变量，由外部决定
    public void setVar(T var){
        this.var = var;
    }
    public T getVar(){
        return this.var;
    }
    public String toString(){   //直接打印
        return this.var.toString();
    }
}
public class GenericsDemo03{
    public static void main(String args[]){
        Info<String> i = new Info<String>();  //使用String类型为泛型类型
        i.setVar("forfan06");
        fun(i);
        Info<Integer> s = new Info<Integer>();
        s.setVar(28);
        fun(s);
    }
    public static void fun(Info<T> info){    //此处Info<?>里面没有明确指明泛型类型，说明可以接受任意的泛型对象。
        System.out.println("内容是：" + info);
    }
}

则会出现编译错误！！！！！！！！！！！！

GenericsDemo03.java:22: error: cannot find symbol
    public static void fun(Info info){    
                                ^
  symbol:   class T
  location: class GenericsDemo03
1 error

编译错误


3. 受限泛型

上限：

class Info<T>{
    private T var;
    public void setVar(T var){
        this.var = var;
    }
    public T getVar(){
        return this.var;
    }
    public String toString(){
        return this.var.toString();
    }
}
public class GenericsDemo04{
    public static void main(String args[]){
        Info<Integer> i1 = new Info<Integer>();          //声明Integer类的泛型对象
        Info<Float> i2 = new Info<Float>();              //声明Float类的泛型对象
        i1.setVar(27);                                   //设置整数（小数）， 自动装箱！！
        i2.setVar(10.53f);
        fun(i1);
        fun(i2);
    }
    public static void fun(Info<? extends Number> temp){   //只能接受Number类及其子类的实例！！！！
        System.out.print(temp + "、");
    }
}

下限：

class Info<T>{
    private T var;
    public void setVar(T var){
        this.var = var;
    }
    public T getVar(){
        return this.var;
    }
    public String toString(){
        return this.var.toString();
    }
}
public class GenericsDemo04{
    public static void main(String args[]){
        Info<String> i1 = new Info<String>();
        Info<Object> i2 = new Info<Object>();
        i1.setVar("forfan06");
        i2.setVar(new Object());
        
        fun(i1);
        fun(i2);
    }
    public static void fun(Info<? super String> temp){     //只能接收String类或其父类（Object类）类型的泛型
        System.out.print(temp + "、");
    }
}


4. 泛型无法向上转型

class Info<T>{
    private T var;
    public void setVar(T var){
        this.var = var;
    }
    public T getVar(){
        return this.var;
    }
    public String toString(){
        return this.var.toString();
    }
}
public class GenericsDemo05{
    public static void main(String args[]){
        Info<String> i1 = new Info<String>();
        Info<Object> i2 = null;
        i2 = i1;   //此句会出错：error: incompatible types
    }
}

运行得到错误：

GenericsDemo05.java:17: error: incompatible types
        i2 = i1;   //此句会出错：incompatible types
             ^
  required: Info
  found:    Info
1 error

编译错误

  • 此时Info<String> i1, Info<Object> i2中，i2已经不是i1的基类了！！！所以不存在向上转型这一说法！！！！！

5. 泛型接口

interface Info<T>{          //在接口中定义泛型
    public T getVar();      //定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl<T> implements Info<T>{   //定义泛型接口的子类
    private T var;
    public InfoImpl(T var){             //通过构造方法设置属性内容
        this.var = var;
    }
    public T getVar(){
        return this.var;
    }
    public void setVar(T var){
        this.var = var;
    }
}
public class GenericsDemo06{
    public static void main(String args[]){
        Info<String> i = null;         //声明接口对象，泛型T此时为String类型
        i = new InfoImpl<String>("forfan06");     //通过子类实例化对象
        System.out.println("内容：" + i.getVar());
    }
}

interface Info<T>{          //在接口中定义泛型
    public T getVar();      //定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl implements Info<String>{   //定义泛型接口的子类
    private String var;
    public InfoImpl(String var){             //通过构造方法设置属性内容
        this.var = var;
    }
    public String getVar(){
        return this.var;
    }
    public void setVar(String var){
        this.var = var;
    }
}
public class GenericsDemo06{
    public static void main(String args[]){
        Info i = null;   //声明接口对象
        i = new InfoImpl("forfan06");  //通过子类实例化对象
        System.out.println("内容：" + i.getVar());
    }
}

6. 泛型方法

声明格式：

[访问权限] <泛型标识>  泛型标识 方法名称([泛型标识 参数名称])

class Demo{
    public <T> T fun(T t){       //可以接收任意类型的数据
        return t;                //直接把参数返回
    }
}
public class GenericsDemo07{
    public static void main(String args[]){
        Demo d= new Demo();
        String str = d.fun("forfan06");
        int i = d.fun(28);    //传递数字，自动装箱
        System.out.println(str);
        System.out.println(i);
    }
}

7. 通过泛型方法返回泛型类型实例

class Info<T extends Number>{    //指定上限，只能是数字类型。（只能是Number类的子类）
    private T var;
    public T getVar(){
        return this.var;
    }
    public void setVar(T var){
        this.var = var;
    }
    public String toString(){   //覆写Object类中的toString()方法
        return this.var.toString();
    }
}
public class GenericsDemo08{
    public static void main(String args[]){
        Info<Integer> i = fun(30);
        System.out.println(i.getVar());
    }
    public static <T extends Number> Info<T> fun(T param){      //方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定
        Info<T> temp = new Info<T>();    //根据传入的数据类型实例化Info
        temp.setVar(param);              //将传递的内容设置到Info对象的var属性中
        return temp;       //返回实例化对象
    }
}

8. 使用泛型统一传入的参数类型

class Info<T>{
    private T var;
    public T getVar(){
        return this.var;
    }
    public void setVar(T var){
        this.var = var;
    }
    public String toString(){
        return this.var.toString();
    }
}
public class GenericsDemo09{
    public static void main(String args[]){
        Info<String> i1 = new Info<String>();
        Info<String> i2 = new Info<String>();
        i1.setVar("forfan06");
        i2.setVar("你好！");
        add(i1,i2);
    }
    public static <T> void add(Info<T> i1, Info<T> i2){
        System.out.println(i1.getVar() + " " + i2.getVar());
    }
}

9. 泛型数组

public class GenericsDemo10{
    public static void main(String args[]){
        Integer i[] = fun1(1, 2, 3, 4, 5, 6);  //返回泛型数组
        fun2(i);
    }
    public static <T> T[] fun1(T...arg){   //接收可变参数
        return arg;                        //返回泛型数组 
    }
    public static <T> void fun2(T param[]){    //输出
        System.out.println("接收泛型数组：");
        for(T t:param){
            System.out.print(t + "、");
        }
    }
}

此时运行会得到以下警告：

GenericsDemo10.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

出现上面警告是因为用到了JAVA5.0的泛型，而5.0的泛型不做类型检查，例如ArrayList = a new ArrayList(); a.add("hello");这样会出现警告！解决方法有以下几种：

  1. 在方法的前面加上@SuppressWarnings("unchecked")
  2. 声明泛型类型，例如ArrayList<Object> a = new ArrayList<Object>();
  3. 使用1.4兼容JDK来编译， javac -source 1.4 Test.java
  4. 也可以查看警告信息，javac Xlint:unchecked Test.java。这样会显示详细的警告信息。

10. 泛型的嵌套设置

class Info<T, V>{
    private T var;
    private V value;
    public Info(T var, V value){
        this.setVar(var);
        this.setValue(value);
    }
    public void setVar(T var){
        this.var = var;
    }
    public void setValue(V value){
        this.value = value;
    }
    public T getVar(){
        return this.var;
    }
    public V getValue(){
        return this.value;
    }
}
class Demo<S>{
    private S info;
    public Demo(S info){
        this.setInfo(info);
    }
    public void setInfo(S info){
        this.info = info;
    }
    public S getInfo(){
        return this.info;
    }
}
public class GenericsDemo11{
    public static void main(String args[]){
        Demo<Info<String, Integer>> d = null;      //将Info作为Demo的泛型类型
        Info<String, Integer> i = null;            //Info指定两个泛型类型
        i = new Info<String, Integer>("forfan06", 30);    //实例化Info对象
        d = new Demo<Info<String, Integer>>(i);           //在Demo类中设置Info类的对象
        System.out.println("内容一：" + d.getInfo().getVar());
        System.out.println("内容二：" + d.getInfo().getValue());
    }
}

泛型方法不一定要通过参数来确定泛型准确类型，可以只通过返回值，比如：

public static <E> ArrayList<E> new ArrayList(){
     return new ArrayList<E>();
}

public List<PrepaidHistory> queryHistories(Long skyid, PrepaidHistoryType type, Date from, Date end){
     ...
     return Lists.newArrayList();
}

这样Lists.newArrayList();

智能的知道返回类型为PrepaidHistory


forfan06
关注
专栏目录
Ts基于泛型`＜T＞`的进阶使用
chenweiqiang77的博客
07-18 5144
这里可以注意到我们不得不多次使用类型断言。假若我们一旦检查过类型，就能在之后的每个分支里清楚地知道pet的类型的话就好了。TypeScript里的类型保护机制让它成为了现实。类型保护就是一些表达式，它们会在运行时检查以确保在某个作用域里的类型。要定义一个类型保护，我们只要简单地定义一个函数，它的返回值是一个类型谓词}在这个例子里，就是类型谓词。谓词为这种形式，必须是来自于当前函数签名里的一个参数名。每当使用一些变量调用isFish注意TypeScript不仅知道在if分支里pet是Fish。...
【Java知识点详解 4】Java泛型详解，淘宝特价版java面试
m0_64205605的博客
11-18 299
?表示不确定的类型 五、使用泛型时的注意事项 ============ 1、在定义一个泛型类时，在“<>”之间定义形式类型参数，例如：“class TestGen<K,V>”，其中“K”，“V”不代表值，而是表示类型。 2、实例化泛型对象时，一定要在类名后面指定类型参数的值（类型），一共要有两次书写。 3、使用泛型时，泛型类型必须为引用数据类型，不能为基本数据类型，Java中的普通方法，构造方法，静态方法中都可以使用泛型，方法使用泛型之前必须先对泛型进行声明，可以使用任意字母，一般都
编译.java后出现：Note:checkUser.java uses unchecked or unsafe operations.Note:Recompile with -Xlint :unchecked for details.
KOOK_OKKO的专栏
05-25 1万+
 如果显示为中文就是：     注意： a.java 使用了未经检查或不安全的操作。     注意： 要了解详细信息，请使用 -Xlint:unchecked 重新编译。  其实是很简单，是因为用到了JAVA5.0的泛型，而5.0的泛型不做类型检查，例如ArrayList a =new ArrayList();a.add("hello");这样会出现警告，解决方法有以下
Pytorch Note
小树屋
11-21 304
如果网络的输入数据维度或类型上变化不大，设置 torch.backends.cudnn.benchmark = true 可以增加运行效率； 如果网络的输入数据在每次 iteration 都变化的话，会导致 cnDNN 每次都会去寻找一遍最优配置，这样反而会降低运行效率。 ...
JavaNote
DCoder2009的博客
12-14 357
java学习笔记，更新中......
JAVA学习笔记-java学习笔记WORD样式.docx
12-26
### JAVA学习笔记知识点详解 #### 一、计算机概述 1. **计算机**：电子设备，用于处理信息。 2. **计算机硬件**： - **中央处理器（CPU）**：计算机的大脑，负责处理指令。 - **内存（RAM）**：临时存储数据，...
Java笔记---李兴华
04-15
这一阶段引入了许多新特性，如泛型、注解等，大大增强了Java的功能性和灵活性。 - **更名与升级**：1998年，Java2发布，标志着Java进入了一个新的发展阶段。随后，2005年Sun Microsystems宣布将Java2更名为Java SE、...
Java泛型面试必问15题，深入详解泛型【附解答】
weixin_57907028的博客
05-12 2495
泛型 什么是泛型？泛型的作用？ Java 泛型（Generics）是 JDK 5 中引入的一个新特性。 使用泛型参数，可以增强代码的可读性以及稳定性。编译器可以对泛型参数进行检测，并且通过泛型参数可以指定传入的对象类型。比如 ArrayList<Persion> persons = new ArrayList<String>() 这行代码就指明了该ArrayList 对象只能传入 Persion 对象，如果传入其他类型的对象就会报错。 可以用于构建泛型集合。原生 List 返回
李兴华-JavaSE开发详解笔记-李兴华
02-07
李兴华的"JavaSE开发详解笔记"深入浅出地讲解了这个重要领域的诸多知识点，旨在帮助开发者掌握Java编程的精髓。 在JavaSE中，首要的知识点是Java语法基础，包括数据类型、变量、运算符、流程控制语句（如if-else，...
gradle与jenkins编译常见报错及解决
热门推荐
caidai1989的专栏
10-28 2万+
一、jenkins编译错误总结 1.错误一：   /data/jenkins/workspace/tv-child-release/tvApp/libraryPrj/lecore/src/com/letv/core/utils/DevicesUtils.java:1335: error: cannot find symbol
Ubuntu编译安卓系统时出现的问题
wygsqsj的博客
09-10 2996
最近使用ubuntu编译安卓源码，具体操作步骤见下面链接，此处记录一下出现的问题。 教程链接： ubuntu-18.04.4 Android系统源码R(Android 11)下载及编译_王人冉的博客-CSDN博客 repo可以看作就是python写的git扩展工具类，为了更好的管理Androd系统源码，需要注意的问题是当前谷歌的repo是以python3为基准写的，我使用的ubuntu16版本，python默认是2.7版本，所以执行 repo sync 命令时出现了各种问题： Tracebac
Ubuntu Eclipse CDT编译动态链接库文件报错recompile with -fPIC错误
飞鱼
07-21 2978
Building target: libtest2.so Invoking: Cross GCC Linker gcc -shared -o "libtest2.so" ./hello_so.o /usr/bin/ld: ./hello_so.o: relocation R_X86_64_32 against `.rodata' can not be used when making a shared object; recompile with -fPIC ./hello_so.o: error
解决recompile module问题
POE_Trinity的专栏
07-26 1508
这个问题自己经常遇到，昨天又遇到了，使用原来的方法不起作用，导致了又学会新的一种方法，一般遇到这两种问题就用下面两种方法试试吧，一般都可以解决。 方法一：很可能是由于新装了SDK与原来的文件冲突了，我们只要将新装SDK的Library Files调到最下面去（Library Files调出来的方法  Tools->Options->Project and Solutions -> VC++ Di
使用 Gradle 插件进行代码分析(转)
weixin_34396902的博客
03-06 244
代码分析在大多数项目中通常是作为最后一个步骤（如果做了的话）完成的。其通常难以配置及与现有代码整合。 本文旨在勾勒出使用 Gradle 整合 PMD 与 FindBugs 的步骤，并将其与一个现有的 Sonar 构建工具进行整合。 PMD、CheckStyle 和 FindBugs 首先要做的就是在我们的 build.gradle 文件中添加插件： ? ...
编译 java 出错
yywfff的专栏
05-12 778
我在编译index_jsp.java 时，遇见编译提示Note:index_jsp.java uses or overrides a deprecated API.Note:Recompile with -deprecation for details.请各位高手帮忙解决一下
cmake编译时候出现recompile with -fPIC
lwei的专栏
07-03 3943
在编译opencv的时候出现recompile with -fPIC。这个时候找到对应出错的模块，比如zlib模块。那么在路径3rdparty/zlib/CMakeFiles/zlib.dir/flags.make 加上-fPIC
Java泛型详解：类型安全与编程便利
Java泛型是Java语言的重要特性，它增强了类型系统的表达力，提高了代码的类型安全性，降低了运行时错误的可能性，同时也方便了代码的重用。对于任何Java开发者来说，理解和掌握泛型都是非常关键的技能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值