javaSE——泛型

一、泛型

1、定义

泛型：在Java 5以后，Java引入了“参数化类型”概念，允许程序在创建集合时指定集合元素的类型。比如List<String>，表明该List只能保存字符类型的对象，java的参数化类型称为泛型。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

import java.util.ArrayList;
import java.util.List;
public class List_text {
    public static void main(String[] args) {
    //创建一个只保存字符串的List集合
    List<String> strList = new ArrayList<String>();
    strList.add("语文");
    strList.add("英语");
   
    /*
     * 只能添加Strng类型对象，不能将Integer对象丢进集合
    strList.add(5);
    */
   
    strList.forEach(str->System.out.println(str.length()));
    }
}

2、菱形语法

java7以前如果使用带泛型的接口、类定义变量，那么调用构造器创建对象时构造器的后面也必须带泛型，比如：

List<String> strList = new ArrayList<String>();
Map<String,Integer> scores = new HashMap<String,Integer>();

    从Java7开始，允许需在构造器后不需要带完整的泛型信息，只需要给出一对尖括号（<>）即可，java可以推断出尖括号里是什么泛类型

List<String> strList = new ArrayList<>();
Map<String,Integer> scores = new HashMap<>();

    菱形语法：

package Text;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class List_text {
    public static void main(String[] args) {
    //创建一个只向保存字符串的List集合
    List<String> books = new ArrayList<>();
    books.add("语文");
    books.add("数学");
   
    //遍历books集合，集合元素就是String类型
    books.forEach(ele->System.out.println(ele.length()));
    //java自动推断出HaspMap的<>里应该是String,List<String>
    Map<String,List<String>>schoolsInfo = new  HashMap<>();
    //java自动推断出ArrayList的<>里应该是String
    List<String> schools = new ArrayList<>();
    schools.add("语文选修");
    schools.add("数学选修");
    schoolsInfo.put("英语", schools);
    //遍历Map时，Map的key是String类型，value是List<String>类型
    schoolsInfo.forEach((key,value)->System.out.println(key+"-->"+value));
    }
}

输出：

2

2

英语-->[语文选修, 数学选修]

二、泛型的使用

1、定义泛型类和接口

泛型类即在实例化类的时候指明泛型的具体类型。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

泛型类，是在实例化类的时候指明泛型的具体类型

public interface List<E>{
    //在该接口里，E可作为类型使用
    //下面方法可以使用E作为参数类型
    void add(E x);
    Iterator<E> iteraator();
    ……
}
//定义接口时指定了一个类型形参，该形参名为E
public interface Iterator<E>{
    //在该接口里E完全可以作为类型使用
    E next();
    boolean hasNext();
    ……
}
//定义该接口时指定了两个类型形参，其形参名为K,V
public interface Map<K,V>{
    //在该接口里K,V完全可以做类型使用
    Set<K> keySet()
    V put(K key,V values)
    ……
  }

定义一个带泛型声明的Apple<T>类，使用Apple<T>类时既可以为T类型形参传入实际类型，这样就可以生成Apple<String>、Apple<Double>……形式的的多个逻辑子类（物理上并不存在）

public class Apple<T>{
    //使用T类型形参定理实例变量
    private T info;
    public Apple() {}
        //下面方法中使用T类型形参类定义构造器
        public Apple(T info) {
             this.info = info;
        }
        public void setInfo(T info) {
             this.info = info;
        }
        public T getInfo() {
             return this.info;
        }
        public static void main(String[] args) {
             //由于传给T形参的是String，所以构造器参数只能是String
             Apple<String> a1 = new Apple<>("苹果");
             //由于传给T形参的是Double，所以构造器参数只能是Double或者double
             Apple<Double> a2 = new Apple<>(5.67);
             System.out.println(a2.getInfo());    
        }
}

2、定义泛型数组

在ArryBag类中，contnet实例变量被声明为“T[]”类型，白哦是泛型数组类型。ArryBag类的main()方法先创建了一个String类型的数组，再把它传给ArrayBag类的构造方法。但在泛型中不能通过T[] content = new T[10]来创建一个数组，也就是说只能声明泛型数组，不能创建泛型数组实例。

//这两种创建泛型数组的方法都是正确是
List<String>[] ls = new ArrayList[10];
List<?>[] ls = new ArrayList<?>[10];  
//此方法不可用于创建泛型数组
List<String>[] ls = new ArrayList<String>[10];  

代码：

public class ArrayBag<T>{
     //private T[] content = new T[10];
     private T[] content;
     
     public ArrayBag(T[] content) {
         this.content = content;
     }
         
     public T[] get() {
         return this.content;
     }
         
     public void set(T[] content) {
         this.content = content;
     }
     
     public static void main(String[] args) {
         String[] content = {"book1","book2","book3"};
         ArrayBag<String>bag=new  ArrayBag<String>(content);
         
         for(String c:bag.get())
              System.out.println(c);
     }
}

3、关键字

（1）、向上造型一个泛型对象的引用

在定义泛型时，可以用extends关键字来限定类型参数，语法为：

<T extends 类名>    //T必须是指定类或者其子类 
  或者：
<T extends 接口名>    //T必须是指定接口的实现类

由于对LimitBag类的类型参数‘’T‘’做了限定‘’<T extends Number>‘’，因此在main（）方法中，‘’LimitBag<List>‘’是非法的，因为List不是Number类的子类，不允许把它赋值给LimitBag的类型参数‘’T‘’。而‘’LimitBag<Integer>‘’是合法的，因为Integer是Number类的子类，可以把它赋值给LimitBag类的类型参数‘’T‘’

import java.util.*;
public class LimitBag<T extends Number>{
     private T content;
     public LimitBag(T content) {
         this.content = content;
     }
     
     public T get() {
         return this.content;
     }
     
     public void set(T content) {
         this.content = content;
     }
     
     public static void main(String[] args) {
         LimitBag<List>bag1 = new LimitBag<List>(new  ArrayList());    //编译出错
         LimitBag<Integer>bag2 = new  LimitBag<Integer>(12);      //编译合法
     }
}

（2）、向下造型一个泛型对象的引用

<? super T> 表示类型下界（Java Core中叫超类型限定），表示参数化类型是此类型的超类型（父类型），直至Object

三、类型通配符

1、使用类型通配符

为了表示各种泛型List的父类，可以使用类型通配符，类型通配符是一个问号（？），将一个问号作为类型实参传给List集合，写作：List<?>(意思是元素类型未知的List)。这个问号被称为通配符，他的元素类型可以匹配任何类型。

2、设定类型通配符的上限

使用List<?>这种形式，即表明这个List集合可以是任何泛型List的父类。但还有一种特殊的情形，我们不想这个List<?>是任何泛型List的父类，只想表示它是某一类泛型List的父类。 

3、设定类型形参的上限

Java泛型不仅允许在使用通配符形参时设定类型上限，也可以在定义类型形参时设定上限，用于表示创给该类型形参的实际类型必须是该上限类型，或是该上限类型的子类。

四、泛型方法

1、概念

在一个方法中，如果方法的参数或返回值的类型带有”<T>“形式的类型参数，那么这个方法称为泛型方法。在普通类或者泛型类中都可以定义泛型方法。泛型方法即在调用方法的时候指明泛型的具体类型 。

2、定义泛型方法

定义泛型方法语法格式如下：

调用泛型方法语法格式如下：

3、泛型方法和类型通配符的区别

?泛型对象是只读的，不可修改，因为?类型是不确定的，可以代表范围内任意类型；

而泛型方法中的泛型参数对象是可修改的，因为类型参数T是确定的（在调用方法时确定），因为T可以用范围内任意类型指定；

4、设置通配符下限

Java集合框架中的TreeSet<E>有一个构造器用到了这种设定通配符下限的语法，语法如下所示：

TreeSet(Comparator<? super E> c)