java 泛型详解

最新推荐文章于 2024-03-10 19:43:54 发布
最新推荐文章于 2024-03-10 19:43:54 发布
阅读量356 收藏
点赞数
分类专栏： Java

1 普通泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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()) ;   // 取得字符串的长度
     }
};
----------------------------------------------------------
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 通配符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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 GenericsDemo14{
     public static void main(String args[]){
         Info<String> i = new Info<String>() ;       // 使用String为泛型类型
         i.setVar( "it" ) ;                            // 设置内容
         fun(i) ;
     }
     public static void fun(Info<?> temp){     // 可以接收任意的泛型对象
         System.out.println( "内容：" + temp) ;
     }
};

3 受限泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
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 + "、" ) ;
     }
};
----------------------------------------------------------
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 + "、" ) ;
     }
};

4 泛型无法向上转型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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 GenericsDemo23{
     public static void main(String args[]){
         Info<String> i1 = new Info<String>() ;      // 泛型类型为String
         Info<Object> i2 = null ;
         i2 = i1 ;                               //这句会出错 incompatible types
     }
};

5 泛型接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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  泛型方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 通过泛型方法返回泛型类型实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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 使用泛型统一传入的参数类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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()) ;
     }
};

9 泛型数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 + "、" ) ;
         }
     }
};

 10 泛型的嵌套设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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()) ;
     }
};
Zju_Jemery
关注
专栏目录
Java中泛型的用法总结
09-03
主要介绍了Java中泛型的用法,实例总结了java中泛型的常见使用技巧,需要的朋友可以参考下
深入理解java泛型详解
08-30
让我们深入探讨一下Java泛型的各个方面。 首先，泛型（Generic type）是一种在定义类、接口或方法时，使用类型参数的方式。类型参数就像是方法的形参，但用于类型而非值。例如，当我们创建一个泛型列表`List<T>`，`...
java 泛型 用法_Java中泛型的用法总结
weixin_30995429的博客
02-12 191
本文实例总结了Java中泛型的用法。分享给大家供大家参考。具体如下：1 基本使用public interface List {void add(E);Iterator iterator();}2 泛型与子类Child是Parent的子类，List却不是List的子类。因此：List list = new ArrayList()是错误的。如果上面是正确的，那么：List ls = new Array...
Java泛型的使用
最新发布
m0_46335449的博客
03-10 1331
Java的泛型也是整个java知识体系中极为重要的一个部分，但是整体内容相对简单，简单理解一句话就是可以在集合中加入各种不同的数据元素，通过泛型，你可以具体限制是哪一种类型
【JavaSe】高级特性篇(一) Java高级特性泛型
不想当架构师的程序员不是好程序员
08-25 670
JavaSe·特性篇(一) 泛型 1. 泛型概述 我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。 public static void main(String[] args) { Collection coll = new ArrayList(); coll.add(...
java泛型详解.pdf
10-02
java泛型详解.pdf
java泛型详解
08-31
Java 泛型详解 Java 泛型是 Java 语言中的一种重要机制，它可以帮助开发者编写更加安全、灵活和可重用的代码。在本文中，我们将详细介绍 Java 泛型的相关知识，包括泛型的概念、类型擦除、泛型的应用场景等内容。 ...
java泛型详解java泛型详解.doc
06-10
Java 泛型是一种强大的语言特性，它允许在类、接口和方法中使用类型参数，以实现类型的安全性和代码的重用性。泛型是 Java 从 JDK 5.0 版本开始引入的重要特性，目的是增强类型系统，提高程序的类型安全性，减少运行...
Java 泛型详解
09-18
Java泛型详解，Java泛型详解，Java泛型详解，Java泛型详解
java泛型使用
xiaocai9999的专栏
09-03 139
在jdk1.5以前我们开发可能会遇到这样一种情况，我们 在使用集合时会出现类型转换错误，为了解决这一情况， 在jdk1.5以上引入了泛型概念，那么怎么使用呢？ 泛型定义 比如arraylist,public void T demo(){}等，比如以下使用： public class GenericDemo1 { //泛型类型使用前必须先声明 //就是声明的泛型类型，放在返回值的前面 p
Java 泛型
weixin_30555515的博客
09-03 96
1、泛型方法 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。 泛型方法体的声明和其他...
Java 泛型的使用
Growing_hacker的博客
05-11 379
当代码逻辑不关注具体的数据类型时，只注重代码的逻辑的时候，可以考虑使用泛型。泛型可以很好的对类型参数化处理。 泛型的使用 泛型类 public class java_day01 <T> { } 泛型接口 public interface java_day01 <T> { public T getData(T t); } // 实现类，指定具体参数类型 class java_day01Impl implements java_day01<St
Java泛型使用
太阳
05-10 198
Java泛型
Java中泛型的使用
weixin_45077895的博客
04-14 196
泛型的理解 泛型类似于标签，告诉java这里面存放的是什么类型的东西。 把元素的类型设计成一个 参数，这个类型参数叫做泛型。 泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类 型或者是某个方法的返回值及参数类型。这个类型参数将在使用时(例如， 继承或实现这个接口，用这个类型声明变量、创建对象时)确定(即传入实 际的类型参数，也称为类型实参)。 ...
Java中泛型使用
weixin_34293902的博客
05-16 96
Java中泛型使用 泛型作用： 泛型：集合类添加对象不用强转 反射机制：将泛型固定的类的所有方法和成员全部显示出来   核心代码： ArrayList&lt;Ls&gt; ff=new ArrayList()&lt;Ls&gt;; Ls ls1=new Ls("薯片",5f); ff.add(ls1); Ls cls=ff.get(0);//这里不再需要强转     代码实...
Java---＞toString方法
Mrrr_Li的博客
10-04 148
toString 是源自java Object类，在Object 内定义为：返回一个 类名@hashcode的字符串，可以overridden 用来返回 你认为有用的信息， toStrng 没有arguments override：public String toString（）{ // insert you code return “informations” } 因为在java中 Object类是基类，所以每个类都会有toString方法。 System.out.println（Object）实际上就是
Java泛型详解与应用
Java泛型是自JDK 1.5（标记为5.0版本）起引入的一项重要特性，它极大地增强了代码的类型安全性和重用性。泛型允许我们在类、接口和方法中使用类型参数，使得数据结构和算法可以独立于具体的类型进行设计和实现，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值