java高级篇--泛型

一.什么是泛型?

其实在我们再使用集合时就用过泛型List

创建一个List对象List list=new ArrayList();

这个它就是泛型。

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

二. 为什么使用泛型?

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

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

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

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

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

这时我们会想到用Object类 --- 所有的父类

package com.xzh.demo01;

public class Point {
    private Object x;
    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 com.xzh.demo01;

public class Test01 {
    public static void main(String[] args) {
        //坐标为整数int--自动装箱为Integer类型 --->Object(向上转型)
        Point point = new Point(10, 20);
        point.show();
        //坐标为小数
        Point point1 = new Point(25.2, 23.2);
        point1.show();
        //坐标为字符串
        Point point2 = new Point("北纬29°", "东经45度");
        point2.show();
    }
}

输出结果:

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

Point point3 = new Point(20, "123");
        point3.show();

 成功输出了

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

可以使用泛型来解决。

package com.xzh.demo02;

public class Point {
    private E x;
    private E y;

    //输出坐标值
    public void show(){
        System.out.println("x轴坐标:"+x+"y轴坐标:"+y);
    }

    public Point() {
    }

    public Point(E x, E y) {
        this.x = x;
        this.y = y;
    }

    public E getX() {
        return x;
    }

    public void setX(E x) {
        this.x = x;
    }

    public E getY() {
        return y;
    }

    public void setY(E y) {
        this.y = y;
    }
}

package com.xzh.demo02;

public class Test01 {
    public static void main(String[] args) {
        //坐标为整数int--自动装箱为Integer类型 --->Object(向上转型)
        Point point = new Point(10, 20);
        point.show();
        //坐标为小数
        Point point1 = new Point(25.2, 23.2);
        point1.show();
        //坐标为字符串
        Point point2 = new Point("北纬29°", "东经45度");
        point2.show();
    }
}

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

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

三. 如何定义泛型

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

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

 格式:

public class 类名<泛型标志,泛型标志....>{

     //类成员
}

package com.xzh.demo03;

public class Test01 {
    public static void main(String[] args) {
        info info = new info<>(10);
        info.show();

       info info1 = new info<>("hello");
       info1.show();

       //如果没有指定泛型的类型 则默认为object类型
       info info2 = new info();
       info2.setVar(23.2);

        //Object var = info2.getVar();//如果想使用真正的类型接受，那么必须进行强制
        Double var = (Double) info2.getVar();
        System.out.println(var);
    }
}
//E标志可以任意起名 A B C D T都可以----> 那么在创建对象时，必须为每个泛型指定数据类型。
class info{
    private E var;

    public void show(){
        System.out.println("var===="+var);
    }
    public info() {
    }

    public info(E var) {
        this.var = var;
    }

    public E getVar() {
        return var;
    }

    public void setVar(E var) {
        this.var = var;
    }
}

四. 通配符

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

package com.xzh.demo04;

public class Test01 {
    public static void main(String[] args) {

        info info = new info<>(10);
        fun(info);

       info info2 = new info<>("Hello");
       fun(info2);
    }
//    //该方法的参数为Info而且它的泛型为Integer类型
//    public static void fun(info info){
//        info.show();
//    }

    //能不能设置泛型类型可以接受任意的类型呢? 我们可以使用同配置?
        public static void fun(info info){
           info.show();
        }
    }

//E标志可以任意起名 A B C D T都可以----> 那么在创建对象时，必须为每个泛型指定数据类型。
class info{
    private E var;

    public void show(){
        System.out.println("var===="+var);
    }
    public info() {
    }

    public info(E var) {
        this.var = var;
    }

    public E getVar() {
        return var;
    }

    public void setVar(E var) {
        this.var = var;
    }
}

6. 受限泛型

        在引用传递中，在泛型操作中也可以设置一个泛型对象的==范围上限>>和范围下限<<

        范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，

        范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。

语法:

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

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

package com.xzh;

public class Test01 {
    public static void main(String[] args) {
        info i1 = new info<>(123.2);
        fun2(i1);


        info