一、什么是泛型
泛型程序设计（generic programming）是程序设计语言的一种风格或范式。泛型允许程序员在强类型程序设计语言中编写代码时使用一些以后才指定的类型，在实例化时作为参数指明这些类型。
二、为什么要使用泛型
例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。
要求: x和y的值可以都是整数类型。
x和y的值可以都是小数类型。
x和y的值可以都是字符串类型。
对于这个例子我们最开始想到的就是利用Object类去解决，因为输入的类型不唯一，并且Object是所有类的父类，这样一来我们就可以解决这个问题。代码如下：
Point类
public class Point {
//x坐标
private Object x;
//y坐标
private Object y;
//输出坐标的值
public void show(){
System.out.println("x:"+x+",y:"+y);
}
public Point() {
}
public Point(Object x, Object y) {
this.x = x;
this.y = y;
}
public Object getX() {
return x;
}
public void setX(Object x) {
this.x = x;
}
public Object getY() {
return y;
}
public void setY(Object y) {
this.y = y;
}
}测试类：
public class Test {
public static void main(String[] args) {
Point p1=new Point(10,20);//坐标为整数int
p1.show();
Point p2=new Point(25.5,36.6);//坐标为小数
p2.show();
Point p3=new Point("东经180度","北纬25度");//坐标为字符串
p3.show();
}
}但是，当我们为这个坐标赋值时，我们给x、y的类型不一样，例如x为int类型，y为String类型，这样的情况下，程序依然时不报错的。但这样就违背了我们最初的要求，这样就产生了数据类型安全问题。所以我们引入了泛型来解决问题。
三、如何定义泛型
泛型可以定义在类上，接口上，方法上。 泛型类，泛型接口以及泛型方法。
泛型可以解决数据类型的安全性问题，主要原理是在类声明时通过一个标识，来表示类中某个属性的数据类型或者是某个方法的返回值及参数类型。这样在类声明或者实例化时只要指定好需要的类型就可以规定某个方法，某个属性的数据类型，这样在赋值或是使用方法时，从根本上避免数据类型安全问题。
语法：
public class 类名<泛型标志,泛型标志....>{
//类成员
}
这样上面的类就可以修改为：
public class Point<T> {
//x坐标----
private T x;
//y坐标
private T y;
//输出坐标的值
public void show(){
System.out.println("x:"+x+",y坐标:"+y);
}
public Point() {
}
public Point(T x, T y) {
this.x = x;
this.y = y;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}测试类：
public class Test {
public static void main(String[] args) {
Point<Integer> p1=new Point<Integer>(10,20);//坐标为整数int
p1.show();
Point<Double> p2=new Point<Double>(25.5,36.6);//坐标为小数
p2.show();
Point<String> p3=new Point<String>("东经180度","北纬25度");//坐标为字符串
p3.show();
}
}注意：上面使用到的泛型，都必须是引用类型。不能是基本类型。
四、泛型通配符
在实际开发中， 对象的引用传递是非常常见的，要注意的是，在泛型的操作中，在进行引用传递时，必须保证泛型类型一致才可以传递，否则时无法传递的。如果在传递时不想指定泛型，可以用泛型通配符代替。 泛型通配符为 ： ？
public class Info<T> {
private T val;
public Info() {
}
public void show(){
System.out.println(val);
}
public T getVal() {
return val;
}
public void setVal(T val) {
this.val = val;
}
}测试类：
public static void main(String[] args) {
Info<Integer> i=new Info<>();
i.setVar(250);
fun(i);
Info<String> i2=new Info<>();
i2.setVar("张三");
fun(i2); //如果为泛型类型:不但要求数据类型相同之外还要求泛型类型也匹配。
Info<Double> i3=new Info<>();
i3.setVar(3.14);
fun(i3);
}
//该方法的参数为Info而且它的泛型为Integer类型
public static void fun(Info<?> info){//通配符？
info.show();
}五、受限类型
在引用传递中，在泛型操作中也可以设置一个泛型对象的范围上限和范围下限。
范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类。
范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。
语法：
[设置上限]
声明对象: 类名称<? extends 类> 对象名称;
定义类: [访问权限] 类名称<泛型标识 extends 类>{}[设置下限]
声明对象: 类名称<? super 类> 对象名称;
定义类: [访问权限] 类名称<泛型标识 super 类>{}
public class Info<T> {
private T val;
public Info() {
}
public void show(){
System.out.println(val);
}
public T getVal() {
return val;
}
public void setVal(T val) {
this.val = val;
}
}测试类：
public class Test {
public static void main(String[] args) {
Info<Number> i =new Info<>();
i.setVal(23);
fun(i);
Info<Number> i2 =new Info<>();
i2.setVal(12);
fun(i2);
}
public static void fun(Info<? extends Number> info){
info.show();
}
public static void fun2(Info<? super Integer> info){
info.show();
}
}六、泛型接口
上面的使用都是对与类的使用，在jdk1.5之后，泛型也可以定义在接口上，定义方法与泛型类方法类似。
语法：
public interface 接口名<泛型标志,泛型标志....>{
//静态常量
//抽象方法。
}public interface Behavior<T> {
void eat(T t);
}public class Person<T> implements Behavior<T> {
@Override
public void eat(T t) {
System.out.println("今天吃的是:"+t);
}
}public class Test {
public static void main(String[] args) {
Behavior<String> p1 = new Person<>();
p1.eat("宫保鸡丁盖浇饭");
}
}七、泛型方法
泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。
泛型方法的定义：
[访问权限] ==<泛型标识>== 泛型标识 方法名称(泛型标识 参数名称)
public class Test {
public static void main(String[] args) {
String hello = Student.fun("你好！！");
Integer fun = Student.fun(123);
Double fun1 = Student.fun(3.1415);
}
}
class Student{
//泛型方法: static静态成员，随着类的加载而被加载到JVM内存中。常量池
public static <T> T fun(T t){
return t;
}
}
