泛型的介绍

为什么使用泛型

早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

package com.UsuallyPractice.generic;

import java.util.ArrayList;

public class Generic_01 {
    public static void main(String[] args) {
        //测试一下泛型的经典案例
        ArrayList arrayList = new ArrayList();
        arrayList.add("helloWorld");
        arrayList.add("taiziyenezha");
        arrayList.add(88);//由于集合没有做任何限定，任何类型都可以给其中存放
        for (int i = 0; i < arrayList.size(); i++) {
            //需求：打印每个字符串的长度,就要把对象转成String类型
            String str = (String) arrayList.get(i);
            System.out.println(str.length());
        }
        //运行这段代码，程序在运行时发生了异常：
        //Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
        //发生了数据类型转换异常，这是为什么？

        //由于ArrayList可以存放任意类型的元素。例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，导致取出时强制转换为String类型后，引发了ClassCastException，因此程序崩溃了。

        //这显然不是我们所期望的，如果程序有潜在的错误，我们更期望在编译时被告知错误，而不是在运行时报异常。而为了解决类似这样的问题（在编译阶段就可以解决），在jdk1.5后，泛型应运而生。让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。

        //我们将第一行声明初始化ArrayList的代码更改一下，编译器就会在编译阶段就能够帮我们发现类似这样的问题。现在再看看效果。
        ArrayList<String> arrayList1 = new ArrayList<>();
        arrayList1.add("helloWorld");
        arrayList1.add("taiziyenezha");
        //arrayList.add(88);// 在编译阶段，编译器就会报错
        //这样可以避免了我们类型强转时出现异常
    }
}

#什么是泛型

泛型：是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，而这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
**注意：**一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

使用泛型的好处

1.避免了类型强制转换的麻烦

2.提供了编译期的类型安全，确保在泛型类型(通常为泛型集合)上只能使用正确类型的对象，避免了在运行时出现ClassCastException

泛型的使用

泛型虽然通常会被大量的使用在集合当中，但是泛型也不仅仅限于此处。泛型有三种使用方式，分别为：泛型类、泛型方法、泛型接口。将数据类型作为参数进行传递。

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种集合框架容器类，如：List、Set、Map

泛型类的定义格式：
修饰符 class 类名<代表泛型的变量> {  }
这里我还是做了一个简单的泛型类：
/**
 * @param <T> 这里解释下<T>中的T:
 *           此处的T可以随便写为任意标识，常见的有T、E等形式的参数表示泛型
 *           泛型在定义的时候不具体，使用的时候才变得具体。
 *           在使用的时候确定泛型的具体数据类型。即在创建对象的时候确定泛型。
 */
public class GenericsClassDemo<T> {
 //t这个成员变量的类型为T,T的类型由外部指定
 private T t;

 //泛型构造方法形参t的类型也为T，T的类型由外部指定
 public GenericsClassDemo(T t) {
 this.t = t;
    }

 //泛型方法getT的返回值类型为T，T的类型由外部指定
 public T getT() {
 return t;
    }
}
泛型在定义的时候不具体，使用的时候才变得具体。在使用的时候确定泛型的具体数据类型。即：在创建对象的时候确定泛型。

例如：Generic<String> genericString = new Generic<String>("helloGenerics");
此时，泛型标识T的类型就是String类型，那我们之前写的类就可以这么认为：
public class GenericsClassDemo<String> {
 private String t;

 public GenericsClassDemo(String t) {
 this.t = t;
    }

 public String getT() {
 return t;
    }
}
当你的泛型类型想变为Integer类型时，也是很方便的。直接在创建时，T写为Integer类型即可：
Generic<Integer> genericInteger = new Generic<Integer>(666);

注意： 定义的泛型类，就一定要传入泛型类型实参么？
并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。即跟之前的经典案例一样，没有写ArrayList的泛型类型，容易出现类型强转的问题

泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型

/*
定义格式：
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }
*/
/**
 *
 * @param t 传入泛型的参数
 * @param <T> 泛型的类型
 * @return T 返回值为T类型
 * 说明：
 *   1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *   2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *   3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *   4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E等形式的参数常用于表示泛型。
 */
package com.UsuallyPractice.generic;

class GenericMethod {
    //1.普通的泛型方法
    public <T> String commonMethod(String name,T t){
        String res = "";
        res += name +"-"+ t;
        System.out.println(t.getClass());
        System.out.println("普通泛型方法 ： "+res);
        return res;
    }
}
public class GenericMethodApplication {
    public static void main(String[] args) {
        //1.调用普通泛型方法
        GenericMethod genericMethod = new GenericMethod();
        String commonRes01 = genericMethod.commonMethod("001", "bb");
        System.out.println(commonRes01);
        String commonRes02 = genericMethod.commonMethod("002", 100);
        System.out.println(commonRes02);
        String commonRes03 = genericMethod.commonMethod("003", true);
        System.out.println(commonRes03);
        System.out.println("==================");
    }
}
//这里我们可以看下结果:
/*
class java.lang.String
普通泛型方法 ： 001-bb
001-bb
class java.lang.Integer
普通泛型方法 ： 002-100
002-100
class java.lang.Boolean
普通泛型方法 ： 003-true
003-true
==================
这里可以看出，泛型方法随着我们的传入参数类型不同，他得到的类型也不同。泛型方法能使方法独立于类而产生变化。
*/

泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中

###使用方式

####定义类时确定泛型的类型

/*
定义格式
修饰符 interface接口名<代表泛型的变量> {  }
*/
/**
 * 定义一个泛型接口
 */
public interface GenericsInteface<T> {
 public abstract void add(T t); 
}

public class GenericsImp implements GenericsInteface<String> {
 @Override
 public void add(String s) {
 System.out.println("设置了泛型为String类型");
    }
}

始终不确定泛型的类型，直到创建对象时，确定泛型的类型

public interface GenericsInteface<T> {
 public abstract void add(T t); 
}
public class GenericsImp<T> implements GenericsInteface<T> {
 @Override
 public void add(T t) {
 	System.out.println("没有设置类型");
    }
}

//确定泛型：
public class GenericsTest {
 public static void main(String[] args) {
 GenericsImp<Integer> gi = new GenericsImp<>();
 gi.add(66);
    }
}

泛型通配符

基本用法

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用

// ？代表可以接收任意类型
// 泛型不存在继承、多态关系,泛型左右两边要一样
//ArrayList<Object> list = new ArrayList<String>();这种是错误的

//泛型通配符?:左边写<?> 右边的泛型可以是任意类型
ArrayList<?> list1 = new ArrayList<Object>();
ArrayList<?> list2 = new ArrayList<String>();
ArrayList<?> list3 = new ArrayList<Integer>();

注意：泛型不存在继承、多态关系,泛型左右两边要一样，jdk1.7后右边的泛型可以省略，所以Collection list = new ArrayList();这是一种错误的写法

受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以，但是java的泛型当中还可以指定一个的泛型的上限和下限
泛型的上限

格式：类型名称<? extends 类型>对象名称
意义：只能接受该类型及其子类

泛型的下限
格式：类型名称<? super 类名>对象名
意义：只能接收该类类型及其父类类型
比如说：已知的顶级父类的Object，String类，Number类，Integer，其中Number类是Integer的父类

/*
 * 泛型的上限限定： ? extends E 代表使用的泛型只能是E类型或者是E类型的子类
 * 泛型的下线限定   ? super   E 代表使用的泛型只能是E类型或者E类型的父类类型
 */
/*
 * 类与类之间的继承关系
 * Integer extends Number extends Object
 */
public static void main(String[] args){
   	Collection<Integer> list01 = new ArrayList<>();
    Collection<String> list02 = new ArrayList<>();
    Collection<Number> list03 = new ArrayList<>();
    Collection<Object> list04 = new ArrayList<>();
        //调用方法getElement1();可以接收Number的子类
        getElement1(list01);
        //getElement1(list02);//不可以接收与number无关的类
        getElement1(list03);
        //getElement1(list04);//不可以接收number的父类类型
		//getElement2(list01);//不可以接收Number的子类类型Integer
		//getElement2(list02);//不可以接收和Number无关的类型
		getElement2(list03);//可以接收自己的本身类型
		getElement2(list04);//可以接受number的父类类型
}
 //定义使用泛型的上限 只能接受Number数字类及其子类
    public static void getElement1(Collection<? extends Number> coll){  }
    //定义使用泛型的下限，只能接收Number数字类型及其父类类型
    public static void getElement2(Collection<? super Number> coll){  }