java高级--泛型

1. 什么是泛型?
2. 为什么使用泛型?
3. 如何使用泛型?
4. 泛型类
5. 泛型的通配符
6. 泛型的上限和下限
7. 泛型接口
8. 泛型方法

其实我们再使用集合时就用过泛型List 创建一个List对象List list=new ArrayList();

它就是泛型。

所谓的泛型就是在类定义时,不为类中属性和方法指定数据类型，而是在类对象创建时为其指定相应的数据类型。

例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。

要求: x和y的值可以都是整数类型。

​ x和y的值可以都是小数类型。

​ x和y的值可以都是字符串类型。

如何定义该类呢? 如何确定属性的类型。----Object类型

package demo01;
​

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;
    }
}
​

package demo01;
​

public class Test {
    public static void main(String[] args) {
        Point p1=new Point(10,20);//坐标为整数int--自动装箱->Integer--->Object(向上转型)
        p1.show();
​
        Point p2=new Point(25.5,36.6);//坐标为小数
        p2.show();
​
        Point p3=new Point("东经180度","北纬25度");//坐标为字符串
        p3.show();
    }
}
​

但是:如果我们为坐标一个赋值整数，一个赋值为字符串，这时会不会报错。

Point p4=new Point(25,"北纬50度");
        p4.show();

但是它违背了我们设计的要求，这就是我们提到的数据类型安全问题。如何解决数据类型安全问题?

可以使用泛型来解决。

public class Point {
    //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;
    }
}
​

 Point p1=new Point(10,20);//坐标为整数int--自动装箱->Integer--->Object(向上转型)
        p1.show();
​
        Point p2=new Point(25.5,36.6);//坐标为小数
        p2.show();
​
        Point p3=new Point("东经180度","北纬25度");//坐标为字符串
        p3.show();

注意: 上面的泛型类型必须都是引用类型。不能是基本类型。

使用泛型就保证了数据类型安全问题。

泛型可以定义在类上，接口上，方法上。 泛型类，泛型接口以及泛型方法。

泛型可以解决数据类型的安全性问题，其主要原理是在类声明时通过一个==标识表示类中某个属性的数据类型或者是某个方法的返回值及参数类型==。这样在类声明或者实例化时只要指定好需要的类型即可。

格式:

public class 类名<泛型标志,泛型标志....>{
​
     //类成员
}

package demo03;
​

public class Test03 {
    public static void main(String[] args) {
        Info info=new Info<>();
        info.setVar("hello");
        info.show();
​
        Info info1=new Info<>();
        info1.setVar(15);
        info1.show();
​
        //如果没有指定泛型类型默认为Object,
        Info  info2=new Info();
        info2.setVar("杨坤想睡不?");
​
        String o = (String) info2.getVar();//如果想使用真正的类型接受，那么必须进行强制
        System.out.println(o);
​
    }
}
//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型。
class Info{
    private T var;
    public void show(){
        System.out.println("var========"+var);
    }
​
    public T getVar() {
        return var;
    }
​
    public void setVar(T var) {
        this.var = var;
    }
}
​

在开发中对象的==引用传递==是最常见的，但是如果在泛型类的操作中，在进行==引用传递时泛型类型必须匹配才可以传递，否则是无法传递的==。如果想传递，可以定义泛型为?通配符。

package demo04;
​

public class Test04 {
    public static void main(String[] args) {
            Info i=new Info<>();
            i.setVar(250);
            fun(i);
​
            Info i2=new Info<>();
            i2.setVar("haha");
            fun(i2); //如果为泛型类型:不但要求数据类型相同之外还要求泛型类型也匹配。
​
           Info i3=new Info<>();
           i3.setVar(25.5);
           fun(i3);
​
            //能不能设置泛型类型可以接受任意的类型呢? 我们可以使用同配置?
    }
​
    //该方法的参数为Info而且它的泛型为Integer类型
    public static void fun(Info info){
         info.show();
    }
}
​
//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型。
class Info{
    
    private T var;
    public void show(){
        System.out.println("var========"+var);
    }
​
    public T getVar() {
        return var;
    }
​
    public void setVar(T var) {
        this.var = var;
    }
}
​

在引用传递中，在泛型操作中也可以设置一个泛型对象的==范围上限==和==范围下限==。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。

语法:

[设置上限]
声明对象: 类名称 对象名称;
定义类:  [访问权限] 类名称<泛型标识 extends 类>{}
​
[设置下限]
声明对象: 类名称 对象名称;
定义类:  [访问权限] 类名称<泛型标识 super 类>{}

package demo5;
​

public class Test04 {
    public static void main(String[] args) {
         Info i=new Info<>();
         fun2(i);
​
         Info