泛型

什么叫泛型？

所谓的泛型就是允许我们在定义类、接口、方法时使用类型形参，这个类型形参将在声明变量、创建对象、调用方法时动态地指定（即传入实际的类型参数，也可称为类型实参）。

 

我们为什么要使用泛型呢？

因为Java集合对元素类型没有任何限制，这样可能引发一些问题。比如我们想创建一个只能保存Tiger对象的集合，但是程序也可以轻易地将Cat对象“丢”进去，所以可能会引发异常。

我们来看个例子

public class ListErr
{
   public static void main(String[] args)
   {
        //创建只想保存字符串的List集合
        List strList = new ArrayList();
        strList.add(“这是一只老虎”);
        strList.add(“这是一只猫”);
        //“不小心”把一个Integer对象“丢进了集合里”
        strList.add(5); //1
        strList.forEach(str->System.out.println(((String)str).length())); //2
  }
} 

我们在1处要是不小心把一个Integer对象“丢进”了List集合中，在2处程序就会引发ClassCastException异常，因为程序试图把一个Integer对象转换为String类型。

 

这个时候泛型就可以派上用场啦！让我们来用泛型改进这个程序

public class GenericList
{
     public static void main(String[] args)
    {
         //创建一个只想保存字符串的List集合
         List<String> strList = new ArrayList<String>(); //1
         strList.add(“这是一只老虎”);
         strList.add(“这是一只猫”);
         //下面代码将引起编译错误
         strList.add(5); //2
         strList.forEach(str->System.out.println(str.length())); //3

    }
}

在这里我们创建了一个特殊的List集合：strList，在这个集合里只能保存字符串对象，不能保存其他类型的对象。在2处程序会引发编译异常。在3处也不需要进行强制类型转换，因为strList对象可以“记住”它的所有集合元素都是String类型。

 

从这里我们也可以看出使用泛型的好处，它会让我们的代码更加健硕，能够避免我们把其他对象“丢进”strList集合中，程序会更加的简洁，集合会自动记住所有集合元素的数据类型，从而就无须对元素进行强制类型转换了。

泛型的“菱形”语法

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

public class DiamondTest
{
    public static void main(String[]  args)
   {
        //Java自动推断出ArrayList的<>里应该是String
        List<String> books = new ArrayList<>();
        books.add(“疯狂Java讲义”);
        books.add(“疯狂Android讲义”);
        //遍历books集合，集合元素就是String类型
        books.forEach(ele -> System.out.println(ele.length()));
       //Java自动推断出HashMap的<>里应该是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));
   }
}

当我们创建带泛型声明的自定义类，为该类定义构造器时，构造器名还是原来的类名，不要增加泛型声明。例如，我们为Apple<T>类定义构造器，其构造器名依然是Apple,而不是Apple<T>。

包含泛型声明的类型可以在定义变量、创建对象时传入一个类型实参，从而可以动态地生成无数多个逻辑上的子类，但这种子类在物理上并不存在。

我们可以为任何类、接口添加泛型声明

public class Cat<T>
{
//使用T类型形参定义实例变量
private T info;
public Cat(){}
//下面方法中使用T类型形参来定义构造器
public Cat(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
    Cat<String> a1 = new Cat<>(“猫”);
    System.out.println(a1.getInfo());
    //由于传给T形参的是Double，所以构造器参数只能是Double或double
    Cat<Double> a2 = new Cat<>(6.66);
    System.out.println(a2.getInfo());
}
}

当我们创建了一个带泛型声明的自定义类，为该类定义构造器时，构造器名还是原来的类名，不要增加泛型声明。像我们上面那个程序为Cat<T>类定义构造器，它的构造器名依然是Cat。在菱形语法中我们可以省略<>中的类型实参。

从泛型类派生子类

当创建了带泛型声明的接口、父类之后，可以为该接口创建实现类，或从该父类派生子类，需要注意的是，当使用这些接口、父类时不能再包含类型形参

//使用Cat类时为T形参传入String类型
public class A extends Cat<String>

并不存在泛型类

我们可以把ArrayLIst<String>类当成ArrayList的子类，ArrayLIst<String>类也确实像一种特殊的ArrayList类：该ArrayList<String>对象只能添加String对象作为集合元素。但实际上，系统并没有为ArrayList<String>生成新了class文件，而且也不会把ArrayList<String>当成新类来处理。

不管为泛型的类型形参传入哪一种类型实参，对于java来说，它们依然被当成同一个类来处理，在内存中也只占用一块内存空间，因此在静态方法、静态初始化块或者静态变量的声明和初始化中不允许使用类型形参。

好了关于泛型的一些知识，博主就先介绍到这了。