泛型：定义阶段不明确具体类型，产生对象时明确具体类型。

//Object是Java中的最高参数统一化，能够接受所有的引用类型；
//有了包装类的自动拆装箱之后，Object还能够接收基本类型数值（自动装箱）
public class Pointer {
    private Object x;
    private Object y;
    public void setX(Object x) {
        this.x = x;
    }
    public void setY(Object y) {
        this.y = y;
    }
    public Object getX() {
        return x;
    }
    public Object getY() {
        return y;
    }

    public static void main(String[] args) {
        //此时x和y都由用户进行输入
        //第一组为整型
        Pointer p1=new Pointer();
        p1.setX(10);
        p1.setY(20);
        System.out.println("x="+p1.getX()+",y="+p1.getY());
        //第二组为字符串
        Pointer p2=new Pointer();
        p2.setX("东经108度");
        p2.setY("北纬18度");
        System.out.println("x="+p2.getX()+",y="+p2.getY());
        //第三种情况：用户进行输入
        //编译阶段不会出现问题，但是运行期间会报错
        //错误原因：由于用户的异常输入，导致程序类型转换异常，当出现异常后，程序就退出了。
        Pointer p3=new Pointer();
        p3.setX(10);
        p3.setY("北纬100度");
        int x=(int)p3.getX();
        int y=(int)p3.getY();
        System.out.println("x="+x+",y="+y);
    }
}

针对于某些需要多种类型的输入的情况，一般大家会想到采用Object进行变量类型定义，但是这种定义变量的方式会存在以下问题：

Object虽然可以接收所有的类型，但是Object转为其他类型都需要进行强制类型转换，只要是强转都有类型出错的风险，调用getX和getY方法时，需要根据具体的类型，将Object强转为具体的子类（隐藏的风险，此风险会发生在运行期间）。

因此，需要有新的机制，可以在定义类时，成员变量可以接收多种类型，但是在具体产生对象时明确类型，当有不同类型设置时，编译阶段就能发现错误。

JDK1.5引入的泛型机制。所谓的泛型，就是在定义类或方法时，没有明确参数的类型，而是在使用该类时，明确类型。不需要进行类型强转，编译阶段就会在语法阶段检查类型是否匹配的机制。

将泛型比作为类型编译阶段守门员，不会让类型不匹配的问题进入到运行阶段。

1. 泛型类的使用

（1）语法

类名称 <类型参数> {  //类型参数用大写英文字母来代替，任何一个都可以

类型参数  成员变量名称；

...

}

泛型类的使用示例：

public class Point<T> {
    private T x;
    private T y;
    public void setX(T x) {this.x = x;}
    public void setY(T y) {this.y = y;}
    public T getX() {return x;}
    public T getY() {return y;}
}

由于此时变量具体类型未知，因此，此处的T只是一个指代，写什么都行。一般采用大写的单个字母定义。

此处x和y的类型未知，但是可以保证它们是同一个类型，因为使用了相同的类型参数T。

（2）根据泛型类，产生泛型对象

泛型类在定义时，可以不明确成员变量的类型，但是在产生对象时，必须明确类型。

public static void main(String[] args) {
        //产生泛型类对象
        //此时产生的是Integer类型的Point对象，此时的x和y就会被定义为整型
        Point<Integer> point=new Point<>();
        //此处不需要进行强制类型转换，且能够在编译阶段检查设置类型是否满足要求（编译阶段就会报错，不会在运行期间出错）
        int x= point.getX();
        int y= point.getY();
    }

此处不需要进行强制类型转换，且能够在编译阶段检查设置类型是否满足要求（如果出错，编译阶段就会报错，不会在运行期间出错）。

（3）泛型类使用多个类型参数

泛型类名称<类型参数1，类型参数2，....>{

        类型参数1 变量x;

        类型参数2 变量y;

        //.....

}

 定义：一般使用多个大写字母来定义类型参数

• T=>一般指代任何类均可
• E=>一般代表元素Element和T意义差不多，也有使用E来指代异常的意思

K和V一般搭配使用，描述一个键值对的对象。

• K=>key的意思，不重复的键值
• V=>value的意思，可以重复

public class NewPoint<T,E> {
    private T x;
    private E y;
    public T getX() { return x; }
    public void setX(T x) { this.x = x;}
    public E getY() {return y;}
    public void setY(E y) {this.y = y;}
}

 产生对象：x和y的类型可以相同，也可以不同

 public static void main(String[] args) {
        NewPoint<Integer,String> newpoint=new NewPoint<>();
        newpoint.set
    }

 2. 泛型方法

 泛型不仅可以定义一个类，也可以单独定义方法。

（1）语法

权限修饰符<类型参数> 方法返回值类型 方法名称（类型参数  形参名称）{

        .......

}

泛型方法以自己的类型参数为准，为了区分和泛型类的类型参数，一般若泛型类中存在泛型方法，使用不同的类型参数。（E代表类型不一样）

当泛型类和泛型方法共存时， 泛型方法始终以自己的类型参数为准。

3. 泛型的注意点

• 泛型只能用在成员域，不能用在静态域（static修饰的内容不能使用泛型）

• 产生泛型对象时，具体的类型不能使用基本数据类型，要用基本类型的话统一使用包装类

• 不能直接创建和实例化泛型数组，要使用泛型数组，统一使用Object数组

这三个问题的本质在于泛型只存在于编译阶段，运行阶段没有泛型（类型擦除）

4. 泛型的类型擦除问题

类型擦除：泛型信息只存在于编译阶段，在进入JVM之前，与泛型有关的所有信息会被编译器擦除掉，专业术语称为“类型擦除”。

运行阶段没有任何与泛型相关的信息。

利用反射进行观察：

 泛型只存在于程序的编译阶段，当javac将代码编译为class文件之后，与泛型相关的所有信息全部被擦除掉了。

• 一般的泛型都会擦除为Object类型；
• 若存在泛型上限，擦除为对应的泛型上限。

5. 泛型数组的正确定义