java基础34 泛型的使用

本文知识点（目录）：

    1、泛型的好处
    2、泛型在集合中的常见应用（这里只用String类型举例）
    3、在泛型中是不能使用基本数据类型，如果需要使用基本数据类型，那么就使用基本数据类型对应的封装类型
    4、在方法上自定义泛型
    5、在类上自定义泛型
    6、在接口类上自定义泛型
    7、泛型的上下限

泛型是jdk1.5使用的新特性

1、泛型的好处

    1.将运行是异常提前至编译时。
    2.消除强制类型转换，所有的强制转换都是自动和隐式的，提高代码的重用率。
    3.提高了Java程序的类型安全性。

2、泛型在集合中的常见应用（这里只用String类型举例）

ArrayList<String> list=new ArrayList<String>(); 推荐使用

下面两种写法是为了兼顾新老系统的兼容性问题
ArrayList<String> lists=new ArrayList();
ArrayList lists=new ArrayList<String>();

注意：泛型没有多态的概念，左右两边的数据类型要一致，或者只写一边的泛型。

3、在泛型中是不能使用基本数据类型，如果需要使用基本数据类型，那么就使用基本数据类型对应的封装类型

   基本数据类型    封装类型
   byte--------------->Byte
   short-------------->Short
   int----------------->Integer
   long--------------->Long

   double----------->Double
   float--------------->Float

   boolean--------->Boolean

   char-------------->Character

4、在方法上自定义泛型

自定义泛型就是一个数据类型占位符或者一个数据类型变量

格式：
    修饰符 <声明自定的泛型> 返回值类型 函数名(自定义泛型的类型 参数){

    }

4.2、泛型方法需要注意的事项
1.泛型方法中自定义泛型具体数据类型是在调用该函数的时候传入实时参数确定的。
2.自定义泛型所用的标识符只要符号标识符的命名规范即可；但是我们习惯用一个大小的字母表示。

实例

 1 public class Demo2 {
 2     public static void main(String[] args) {
 3         int i = getData(23);
 4         String s = getData("hello");
 5         System.out.println(i);//返回结果：23
 6         System.out.println(s);//返回结果：hello
 7     }
 8     public static <abc>abc getData(abc o){//在方法上，自定义泛型
 9         return o;    
10     }
11 }

5、在类上自定义泛型

格式：
    class 类名<声明自定义泛型>{
    }

5.2、泛型类需要注意的事项
    1.泛型类上自定义泛型是使用该类创建对象的时候自定的具体数据类型的.
    2.如果一个类已经自定义了泛型，使用该类创建对象时，如果没有在指定泛型的具体类型，那么默认为Object类型
    3.静态的函数不能使用类上自定义泛型，如果静态函数需要使用，必须要在函数上自定泛型

实例1

 1 package com.dhb.collection;
 2 
 3 /**
 4  * @author DSHORE / 2018-5-25
 5  *
 6  */
 7 //元素的反转
 8 class MyArrays{
 9     public <T> void reverse(T[] arr) {//在方法上，自定义泛型
10         for (int starIndex = 0,endIndex = arr.length-1; starIndex < endIndex; starIndex++,endIndex--) {
11             T temp = arr[starIndex];
12             arr[starIndex] = arr[endIndex];
13             arr[endIndex] = temp;
14         }
15         for (int i = 0; i < arr.length; i++) {
16             System.out.print(arr[i]);//返回结果：87654321
17         }
18     }
19 }
20 public class Demo18 {
21     public static void main(String[] args) {
22         MyArrays ma = new MyArrays();
23         Integer[] integer = {1,2,3,4,5,6,7,8};
24         ma.reverse(integer);
25     }
26 }

实例2

 1 package com.dhb.collection;
 2 
 3 /**
 4  * @author DSHORE / 2018-5-25
 5  *
 6  */
 7 //元素的反转
 8 class MyArrays<T>{//在类上，自定义泛型
 9     public  void reverse(T[] arr) {
10         for (int starIndex = 0,endIndex = arr.length-1; starIndex < endIndex; starIndex++,endIndex--) {
11             T temp = arr[starIndex];
12             arr[starIndex] = arr[endIndex];
13             arr[endIndex] = temp;
14         }
15         /*for (int i = 0; i < arr.length; i++) {
16             System.out.print(arr[i]);//返回结果：87654321
17         }*/
18     }
19     public String toString(T[] arr) {//自定义 输出格式
20         StringBuilder sb =new StringBuilder();
21         for (int i = 0; i < arr.length; i++) {//第一个元素
22             if(i == 0){
23                 sb.append("["+arr[i]+",");
24             }else if(i == arr.length-1){//最后一个元素
25                 sb.append(arr[i]+"]");
26             }else{//中间的元素
27                 sb.append(arr[i]+",");
28             }
29         }
30         return sb.toString();
31     }
32 }
33 public class Demo18 {
34     public static void main(String[] args) {
35         MyArrays<Integer> ma = new MyArrays<Integer>();
36         Integer[] in = {1,2,3,4,5,6,7,8};
37         ma.reverse(in);
38         System.out.println(ma.toString(in));//返回结果：[8,7,6,5,4,3,2,1]
39     }
40 }

6、在接口类上自定义泛型

格式:
     interface 接口名<声明自定义泛型>{

    }

6.1、泛型接口需要注意的事项

    1.在接口上自定义的泛型，具体数据类型是在实现接口的时候指定的。
    2.在接口上自定义的泛型，具体数据类型在实现接口时没有指定，那么默认问哦Object类型。
    3.如果需要在创建接口实现类对象的时候才指定自定义泛型，那么需要一下格式：class<T> 类名 implements 接口<T>{    }

6.2、如果延长接口的自定义泛型的数据类型,那么格式如下

格式:
    public class Demo4<t> implements Dao<t>{//t：声明自定义泛型

    }

实例

 1 interface Dao<T>{
 2     public void add(T t);
 3     public void update(T t);
 4 }
 5 public class Demo4<T> implements Dao<T>{
 6     public static void main(String[] args) {
 7         Demo4<String> d=new Demo4<String>();
 8     }
 9     @Override
10     public void add(T t) {
11         // TODO Auto-generated method stub
12     }
13     @Override
14     public void update(T t) {
15         // TODO Auto-generated method stub
16     }
17 }

7、泛型的上下限

? super Integer 允许是Integer类型或者是Integer父类的类型泛型的下限
? extends Number 允许是Number类型或者Number子类的数据类型泛型的上限

 1 package com.dhb.collection;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 
 6 /**
 7  * @author DSHORE / 2018-5-25
 8  *
 9  */
10 /* 泛型的上下限
11  * 
12  * 需求1：定义一个函数可以接收任意类型的集合对象，要求接收的集合对象只能存储Integer或者是Integer的父类类型的数据
13  * 需求2：定义一个函数可以接收任意类型的集合对象，要求接收的集合对象只能存储Number或者是Number的子类类型的数据
14  * 
15  * 泛型中的通配符：?
16  *     <? super Integer>：只能存储Interger或者是Interger的父类元素.   泛型的下限
17  *     <? extends Number>：只能存储Number或者Number以下的子类元素.   泛型的上限
18  * */
19 public class Demo19 {
20     public static void main(String[] args) {
21         //泛型的上线
22         ArrayList<Double> list = new ArrayList<Double>();//Number最大，所以<>里的泛型是子类的什么类型都行（上线，看关键字extends）
23         getDate(list);
24         //泛型的下线
25         ArrayList<Integer> list1 = new ArrayList<Integer>();//要看super后面的类型确定当前泛型的类型（下线，看关键字super）
26         print(list1);
27     }
28     //泛型的上线
29     public static void getDate(Collection<? extends Number> c){//Number或者以下的都可以
30 
31     }
32     //泛型的下线
33     public static void print(Collection<? super Integer> c){//Interger或者以上的都可以
34         
35     }
36 }

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：https://www.cnblogs.com/dshore123/p/9090210.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的推荐，或评论，谢谢！）