JAVA基础知识点（十四）--泛型

一、泛型的用途

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

 泛型的好处：

      1. 将运行时的异常提前至了编译时。

      2. 避免了无谓的强制类型转换 。

泛型在集合中的常见应用：

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

      ArrayList<Object>  list = new ArrayList<String>();  false

      ArrayList<String>  list = new ArrayList<Object>();  false

      //以下两种写法主要是为了兼顾新老系统的兼用性问题。

   ArrayList<String>  list =new ArrayList();           true  

   ArrayList    list = newArrayList<String>();   true  

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

package cn.itcast.genrictiry;

import java.util.ArrayList;

public class Demo1 {

         publicstatic void main(String[] args) {

                  ArrayList<String>  list = new ArrayList<String>();  //<String> 表示该容器只能存储字符串类型 的数据。

                  list.add("aa");

                  list.add("bb");

                  list.add("cc");

                  for(inti = 0 ; i < list.size() ; i++){

                          Stringstr =  list.get(i);

                          System.out.println("大写："+str.toUpperCase());

                  }

                  MyUtil.print(list);

                  ArrayList<String>list2 = MyUtil.getList();

         }

}

二、自定义泛型

 需求： 定义一个方法可以接收任意类型的参数，而且返回值类型必须要与实参的类型一致。

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

 方法上自定义泛型：

        修饰符          <声明自定义的泛型>返回值类型    函数名(使用自定义泛型 ...){

        }

在泛型中不能使用基本数据类型，如果需要使用基本数据类型，那么就使用基本数据类型对应的包装类型。int----> Integer

方法泛型注意的事项：

        1. 在方法上自定义泛型，这个自定义泛型的具体数据类型是在调用该 方法的时候传入实参时确定具体的数据类型的。

        2. 自定义泛型只要符合标识符 的命名规则即可, 但是自定义泛型我们一般都习惯使用一个大写字母表示。  T Type  E Element

package cn.itcast.genrictiry;

public class Demo2 {

         publicstatic void main(String[] args) {

                  Stringstr = getData("abc");

                  Integeri = getData(123);

         }

         publicstatic <abc>abc getData(abc o){

                  returno;

         }

}

 

 

三、泛型类

需求：编写一个数组 的工具类

泛型类的定义格式

         class类名<声明自定义泛型>{

         }

泛型类要注意的事项：

        1. 在类上自定义泛型的具体数据类型是在使用该类的时候创建对象时候确定的。

        2. 如果一个类在类上已经声明了自定义泛型，如果使用该类创建对象 的时候没有指定 泛型的具体数据类型，那么默认为Object类型

        3.在类上自定义泛型不能作用于静态的方法，如果静态的方法需要使用自定义泛型，那么需要在方法上自己声明使用。

 package cn.itcast.genrictiry;

import java.util.ArrayList;

class MyArrays<T>{

         //元素翻转

         publicvoid reverse(T[] arr){

                  for(intstartIndex = 0, endIndex = arr.length-1 ; startIndex<endIndex ;startIndex++,endIndex--){

                          Ttemp  = arr[startIndex];

                          arr[startIndex]= arr[endIndex];

                          arr[endIndex]= temp;

                  }

         }

         //

         publicString toString(T[] arr){

                  StringBuildersb = new StringBuilder();

                  for(inti = 0 ; i < arr.length ; i++){

                          if(i==0){

                                   sb.append("["+arr[i]+",");

                          }elseif(i==arr.length-1){

                                   sb.append(arr[i]+"]");

                          }else{

                                   sb.append(arr[i]+",");

                          }

                  }

                  returnsb.toString();

         }

         publicstatic <T>void print(T[] t){

         }

}

public class Demo3 {

         publicstatic void main(String[] args) {

                  Integer[]arr = {10,12,14,19};

                  MyArrays<Integer>tool = new MyArrays<Integer>();

                  tool.reverse(arr);

                  System.out.println("数组的元素："+tool.toString(arr));

                  MyArrays<String>tool2 = new MyArrays<String>();

                  String[]arr2 = {"aaa","bbb","ccc"};

                  tool2.reverse(arr2);

                  ArrayList<String>list = new ArrayList<String>();

         }

}

 

 

 

四、泛型接口

泛型接口的定义格式:

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

         }

泛型接口要注意的事项：

         1.接口上自定义的泛型的具体数据类型是在实现一个接口的时候指定的。

         2.在接口上自定义的泛型如果在实现接口的时候没有指定具体的数据类型，那么默认为Object类型。

需求：目前我实现一个接口的时候，我还不明确我目前要操作的数据类型，我要等待创建接口实现类对象的时候我才能指定泛型的具体数据类型。

         如果要延长接口自定义泛型 的具体数据类型，那么格式如下：

         格式： 

                  publicclass Demo4<T> implements Dao<T>{

                  }

package cn.itcast.genrictiry;

interface Dao<T>{

         publicvoid add(T t);       

}

public class Demo4<T> implementsDao<T> {

         publicstatic void main(String[] args) {

                  Demo4<String>d = new Demo4<String>();

         }

         publicvoid add(T t){       

         }

}

 

 

 

五．泛型的上下限

需求1：定义一个函数可以接收接收任意类型的集合对象，要求接收的集合对象只能存储Integer或者是Integer的父类类型数据。

需求2：定义一个函数可以接收接收任意类型的集合对象，要求接收的集合对象只能存储Number或者是Number的子类类型数据。

泛型中通配符：？

         ?super Integer : 只能存储Integer或者是Integer父类元素。  泛型 的下限

        ? extends Number ： 只能存储Number或者是Number类型的子类数据。 泛型上限

package cn.itcast.genrictiry;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashSet;

public class Demo5 {

         publicstatic void main(String[] args) {

                  ArrayList<Integer>list1 = new ArrayList<Integer>();

                  ArrayList<Number>list2 = new ArrayList<Number>();

                 

                  HashSet<String>set = new HashSet<String>();

                  //getData(set);

         }

         //泛型的上限

         publicstatic void getData(Collection<? extends Number> c){

         }

         //泛型的下限

         publicstatic void print(Collection<? super Integer> c){

         }

}