java泛型总结学习

最新推荐文章于 2021-04-27 11:28:08 发布
最新推荐文章于 2021-04-27 11:28:08 发布
阅读量957 收藏 1
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/findmyself_for_world/article/details/42493769
版权

代码中经常有用到泛型，但是从来没有系统的总结一下它的用法，今天有时间就做一个总结。

（一）概念

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。

（二）为什么使用泛型

在以往的J2ES中，没有泛型的情况下，通常是通过Object类型进行多种类型的转换。在使用object进行多种类型的转换时，一般是基于开发者知道转换的类型，例如（object->string），否则编译时不会报错，但是运行时会报classCastException。

使用泛型的好处在于它在编译的时候进行类型安全检查，并且在运行的时候所有的类型转换都是强制的，隐式的，大大提高了代码的重用。

（三）泛型的使用

一）实例分析

1、<T>是泛型的标记，当然可以使用别的名字，比如。使用<T>声明一个泛型的引用，从而可以在class、方法及接口中使用它进行数据定义，参数传递。

2、<T>在声明的时候相当于一个有意义的数据类型，编译过程中不会发生错误；在实例化时，将其用一个具体的数据类型进行替代，从而就可以满足不用需求。

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 GenericsDemo06{  
    public static void main(String args[]){  
        Point<String> p = new Point<String>() ; // 里面的var类型为String类型  
        p.setVar("it") ;        // 设置字符串  
        System.out.println(p.getVar().length()) ;   // 取得字符串的长度  
    }  
};
二）泛型的规则和限制

1、泛型的参数类型只能是引用类型，而不能是简单类型。

      比如，<int>是不可使用的。

2、可以声明多个泛型参数类型，比如<T, P,Q…>，同时还可以嵌套泛型，例如：<List<String>>

3、泛型的参数类型可以使用extends语句，例如<T extends superclass>。

4、泛型的参数类型可以使用super语句，例如< T super childclass>。

5、泛型还可以使用通配符，例如<? extends ArrayList>

下面一一举例说明：

（1）申明多个泛型类型

<span style="color:#ff0000;">//申明多个泛型类型</span>
class Notepad<K,V>{       // 此处指定了两个泛型类型  
    private K key ;     // 此变量的类型由外部决定  
    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 GenericsDemo09{  
    public static void main(String args[]){  
        Notepad<String,Integer> t = null ;        // 定义两个泛型类型的对象  
        t = new Notepad<String,Integer>() ;       // 里面的key为String，value为Integer  
        t.setKey("汤姆") ;        // 设置第一个内容  
        t.setValue(20) ;            // 设置第二个内容  
        System.out.print("姓名；" + t.getKey()) ;      // 取得信息  
        System.out.print("，年龄；" + t.getValue()) ;       // 取得信息  
  
    }  
};

（2）extends语句

使用extends语句将限制泛型参数的适用范围。例如：

<T extends collection> ，则表示该泛型参数的使用范围是所有实现了collection接口的calss。如果传入一个<String>则程序编译出错。

（3）通配符

使用通配符的目的是为了解决泛型参数被限制死了不能动态根据实例来确定的缺点。


<span style="color:#ff0000;">//extends和通配符的结合使用</span>
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 GenericsDemo17{  
    public static void main(String args[]){  
        Info<Integer> i1 = new Info<Integer>() ;        // 声明Integer的泛型对象  
        Info<Float> i2 = new Info<Float>() ;            // 声明Float的泛型对象  
        i1.setVar(30) ;                                 // 设置整数，自动装箱  
        i2.setVar(30.1f) ;                              // 设置小数，自动装箱  
        fun(i1) ;  
        fun(i2) ;  
    }  
    public static void fun(Info<? extends Number> temp){  // 只能接收Number及其Number的子类  
        System.out.print(temp .getVar()+ "、") ;  
    }  
};  
打印结果为：
30、30.1、

（4）super语句

super语句的作用与extends一样，都是限制泛型参数的适用范围。区别在于，super是限制泛型参数只能是指定该class的上层父类。

例如<T super List>，表示该泛型参数只能是List和List的上层父类。

<span style="color:#ff0000;">//super的使用</span>
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 GenericsDemo21{  
    public static void main(String args[]){  
        Info<String> i1 = new Info<String>() ;      // 声明String的泛型对象  
        Info<Object> i2 = new Info<Object>() ;      // 声明Object的泛型对象  
        i1.setVar("hello") ;  
        i2.setVar(new Object()) ;  
        fun(i1) ;  
        fun(i2) ;  
    }  
    public static void fun(Info<? super String> temp){    // 只能接收String或Object类型的泛型  
        System.out.print(temp + "、") ;  
    }  
};

（5）泛型接口的使用

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

不管想要对参数之间还是参数与返回类型之间的泛型类型施加约束，都可以使用泛型方法：
例如，如果编写的反转函数是在位置上反转，那么可能不需要泛型方法。然而，如果希望反转返回一个新的List，那么可能会希望新List的元素类型与传入的List的类型相同。在这种情况下，就需要一个泛型方法：


<T> List<T> reverse(List<T> list)


 
class Demo{  
    public <T> T fun(T t){            // 可以接收任意类型的数据  
        return t ;                  // 直接把参数返回  
    }  
};  
public class GenericsDemo26{  
    public static void main(String args[]){  
        Demo d = new Demo() ;   // 实例化Demo对象  
        String str = d.fun("汤姆") ; //   传递字符串  
        int i = d.fun(30) ;     // 传递数字，自动装箱  
        System.out.println(str) ;   // 输出内容  
        System.out.println(i) ;     // 输出内容  
    }  
};
（7）通过泛型方法返回泛型实例 

//
class Info<T extends 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 GenericsDemo27{  
    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(){       // 覆写Object类中的toString()方法  
        return this.var.toString() ;      
    }  
};  
public class GenericsDemo28{  
    public static void main(String args[]){  
        Info<String> i1 = new Info<String>() ;  
        Info<String> i2 = new Info<String>() ;  
        i1.setVar("HELLO") ;        // 设置内容  
        i2.setVar("汤姆") ;       // 设置内容  
        add(i1,i2) ;  
    }  
    public static <T> void add(Info<T> i1,Info<T> i2){  
        System.out.println(i1.getVar() + " " + i2.getVar()) ;  
    }  
};  
 泛型数组
public class GenericsDemo30{  
    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.print("接收泛型数组：") ;  
        for(T t:param){  
            System.out.print(t + "、") ;  
        }  
    }  
};

（9）  泛型的嵌套设置 

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 GenericsDemo31{  
    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>("汤姆",30) ;    // 实例化Info对象  
        d = new Demo<Info<String,Integer>>(i) ; // 在Demo类中设置Info类的对象  
        System.out.println("内容一：" + d.getInfo().getVar()) ;  
        System.out.println("内容二：" + d.getInfo().getValue()) ;  
    }  
};



上面是泛型的一些基本用法，下面讲一下一些注意事项。

（四）泛型使用需要注意的地方

1.泛型无法向上转型

public class GenericDemoNote {
	
	public static void main(String[] args){
	 
	        Point<Integer> i1 = new Point<Integer>();        // 声明Integer的泛型对象  
	        Point<Object> i2 = null;            // 声明Float的泛型对象  
	        i2 = i1;  //<span style="background-color: rgb(255, 0, 0);">Type mismatch: cannot convert from Point<Integer> to Point<Object></span>
	    
	    
	}
	 public static void fun(Point<?> temp){  // 只能接收Number及其Number的子类  
	        System.out.print(temp.getVar() + "、") ;  
	    } 

}
2.




qianmacao
关注
专栏目录
java泛型学习总结
qq_41784749的博客
06-16 1万+
泛型的本质是参数化类型，即所操作的数据类型被指定为一个参数。这种类型参数可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 在没有泛型的情况下，通过对类型Object的引用来实现参数的转换，这种转换是需要显式地强制类型转换，对于强制类型转换错误的情况，编译器可能不提示错误，而在运行时候却又通不过，这是一个安全隐患。可能给我们的开发带来了麻烦，难以找到运行时错误，增加不必要的精力开支，所以一般提倡使用泛型来实现参数化类型。 使用泛型的好处 类型安全。泛型的主要目的就是提高Java程序的类
Java中泛型总结(全面)
qq_29545781的博客
07-28 1796
参考资料： 书：Java编程思想 博客： https://blog.csdn.net/wang__qin/article/details/81415223 https://blog.csdn.net/harvic880925/article/details/49883589 https://blog.csdn.net/qq_27093465/article/details/73229016 ...
全面总结Java泛型--实例
10-04 377
虽然Scala创始人Martin Odersky说当年正是因为Java泛型的丑陋，所以才想到要创建一个新的语言，不过这仍然不妨碍我们学习Java泛型。毕竟即使听说Java泛型不好用，但好不好用还是得会用了才知道。下面是一些有关Java泛型的总结：普通泛型class Point{  // 此处可以随便写标识符号，T是type的简称   private T var ; // var的类型由T指
java学习笔记10--泛型总结
weixin_34250709的博客
12-11 126
java学习笔记系列: java学习笔记9--内部类总结 java学习笔记8--接口总结 java学习笔记7--抽象类与抽象方法 java学习笔记6--类的继承、Object类 java学习笔记5--类的方法  java学习笔记4--对象的初始化与回收 java学习笔记3--类与对象的基础  java学习笔记2--数据类型、数组 java学习笔记1--开发环境平台总结 本文地址...
JAVA 泛型总结
鑫宇的博客
04-27 340
什么是泛型 背景 JAVA推出泛型以前，程序员可以构建一个元素类型为Object的集合，该集合能够存储任意的数据类型对象，而在使用该集合的过程中，需要程序员明确知道存储每个元素的数据类型，否则很容易引发ClassCastException异常。 泛型的概念 Java泛型(generics) 是JDK5中引入的-一个 新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数。 泛型的好处 类型安全 消除了强制类
Java泛型总结
weixin_30245867的博客
11-25 100
0. 概述 泛型是Jdk1.5引入的特性。泛型是Java程序员最常用且最容易被忽视的知识之一。许多Java程序员只是使用泛型类。但不考虑其工作方式，直到出现问题。 1 术语 用示例进行描述。ArrayList<E>类、ArrayList<Integer>类： 整个称为ArrayList<E> 泛型类型。 ArrayL...
Java泛型深入学习和总结 看这一篇就足够！
12-22
二 泛型类、泛型接口、泛型方法、泛型通配符 2.1 泛型类： 2.2 泛型接口： 2.3 泛型方法： 2.4 泛型通配符： 三 限定类型变量 四 泛型中的约束和局限性 4.1 不能用基本类型实例化类型参数 4.2 运行时类型查询只适用...
Java泛型编程最全总结
04-05
Java泛型是Java编程语言中的一个关键特性，它在2004年随着JDK 5.0的发布被引入，极大地增强了代码的类型安全性和重用性。泛型允许我们在编写类、接口和方法时指定参数化类型，使得代码在编译时期就能捕获类型错误，...
Java深度历险之Java泛型.docx
最新发布
06-28
### Java泛型详解 #### 一、Java泛型概述 Java泛型（Generics）是Java SE 5.0引入的一项重要新特性，它允许开发者在定义类、接口或方法时使用类型参数（Type Parameters）。类型参数在使用时可以用具体的类型来...
java泛型总结
司新博的博客
07-26 253
泛型笔记 Jdk5引入了泛型概念，可以使类型参数化。 定义一个泛型类： 定义一个泛型类，使用这个类的时候，就像使用List接口一样去实例化相应参数的对象就可以。 例如： public class Fanxing&lt;T&gt; { //定义一个泛型类//定义泛型类时，也可以定义多个类型，例如 Fanxing&lt;T1，T2&gt;private T nam...
学习：Java泛型之一
weixin_34138139的博客
03-09 108
  “ 泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。” 　　1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。 　　2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。 　　3、泛型的类型参数可以有多...
Java泛型学习总结
猿诗人的博客
03-28 281
感觉在Java的世界里，我永远是初学者。还是有好多东西需要总结学习。 Java泛型：泛型类、泛型接口和泛型方法1、泛型类出现的必要性泛型类出现的原因之一为容器类的使用，看下面的代码：public class Container { private String key; private String value; public Container(String k, Str
Java泛型深入理解与应用
总结，泛型是Java中一种强大的工具，它提高了代码的可读性、类型安全性，并减少了冗余的类型转换。学习和掌握泛型是提升Java编程能力的关键步骤，对于开发者来说尤其重要。通过李兴华老师的课程，初学者和有经验的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值