大家好,又见面了,我是全栈君。
【定义】
一、泛型的定义主要有下面两种:
在程序编码中一些包括类型參数的类型,也就是说泛型的參数仅仅能够代表类。不能代表个别对象。(这是当今较常见的定义)
在程序编码中一些包括參数的类。其參数能够代表类或对象等等。
(如今人们大多把这称作模板)
不论使用那个定义。泛型的參数在真正使用泛型时都必须作出指明。
泛型类。是在实例化类的时候指明泛型的详细类型。
泛型方法。是在调用方法的时候指明泛型的详细类型。
二、使用泛型的目的:
一些强类型程序语言支持泛型,其主要目的是加强类型安全及降低类转换的次数,但一些支持泛型的程序语言仅仅能达到部份目的。
泛型程序设计(Genericprogramming)意味着编写的代码能够被非常多不同类型的对象所重用。
是对java语言的类型系统的一种扩展,以支持创建能够按类型进行參数化的类。能够把类型參数看作是使用參数化类型时指定的类型的一个占位符。就像方法的形式參数是执行时传递的值得占位符一样。
【Java泛型的几种类型代码】
一、不使用泛型的代码
我们定义一个Person类,包括三个属性x。y,z。在我们開始定义地时候,我们也不知道这三个属性是用来干什么的,所以我们定义为Object类型。
可是在使用的时候,我们分别对x。y。z赋予了int,double。String类型,所以在取出的时候。我们须要把这三个类型值进行强制转换。例如以下代码:
1. Person.java
<span style="font-size:18px;"> public class Person { private Object x; private Object y; private Object z; //使用Object类型。能够转化为不论什么类型 public Object getX() { return x; } public void setX(Object x) { this.x = x; } public Object getY() { return y; } public void setY(Object y) { this.y = y; } public Object getZ() { return z; } public void setZ(Object z) { this.z = z; } } 2. NoGenericTest.java public class NoGenericTest { public static void main(String[]args){ Person boy=new Person(); boy.setX(20); boy.setY(22.2); boy.setZ("帅哥TT"); //这里依据设置的不同类型的值,我们须要进行强制类型转化。int x=(Integer)boy.getX(); double y=(double)boy.getY(); String z=(String)boy.getZ(); System.out.println(x); System.out.println(y); System.out.println(z); }}3. 执行结果 20 22.2 帅哥TT</span>
二、使用一个类型变量泛型的代码
我们定义一个泛型类Person,定义三个属性x,y,z,在測试类中,我们设置属性的值,并打印。
<span style="font-size:18px;"> 1. Person.java public class Person<T> { private T x; private T y; private T z; public T getX() { return x; } public void setX(T x) { this.x = x; } public T getY() { return y; } public void setY(T y) { this.y = y; } public T getZ() { return z; } public void setZ(T z) { this.z = z; } } 2. GenericTest.java public class GenericTest { public static void main(String[]args){ Person boy=new Person(); boy.setX(20); boy.setY(22.2); boy.setZ("帅哥TT"); //不用进行类型转化 System.out.println(boy.getX()); System.out.println(boy.getY()); System.out.println(boy.getZ()); } } 3. 执行结果 20 22.2 帅哥TT 三、使用两个类型变量泛型的代码 我们定义一个泛型类Person,定义两个属性x,y。使用了两种不同的类型变量,在測试类中。我们设置属性的值。并打印。 1. Person.java public class Person<T1,T2> { private T1 x; private T2 y; public T1 getX() { return x; } public void setX(T1 x) { this.x = x; } public T2 getY() { return y; } public void setY(T2 y) { this.y = y; } } 2. GenericTest.java public class GenerricTest { public static void main(String[] args){ Person<String,Integer> boy=new Person<String,Integer>(); boy.setX("帅哥TT"); boy.setY(20); System.out.println(boy.getX()); System.out.println(boy.getY()); } } 3. 执行结果 帅哥TT 20</span>
四、使用泛型的继承
我们定义一个泛型类Person,定义两个属性x。y,然后定义还有一个泛型类Boy。定义属性z。Boy继承Person类,在測试类中,我们设置属性的值。并打印。
1. Person.java public class Person<T1,T2> { private T1 x; private T2 y; public T1 getX() { return x; } public void setX(T1 x) { this.x = x; } public T2 getY() { return y; } public void setY(T2 y) { this.y = y; } } 2. Boy public class Boy<T1,T2,T3>extendsPerson<T1,T2> { private T3 z; public T3 getZ() { return z; } public void setZ(T3 z) { this.z = z; } } 3. GenericTest.java 1public class GenericTest { 2 public static void main(String[] args){ 3 Boy<String,Integer,Double> boy=new Boy<String,Integer,Double>(); 4 boy.setX("帅哥TT"); 5 boy.setY(20); 6 boy.setZ(200000.22); 7 8 System.out.println(boy.getX()); 9 System.out.println(boy.getY()); 10 System.out.println(boy.getZ()); 11 } 12 } 4.执行结果 1 帅哥TT 2 20 3 200000.22
五、使用泛型的接口
我们定义一个泛型接口Person,定义两个方法,然后定义还有一个泛型类Boy,实现泛型接口Person。定义属性x,y,z,在測试类中。我们设置属性的值,并打印。
<span style="font-size:18px;">1. Person.java 1 public interface Person<T1,T2> { 2 public T1 getX(); 3 public T2 getY(); 4 } 2. Boy 1public class Boy<T1,T2,T3>implements Person<T1,T2> { 2 private T1 x; 3 private T2 y; 4 private T3 z; 5 public T1 getX() { 6 return x; 7 } 8 public void setX(T1 x) { 9 this.x = x; 10 } 11 public T2 getY() { 12 return y; 13 } 14 public void setY(T2 y) { 15 this.y = y; 16 } 17 public T3 getZ() { 18 return z; 19 } 20 public void setZ(T3 z) { 21 this.z = z; 22 } 23 24 } 3. GenericTest.java 1public class GenericTest { 2 public static void main(String[] args){ 3 Boy<String,Integer,Double> boy=newBoy<String,Integer,Double>(); 4 boy.setX("帅哥TT"); 5 boy.setY(20); 6 boy.setZ(200000.22); 7 System.out.println(boy.getX()); 8 System.out.println(boy.getY()); 9 System.out.println(boy.getZ()); 10 } 11 } 4. 执行结果 1 帅哥TT 2 20 3 200000.22</span>
六、使用泛型方法
说明一下。定义泛型方法时,必须在返回值前边加一个<T>。来声明这是一个泛型方法,持有一个泛型T,然后才干够用泛型T作为方法的返回值。
定义一个普通类Person,定义一个泛型方法,例如以下代码:
<span style="font-size:18px;">1. Person.java 1public class Person{ 2 public static<T>T getMiddle(T[]a){ 3 return a[a.length/2]; 4 } 5 public static void main(String [] args){ 6 String[]name={"帅哥TT","帅哥TT1","帅哥TT2"}; 7 String middle=Person.<String>getMiddle(name); 8 System.out.println(middle); 9 10 Integer[]num={20,22,25}; 11 Integer middle1=Person.<Integer>getMiddle(num); 12 System.out.println(middle1); 13 14 Double[]num1={20.0,22.2,25.5}; 15 Double middle2=Person.<Double>getMiddle(num1); 16 System.out.println(middle2); 17 } 18 } 2. 执行结果 1 帅哥TT1 2 22 3 22.2</span>
七、类型变量的限定
例如以下代码,我们在方法min中定义了一个变量smallest类型为T。这说明了smallest能够是不论什么一个类的对象,我们在以下的代码中须要使用compareTo方法, 可是我们没有办法确定我们的T中含有CompareTo方法,所以我们须要对T进行限定,在代码中我们让T继承Comparable类。
例如以下:
<span style="font-size:18px;">public static<T extendsComparable>T min(T[]a) 1.Person.java 1public class Person{ 2 public static<T extends Comparable>T min(T[]a){ 3 if(a==null||a.length==0){ 4 return null; 5 } 6 T smallest=a[0]; 7 for(int i=1;i<a.length;i++){ 8 if(smallest.compareTo(a[i])>0){ 9 smallest=a[i]; 10 } 11 } 12 return smallest; 13 } 14 public static void main(String [] args){ 15 Integer[]num={20,25,30,10}; 16 Integer middle=Person.<Integer>min(num); 17 System.out.println(middle); 18 } 19 } 2. 执行结果 10</span>
【Java泛型理解】
一、类型擦除
正确理解泛型概念的首要前提是理解类型擦除(type erasure)。 Java中的泛型基本上都是在编译器这个层次来实现的。
在生成的Java字节代码中是不包括泛型中的类型信息的。使用泛型的时候加上的类型參数,会被编译器在编译的时候去掉。这个过程就称为类型擦除。如在代码中定义的List<Object>和List<String>等类型。在编译之后都会变成List。JVM看到的仅仅是List,而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方,可是仍然无法避免在执行时刻出现类型转换异常的情况。
非常多泛型的奇怪特性都与这个类型擦除的存在有关,包含:
泛型类并没有自己独有的Class类对象。比方并不存在List<String>.class或是List<Integer>.class,而仅仅有List.class。
静态变量是被泛型类的全部实例所共享的。对于声明为MyClass<T>的类,訪问当中的静态变量的方法仍然是 MyClass.myStaticVar。
无论是通过new MyClass<String>还是new MyClass<Integer>创建的对象,都是共享一个静态变量。
泛型的类型參数不能用在Java异常处理的catch语句中。
由于异常处理是由JVM在执行时刻来进行的。由于类型信息被擦除,JVM是无法区分两个异常类型MyException<String>和MyException<Integer>的。对于JVM来说,它们都是 MyException类型的。也就无法执行与异常相应的catch语句。
二、最佳实践
在使用泛型的时候能够遵循一些主要的原则。从而避免一些常见的问题。
在代码中避免泛型类和原始类型的混用。比方List<String>和List不应该共同使用。这样会产生一些编译器警告和潜在的执行时异常。当须要利用JDK 5之前开发的遗留代码,而不得不这么做时,也尽可能的隔离相关的代码。
在使用带通配符的泛型类的时候,须要明白通配符所代表的一组类型的概念。因为详细的类型是未知的,非常多操作是不同意的。
泛型类最好不要同数组一块使用。你仅仅能创建new List<?>[10]这种数组。无法创建new List<String>[10]这种。这限制了数组的使用能力。并且会带来非常多费解的问题。因此,当须要类似数组的功能时候,使用集合类就可以。
不要忽视编译器给出的警告信息。
发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/116078.html原文链接:https://javaforall.cn
【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛
【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...