java 泛型详解

最新推荐文章于 2023-07-25 14:00:00 发布
最新推荐文章于 2023-07-25 14:00:00 发布
阅读量324 收藏
点赞数
分类专栏： 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 泛型详解
09-18
Java泛型详解，Java泛型详解，Java泛型详解，Java泛型详解
Java泛型详解
09-02
本文给大家汇总介绍了下java中的泛型的相关资料，包括引入泛型机制的原因，泛型类，泛型方法，泛型的实现以及泛型的注意事项，非常的详细，有需要的小伙伴可以参考下
JAVA泛型的使用（超详细）
weixin_45531755的博客
08-15 1万+
泛型的使用
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 5万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java泛型详解（史上最全泛型知识详解）
最新发布
m0_70325779的博客
07-25 4230
泛型是在JDK5之后引入的一个新特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式为用大白话来说，泛型就好比是给一个标签，通常情况下我们会在开发过程中或者个人学习或练习的过程中使用到泛型；就拿数组的泛型举例来说，我们把数组比作一个药瓶子，我们药瓶子贴上了什么标签，就只能放什么药，如果不管什么药都放在一个药瓶子里，那不得出大事吗？同样容器(数组)写上什么泛型，就只能存放什么数据；这样就不会导致我们存取数据的混乱。这样就解决了我们引言中提到的问题，也就解释了什么是泛型。
Java基础—泛型的使用（详细）
m0_63330888的博客
04-14 9593
文章目录 目录 零、概念 一、泛型的优点 1.1优点 1.2为什么要使用泛型 二、泛型使用与不使用的区别 1、泛型的没有使用会造成什么后果呢？ 2.添加泛型的使用会发生什么效果呢？ 【一、二】 知识点小结 关于包装类的延伸知识点 包装类 三、自定义泛型结构 3.1泛型类举个栗子 3.1.1 OrderTest类 3.2自定义泛型类的子类怎么处理？ 3.3、在继承情况中使用泛型 3.4自定义泛型方法 3.4.1泛型⽅法说明：⽅法也可以被泛型化，不管此时定义在其中的类是不.
java泛型详解
qq_42003527的博客
08-24 1万+
java泛型详解
深入理解java泛型详解
08-30
主要介绍了Java中的泛型详解，什么是泛型，作用以及基础实例等，喜欢的朋友可以参考
java泛型详解.pdf
10-02
java泛型详解.pdf
12、Java基础之泛型的使用
xiaosuxueJava的博客
01-09 973
Java泛型的使用
泛型的用法
weixin_57197500的博客
12-20 2596
泛型的一些简单的用法和实现
Java基础：泛型的使用
weixin_50835087的博客
08-11 1047
集合、类、方法中泛型的使用以及泛型在继承中的体现
Java---＞toString方法
Mrrr_Li的博客
10-04 114
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的泛型详解
peng的博客
05-30 8561
Java泛型是一种编程语言的特性，它允许类、接口和方法在定义时使用一个或多个类型参数，这些类型参数在调用时会被实际类型替换，从而增强了代码的重用性和类型安全性。通过使用泛型，我们可以编写出更加通用的代码，同时也可以减少代码中的强制类型转换操作，提高代码的可读性和可维护性。比如，我们可以使用泛型实现一个通用的容器类，该容器类可以存储任意类型的数据，并且在使用时可以保证数据类型的安全性。
Java泛型详解 | 最新、全面、详细和深入 | 2万字超全
xwshappy的博客
05-19 3090
深度记录Java后端开发，对Java的泛型特性进行详细的整理并且分享，最新版，本文参考了Java泛型详解，JVM相关内容，以及其他博主的优秀思想和个人实战理解而成，希望对大家有帮助！！！
第12章 泛型
m0_59157761的博客
12-16 318
一、为什么要有泛型 二、在集合中使用泛型 泛型的使用 1.jdk 5.0新增的特性 2.在集合中使用泛型： 总结： ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。 ② 在实例化集合类时，可以指明具体的泛型类型 ③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。 比如：add(E e) --->实例化以后：add(Integer e) ④ ...
java基础(十二 )-----Java泛型详解
05-16
Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。 一、泛型的基本语法 在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、接口名、方法名后面加上尖括号<>，括号中可以声明一个或多个类型参数，多个类型参数之间用逗号隔开。例如： ```java public class GenericClass<T> { private T data; public T getData() { return data; } public void setData(T data) { this.data = data; } } public interface GenericInterface<T> { T getData(); void setData(T data); } public <T> void genericMethod(T data) { System.out.println(data); } ``` 其中，`GenericClass`是一个泛型类，`GenericInterface`是一个泛型接口，`genericMethod`是一个泛型方法。在这些声明中，`<T>`就是类型参数，可以用任何字母代替。 二、泛型的使用 1. 泛型类的使用 在使用泛型类时，需要在类名后面加上尖括号<>，并在括号中指定具体的类型参数。例如： ```java GenericClass<String> gc = new GenericClass<>(); gc.setData("Hello World"); String data = gc.getData(); ``` 在这个例子中，`GenericClass`被声明为一个泛型类，`<String>`指定了具体的类型参数，即`data`字段的类型为`String`，`gc`对象被创建时没有指定类型参数，因为编译器可以根据上下文自动推断出类型参数为`String`。 2. 泛型接口的使用 在使用泛型接口时，也需要在接口名后面加上尖括号<>，并在括号中指定具体的类型参数。例如： ```java GenericInterface<String> gi = new GenericInterface<String>() { private String data; @Override public String getData() { return data; } @Override public void setData(String data) { this.data = data; } }; gi.setData("Hello World"); String data = gi.getData(); ``` 在这个例子中，`GenericInterface`被声明为一个泛型接口，`<String>`指定了具体的类型参数，匿名内部类实现了该接口，并使用`String`作为类型参数。 3. 泛型方法的使用 在使用泛型方法时，需要在方法名前面加上尖括号<>，并在括号中指定具体的类型参数。例如： ```java genericMethod("Hello World"); ``` 在这个例子中，`genericMethod`被声明为一个泛型方法，`<T>`指定了类型参数，`T data`表示一个类型为`T`的参数，调用时可以传入任何类型的参数。 三、泛型的通配符 有时候，我们不知道泛型的具体类型，可以使用通配符`?`。通配符可以作为类型参数出现在方法的参数类型或返回类型中，但不能用于声明泛型类或泛型接口。例如： ```java public void printList(List<?> list) { for (Object obj : list) { System.out.print(obj + " "); } } ``` 在这个例子中，`printList`方法的参数类型为`List<?>`，表示可以接受任何类型的`List`，无论是`List<String>`还是`List<Integer>`都可以。在方法内部，使用`Object`类型来遍历`List`中的元素。 四、泛型的继承 泛型类和泛型接口可以继承或实现其他泛型类或泛型接口，可以使用子类或实现类的类型参数来替换父类或接口的类型参数。例如： ```java public class SubGenericClass<T> extends GenericClass<T> {} public class SubGenericInterface<T> implements GenericInterface<T> { private T data; @Override public T getData() { return data; } @Override public void setData(T data) { this.data = data; } } ``` 在这个例子中，`SubGenericClass`继承了`GenericClass`，并使用了相同的类型参数`T`，`SubGenericInterface`实现了`GenericInterface`，也使用了相同的类型参数`T`。 五、泛型的限定 有时候，我们需要对泛型的类型参数进行限定，使其只能是某个类或接口的子类或实现类。可以使用`extends`关键字来限定类型参数的上限，或使用`super`关键字来限定类型参数的下限。例如： ```java public class GenericClass<T extends Number> { private T data; public T getData() { return data; } public void setData(T data) { this.data = data; } } public interface GenericInterface<T extends Comparable<T>> { T getData(); void setData(T data); } ``` 在这个例子中，`GenericClass`的类型参数`T`被限定为`Number`的子类，`GenericInterface`的类型参数`T`被限定为实现了`Comparable`接口的类。 六、泛型的擦除 在Java中，泛型信息只存在于代码编译阶段，在编译后的字节码中会被擦除。在运行时，无法获取泛型的具体类型。例如： ```java public void genericMethod(List<String> list) { System.out.println(list.getClass()); } ``` 在这个例子中，`list`的类型为`List<String>`，但是在运行时，`getClass`返回的类型为`java.util.ArrayList`，因为泛型信息已经被擦除了。 七、泛型的类型推断 在Java 7中，引入了钻石操作符<>，可以使用它来省略类型参数的声明。例如： ```java List<String> list = new ArrayList<>(); ``` 在这个例子中，`ArrayList`的类型参数可以被编译器自动推断为`String`。 八、总结 Java泛型是一个强大的特性，可以提高代码的可读性和安全性，降低代码的耦合度。在使用泛型时，需要注意它的基本语法、使用方法、通配符、继承、限定、擦除和类型推断等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值