JAVA泛型

最新推荐文章于 2024-07-15 22:27:12 发布

程序猿Ada

最新推荐文章于 2024-07-15 22:27:12 发布

阅读量589

点赞数 1

文章标签： java 开发语言 jvm

原文链接：https://blog.csdn.net/qq_53625788/article/details/125779739?spm=1001.2014.3001.5502

版权

正文：

什么是泛型?
为什么使用泛型?
如何使用泛型?
泛型类
泛型的通配符
泛型的上限和下限
泛型接口
泛型方法

1. 什么是泛型?

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

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

2. 为什么使用泛型?

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

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

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

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

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

package demo02;/*
 * @author     : wzl
 * @date       : 2022/7/13 18:45
 * @description: some description
 */
 
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 demo02;/*
 * @author     : wzl
 * @date       : 2022/7/13 18:47
 * @description: some description
 */
 
public class Test {
    public static void main(String[] args) {
        Point p1 = new Point(10,20);
        p1.show();
 
        Point p2 = new Point("东经10°","北纬30°");
        p2.show();
 
        Point p3 = new Point(20.2,30.2);
        p3.show();
    }
}

但是:如果我们为坐标一个赋值整数，一个赋值为字符串，这时会不会报错。
Point p4=new Point(25,“北纬50度”);
p4.show();

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

可以使用泛型来解决。

package demo01;/*
 * @author     : wzl
 * @date       : 2022/7/13 15:10
 * @description: some description
 */
 
/**
 * java高级-泛型
 * @param <T>
 */
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;
    }
}

测试：

package demo01;/*
 * @author     : wzl
 * @date       : 2022/7/13 15:11
 * @description: some description
 */
 
 
public class Test {
    public static void main(String[] args) {
        Point<Integer> p1 = new Point<Integer>(10,20);
        p1.show();
 
        Point<Double> p2 = new Point<Double>(20.3,30.5);
        p2.show();
 
    }
}

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

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

3. 如何使用泛型?

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

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

     //类成员
}

package demo03;/*
 * @author     : wzl
 * @date       : 2022/7/13 18:59
 * @description: some description
 */
 
public class Test03 {
    public static void main(String[] args) {
        Info<String> info = new Info<>();
        info.setVar("你好!");
        info.show();
 
 
 
        Info<Integer> info1 = new Info<>();
        info1.setVar(1211);
        info1.show();
 
        //如果没有指定泛型类默认为Object
        Info info2 = new Info<>();
        info2.setVar("还不休息？");
        //要是想用泛型接收 ，  那么必须进行强转
        String s = (String) info2.getVar();
        System.out.println(s);
 
 
    }
}
 
class Info<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;
    }
}

4. 泛型类

使用泛型，我们可以在不知道代码操作对象的类型的情况下编写代码。它允许我们创建泛型类，构造函数和方法。泛型类是使用形式类型参数定义的。形式类型参数是一个逗号分隔的变量名列表，位于类声明中类名后面的尖括号<>中。

5. 泛型的通配符

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

package demo04;/*
 * @author     : wzl
 * @date       : 2022/7/13 19:11
 * @description: some description
 */
 
/**
 * 通配符：
 * 在开发中对象的==引用传递==是最常见的，但是如果在泛型类的操作中，
 * 在进行==引用传递时泛型类型必须匹配才可以传递，否则是无法传递的==。
 * 如果想传递，可以定义泛型为?通配符
 */
public class Test04 {
    public static void main(String[] args) {
        Info<Integer> i = new Info<>();
        i.setVar(2222);
        fun(i);
 
        Info<String> i2 = new Info<>();
        i2.setVar("明天你好!");
        fun(i2);
 
        Info<Double> i3 = new Info<>();
        i3.setVar(200.333);
        fun(i3);
 
    }
 
    public static void fun(Info<?> info) {
        info.show();
    }
}
 
class Info<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;
    }
}

6. 泛型的上限和下限

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

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

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

package demo05;/*
 * @author     : wzl
 * @date       : 2022/7/13 19:38
 * @description: some description
 */
 
/**
 * 受限泛型：
 * [设置上限]
 * 声明对象: 类名称<? extends 类> 对象名称;
 * 定义类:  [访问权限] 类名称<泛型标识 extends 类>{}
 *
 * [设置下限]
 * 声明对象: 类名称<? super 类> 对象名称;
 * 定义类:  [访问权限] 类名称<泛型标识 super 类>{}
 *
 */
public class Test05 {
    public static void main(String[] args) {
        Info<Number> i = new Info<>();
        fun2(i);
        Info<Number> i2 = new Info<>();
        fun(i2);
        Info<Integer> i3 = new Info<>();
    }
 
    public static void fun(Info<? super Number> info) {
        info.show();
    }
 
    public static void fun2(Info<? extends Number> info) {
        info.show();
    }
}
//当创建该类对象时，泛型必须为Number的子类以及Number类型
class People<T extends Number>{
 
}
 
class Info<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;
    }
}

7. 泛型接口

上面那些例子都是使用泛型类。而在jdk1.5以后，泛型也可以定义在接口上了，定义接口的泛型和定义泛型类语法相似。

<br class="Apple-interchange-newline"><div></div>

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

         //静态常量

   //抽象方法。
}

实现类的接口：

package demo06;/*
 * @author     : wzl
 * @date       : 2022/7/13 20:05
 * @description: some description
 */
 
/**
 * 泛型接口：
 * public interface 接口名<泛型标志,泛型标志....>{
 *    //静态常量
 *    //抽象方法。
 * }
 */
public class Test06 {
    public static void main(String[] args) {
        Upan u = new Upan();
        Mouse<Integer> mouse = new Mouse<>();
        System.out.println(mouse);
    }
}
 
interface USB<T> {
    //常量的命名必须为大写   static 静态的
    public static final String NAME = "";
    //抽象方法
    T du();
}
//子类在实现接口时，确定泛型类型
class Upan implements USB<String>{
 
    @Override
    public String du() {
        return "你好呀！小明。";
    }
}
 
//子类也实现泛型和父类名相同的泛型
class Mouse<T> implements USB<T> {
 
    @Override
    public T du() {
        return null;
    }
}

8. 泛型方法

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

    【泛型方法的简单定义】

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

package demo07;/*
 * @author     : wzl
 * @date       : 2022/7/13 20:15
 * @description: some description
 */
 
/**
 * 泛型方法：
 * 【泛型方法的简单定义】
 *
 * [访问权限] ==<泛型标识>== 泛型标识  方法名称(泛型标识 参数名称)
 */
public class Test07 {
    public static void main(String[] args) {
        String pp = Student.fun("你好！小明");
        Integer fun = Student.fun(2220);
        Double fun2 = Student.fun(22.22);
        System.out.println("String是："+pp+"fun是:"+fun+"fun2是："+fun2);
    }
}
class Student{
    //泛型方法：static 静态成员，随着类的加载而被加载到JVM内存中 。 常量池
    public static <T> T fun(T t) {
        return t;
    }
}