Java高级--泛型

于 2022-07-19 10:33:18 发布
阅读量115 收藏
点赞数
文章标签： java servlet 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59114219/article/details/125865113
版权

1.什么是泛型

我们之前使用过集合时就用过泛型List<T>

创建一个 List<Student> list = new ArrayList();

<T>就是泛型

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

2.为什么使用泛型

列: 定义一个Point点类，该类中属性有x，y坐标

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

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

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

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

package com.lmy.demo01;

public class Demo01 {
    //x坐标
    private Object x;
    //y坐标
    private  Object y;
    //输出坐标的之值
    public void  show(){
        System.out.println("x==============="+x+";y=============="+y);
    }

    public Demo01() {
    }

    public Demo01(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.lmy.demo01;

public class Test01 {
    public static void main(String[] args) {
        //坐标为整数int--自动装箱--Integer----Object(向上转型)
        Demo01 d1 = new Demo01(10,20);
        d1.show();
        //坐标位小数
        Demo01 d2  = new Demo01(10.5,20.5);
        d2.show();
        //坐标为字符串
        Demo01 d3 = new Demo01("东经150度","北纬230度");
        d3.show();
        //xy类型不同也不会报错,但是它违背了设计的要求,涉及到数据类型安全问题
        Demo01 d4 = new Demo01(150,"北纬230度");
        d4.show();
    }
}

注意：以上代码d4虽然不报错但是违背了数据类型安全问题，此时我们可以通过泛型来解决

package com.lmy.demo02;

public class Demo02<T> {
    //x坐标
    private T x;
    //y坐标
    private  T y;
    //输出坐标的之值
    public void  show(){
        System.out.println("x==============="+x+";y=============="+y);
    }

    public Demo02() {
    }

    public Demo02(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;
    }
}

测试

package com.lmy.demo02;

public class Test02 {
    public static void main(String[] args) {
        //坐标为整数int--自动装箱->Integer--->Object(向上转型)
        Demo02<Integer> d1 = new Demo02<Integer>(10,20);
        d1.show();
        //坐标为小数
        Demo02<Double> d2 = new Demo02<Double>(10.5,20.5);
        d2.show();
        //坐标为字符串
        Demo02<String> d3 =new Demo02<String>("东经100度","北纬230度");
        d3.show();
    }
}

注意：上边的泛型类型必须是引用类型，不能是基本类型

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

3.如何定义泛型

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

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

格式：

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

                类成员

}

 

package com.lmy.demo03;

public class Demo03<T> {
    //T标志可以随意起名 如果使用多个泛型  那么在创建对象时必须为每个泛型指定数据类型
    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 com.lmy.demo03;

public class Test03 {
    public static void main(String[] args) {
        Demo03<String> d1 = new Demo03<String>();
        d1.setVar("hello world");
        d1.show();

        Demo03<Integer> d2 = new Demo03<Integer>();
        d2.setVar(15);
        d2.show();
        //如果没有指定泛型类型那就默认为Object
        Demo03 d3 = new Demo03();
        d3.setVar("你好你好");
        d3.show();
        //如果想使用真正的类型接收 那就必须强转
        String var = (String) d3.getVar();
        System.out.println(var);


    }
}

4.通配符

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

package com.lmy.demo04;

public class Demo04<T> {

    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 com.lmy.demo04;

public class Test04 {
    public static void main(String[] args) {
        Demo04<Integer> d1 = new Demo04<>();
        d1.setVar(100);
        fun(d1);

     /*
          Demo04<String> d2 = new Demo04<>();
          d2.setVar("烩面");
          fun(d2);报错 如果为泛型类型不但要求数据类型相同还要泛型类型相同
        */
        //可以使用?通配符接受任意类型
        Demo04<String> d2 = new Demo04<>();
        d2.setVar("烩面");
        fun(d2);

        Demo04<Double> d3 = new Demo04<>();
        d3.setVar(123.123);
        fun(d3);
    }
    
/*
    该方法的参数为Demo04泛型类型为Integer
    public static void fun(Demo04<Integer> d) {
        d.show();
*/
    public static void fun(Demo04<?> d) {
        d.show();
    }
}

5.受限泛型

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

语法

【设置上限】

声明对象:类名称<? extends 类> 对象名称;

定义类:[访问权限] 类名称<泛型标识 extends 类>{}

【设置下限】

声明对象:类名称<? super 类>对象名称;

定义类:[访问权限] 类名称<泛型标识 super 类>{}

package com.lmy.demo05;

public class Demo05<T> {
    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 com.lmy.demo05;

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

        Demo05<Number> d1 = new Demo05<>();
        fun(d1);
        fun2(d1);

        Demo05<Object> d2 = new Demo05<>();
        //fun(d2); Object为Number的父类
        fun2(d2);

        Demo05<Integer> d3 = new Demo05<>();
        fun(d3);
        //fun2(d3); Integer为Number的子类

    }

    //传递的参数类型必须为Number或者Number的子类
    public static void fun(Demo05<? extends  Number> d) {
        d.show();
    }
    //只能传递Number或者Number的父类
    public  static  void  fun2(Demo05<? super Number> d){
        d.show();
    }

}

6.泛型接口

上面那些例子都是使用泛型类。

而在jdk1.5以后，泛型也可以定义在接口上了，定义接口的泛型和定义泛型类语法相似。

语法

public inerface 接口名<泛型标志,泛型标志...>{

        //静态常量

        //抽象方法

}

类如何实现泛型接口:

package com.lmy.demo06;

public interface Usb<T> {
    //常量的命名必须全大写
    public static final String NAME="";
    T fun();//抽象方法

    //子类在实现接口时要确定泛型类型
    class Upan implements Usb<String>{
        @Override
        public String fun(){
            return "hello world";
        }
    }
    //子类实现和父类相同的泛型
    class Mouse<T> implements Usb<T>{
        @Override
        public T fun(){
            return null;
        }
    }

        /*
            JDK1.8新增
            default void  fun02(){

            }
            static void fun03(){

            }
        */
}

 测试类

package com.lmy.demo06;

public class Test06 {
    public static void main(String[] args) {
        Usb.Upan u = new Usb.Upan();

        Usb.Mouse<Integer> m = new Usb.Mouse();
    }
}

7. 泛型方法

前面学习的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。

【语法】

【泛型方法的简单定义】

[访问权限] ==<泛型标识>== 泛型标识 方法名称(泛型标识 参数名称)


public class Student {
    //泛型方法  static静态成员 随着类的加载加载到JVM内存中
    public static <T> T fun(T t){
        return t;
    }
}

测试类

package com.lmy.demo07;

public class Test07 {
    public static void main(String[] args) {
        //根据输入的内容自动确定类型
        String hello = Student.fun("hello");
        Integer fun = Student.fun(100);
        Double fun1 = Student.fun(100.123);
    }
}

L向上z
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值