详解Java泛型之入门泛型必懂的知识点

开发 后端
今天我来讲解第一个知识点:入门泛型必懂的知识点。先帮大家扫清泛型基础概念的相关知识点,也欢迎大家持续关注我的后续文章。

 我相信,绝大多数初始Java泛型的同学都会感到这个知识点理解起来有些困难,在这里我会对java泛型相关知识点做一个详细的介绍,包括:入门泛型必懂的知识点、通配符、泛型擦除以及泛型应用四个内容。今天我来讲解第一个知识点:入门泛型必懂的知识点。先帮大家扫清泛型基础概念的相关知识点,也欢迎大家持续关注我的后续文章。

[[406054]]

泛型定义

泛型的英文是 generics,generic 的意思是通用,而翻译成中文,泛应该意为广泛,型是类型。所以泛型就是能广泛适用的类型。但泛型还有一种较为准确的说法就是为了参数化类型,或者说可以将类型当作参数传递给一个类或者是方法。我们通过两个实例对比来了解使用泛型和好处。

1.不使用泛型的实例

  1. public class ValueDemo { 
  2.   Object value; 
  3.   public Object getValue() { 
  4.       return value; 
  5.   } 
  6.   public void setValue(Object value) { 
  7.       this.value = value; 
  8.   } 
  9.   public static void main(String[] args) { 
  10.       // TODO Auto-generated method stub 
  11.       ValueDemo demo = new ValueDemo(); 
  12.       demo.setValue(888); 
  13.       int value = (int) demo.getValue(); 
  14.       demo.setValue("hello"); 
  15.       String value1 = (String) demo.getValue(); 
  16.       System.out.println(value); 
  17.       System.out.println(value1);  
  18.   } 

2.使用泛型的实例

  1. public class ValueDemoT<T> { 
  2.       T value; 
  3.       public T getValue() { 
  4.         return value; 
  5.       } 
  6.       public void setValue(T value) { 
  7.         this.value = value; 
  8.       } 
  9.   public static void main(String[] args) { 
  10.       // TODO Auto-generated method stub 
  11.       ValueDemoT<Integer> demo = new ValueDemoT<Integer>(); 
  12.       demo.setValue(888); 
  13.       Integer value = demo.getValue(); 
  14.       ValueDemoT<String> demo1 = new ValueDemoT<String>(); 
  15.       demo1.setValue("hello"); 
  16.       String value1 = demo1 .getValue(); 
  17.       System.out.println(value); 
  18.       System.out.println(value1);  
  19.   } 

通过上面的例子我们可以发现使用泛型的好处主要有三点:

1.相对于Object 代替一切类型这种方式,泛型不再需要对取出来的结果进行强制转换了!泛型使得数据的类型可以像参数一样由外部传递进来,实现类型参数化。

2.泛型参数一旦确定好,如果类型不匹配,编译器就不通过。如下图所示:

这是一种类型安全检测机制,一定程度上提高了软件的安全性防止出现低级的失误。

3.泛型提高了程序代码的可读性,不必要等到运行的时候才去强制转换,在定义或者实例化阶段,因为 ValueDemoT 这个类型显化的效果,程序员能够一目了然猜测出代码要操作的数据类型。

泛型类、泛型方法和泛型接口

泛型按照使用情况可以分为 3 种。

  • 泛型类。
  • 泛型方法。
  • 泛型接口。

泛型类

  1. public class Demo<T> { 
  2.         T field1; 

实例化方法如下:

  1. Demo <String> demo1=new Demo <>(); 
  2. Demo <Integer> demo2 =new Demo<>(); 

泛型方法

泛型方法必须以进行声明,其中包括有参方法和无参方法,具体代码如下

  1. public class Demo { 
  2.  //无返回值的方法 
  3.   public <T> void testMethod1(T t){ 
  4.           //code 
  5.  //有返回值的方法 
  6.  public  <T> T testMethod2(T t){ 
  7. return null

泛型接口

泛型接口与泛型类的定义及使用基本相同,代码如下:

  1. public interface DemoT<T> { 
  2.     public T test(); 

泛型上下边界

在使用泛型的时候,我们还可以为传入的泛型类型实参进行上下边界的限制。

— 泛型的参数使用extends关键字表示参数只能接受类class和其子类。这里的class是上限。

— 泛型的参数使用super关键字表示参数只能接受类class和其父类。这里的class是下限。

使用的代码如下:

  1. public class Vehicle { 
  2.   public void drive() {}; 
  3.   public void brake() {}; 
  4. public class Car extends Vehicle { 
  5.   public void drive() { 
  6.       System.out.println("car的drive方法"); 
  7.   }; 
  8.   public void brake() { 
  9.       System.out.println("car的brake方法"); 
  10.   }; 
  11. public class Benz extends Car{ 
  12.   public void drive() { 
  13.       System.out.println("benz drive"); 
  14.   }; 

定义一个泛型方法

  1. public class CarT { 
  2.   public static void main(String[] args) { 
  3.       getCar(new Benz()); 
  4.       getCar(new Car()); 
  5.       getCar(new Vehicle()); //IDE报错 
  6.   } 
  7.   public static <T extends Car> void getCar(T car) { 
  8.       car.drive(); 
  9.   } 

可以看到方法getCar(T car) 中的参数只能传入 Car类或者其子类的实例,而Car的父类Vehicle的实例则不能传入!super的使用跟extends类似,这里就不再详细讲解了

泛型的注意点

1.泛型方法中的泛型参数与类的泛型参数没有关联,代码如下:

  1. public class Demo1<T> { 
  2.   public <T> T testMethod1(T t){ 
  3.         return t; 
  4.   } 
  5.   public static void main(String[] args) { 
  6.       Demo1<String> demo=new Demo1<String> (); 
  7.       Integer i=demo.testMethod1(new Integer(123)); 
  8.       System.out.println(i); 
  9.   } 

可以看到Demo1和testMethod1(T t)可以赋值不同的类型,前者是String而后者是Integer。

2.出于规范的目的,泛型中的T 只是一种习惯性写法,我们可以把替换为其他标识,例如。常见的其他约定写法如下:

  • T 代表一般的任何类。
  • E 代表 Element 。
  • K 代表 Key 。
  • V 代表 Value,通常与 K 一起配合使用。

3.泛型可以有多个参数,我们以2个参数为例,代码如下:

  1. public class ValueDemoT2<A,B> { 
  2.       A value1; 
  3.       B value2; 
  4.       public  void setValue(A p_value1,B p_value2) { 
  5.         value1 = p_value1; 
  6.         value2 = p_value2; 
  7.       } 
  8.   public static void main(String[] args) { 
  9.       ValueDemoT2<Integer,String> demo = new ValueDemoT2<Integer, String>(); 
  10.       demo.setValue(123456,"hello"); 
  11.       System.out.println(demo.value1); 
  12.       System.out.println(demo.value2);  
  13.   } 

执行代码输出:

  • 123456
  • Hello

4.泛型类或者泛型方法中,不接受 8 种基本数据类型。例如下面代码则无法编译通过

  1. List<int> li = new ArrayList<>(); 

 

责任编辑:姜华 来源: 今日头条
相关推荐

2021-06-18 08:25:42

Java泛型通配符

2021-07-01 06:47:30

Java泛型泛型擦除

2021-07-09 06:11:37

Java泛型Object类型

2022-06-19 22:54:08

TypeScript泛型工具

2017-11-14 14:41:11

Java泛型IO

2011-03-21 16:26:28

java泛型

2010-01-06 10:43:49

.NET Framew

2011-04-13 09:16:55

泛型

2021-03-01 07:34:42

Java泛型ArrayList

2021-09-29 18:17:30

Go泛型语言

2020-02-21 08:18:58

JavaScala编程语言

2009-09-25 10:03:51

Java泛型

2009-07-30 14:00:21

ASP.NET 2.0

2017-03-06 16:51:52

Java泛型实现

2021-12-30 19:34:15

Java泛型JDK

2011-06-03 08:49:54

Java

2009-08-24 18:22:05

C# 泛型编程

2009-06-16 11:32:00

Java泛型

2020-10-26 14:01:22

Java泛型

2012-02-16 10:36:43

Java
点赞
收藏

51CTO技术栈公众号