泛型程序设计

最新推荐文章于 2024-07-13 13:55:40 发布
最新推荐文章于 2024-07-13 13:55:40 发布
阅读量186 收藏
点赞数
分类专栏： java 文章标签： java 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luzz243/article/details/77488124
版权

在Java的集合中我们运行程序时会出现下方警告代码

$ javac CollectionDemo.java -encoding utf8
注: CollectionDemo.java使用了未经检查或不安全的操作。
注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。

这是因为集合中可能会被存放类型不同的元素，这在编译时不会出错，但运行时可能会出现错误！可以在代码中使用注解@SuppressWarnings("unchecked")压制警告，但这终究不是一个好的方法，Java中可以使用泛型来解决这一问题！

在引入泛型之前，泛型程序设计都是用继承来实现的，必须要强制类型转换，并且可能会引发一些编译时发现不了的潜在问题。泛型可以很好的解决这些问题。

泛型类

首先看一下泛型类如何定义与使用：

代码示例

class Pair<T, U> {
    private T first;
    private U second;
    Pair() {
        first = null;
        second = null;
    }
    Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public void setFirst(T newValue) {
        first = newValue;
    }
    public void setSecond(U newValue) {
        second = newValue;
    }
    public T getFirst() {
        return first;
    }
    public U getSecond() {
        return second;
    }
    public static <T> T getSo(T some) {
        return (T)some.toString();
    }
}

public class NewGer {
    public static void main(String[] args) {
        Pair<String, Integer> pair = new Pair<String, Integer>("java", 123);
        Pair<Integer, Integer> pair1 = new Pair<Integer, Integer>(123, 456);
        System.out.println(pair.getFirst());
        System.out.println(pair.getSecond());
        System.out.println(pair1.getClass() == pair.getClass());
    }
}

输出结果：

java
123
true

代码说明

以下数字表示满足要求的代码所在行

  • 泛型可以有多个类型变量以满足不同需求 1
  • 类型变量可以指定方法的返回类型及域和局部变量的类型 2、3、19、22
  • 使用具体的类型替换类型变量可以实例化泛型类型 32、33
  • 范型的类型变量只能是类或接口，不能是简单类型(比如int、double等) 32、33
  • Java中无论泛型的类型参数传入哪一种类型实参，其运行的都是同一块内存空间中的同一个类 32、33->36

另外还有一些应该注意的问题：

  1. 静态方法、静态初始化块、静态变量的声明与初始化都不允许使用泛型类型形参
  2. Java中不存在真正的泛型类，因此instanceof运算符对泛型类不可用
  3. 即使类型参数是子父类(子父接口)的关系，其泛型也不是子父类(子父接口)之间的关系
import java.util.*;
public class NewClass<T> {
    // 1
    static T info;
    T age;
    void foo(T msg) {}
    public static void bar(T msg) {}
    // 2
    Collection<String> cs = new ArrayList<>();
    if (cs instanceof List<String>) {}
    // 3
    public void test(List<Object> c) {}
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();
        test(strList);
    }
}

泛型方法

普通泛型方法

class ArrayAlg {
    public static <T> T getMid(T... a) {
        return a[a.length / 2];
    }
}

public class ArrAnalog {
    public static void main(String[] args) {
        String mid = ArrayAlg.<String>getMid("hello", "java", "test");
        //等价于String mid = ArrayAlg.getMid("hello", "java", "test");
        System.out.println(mid);
    }
}

说明

  • 泛型方法可以放在泛型类中，也可以放在普通类中
  • 泛型方法的类型变量要放在修饰符后面
  • 编译器可以根据实参推断出泛型方法类型，<String>可以省略。因此第9行代码等价于第10行代码
  • 实参元素类型必须属于同一类，否则运行时会报错
  • T…代表着可变长度的类型为T的数组
  • 如果不需要返回值，请将第2行代码写成public static <T> void getMid(T... a) {

泛型构造器

class Test {
    public Test() {
    }
    public <T> Test(T t) {
        System.out.println(t);
    }
}
public class NewGericDemo {
    public static void main(String[] args) {
        new <String>Test("hello");
        new Test(123);
        //new <Integer>Test("hello");
    }
}

代码说明：

  • 泛型构造器的类型实参必须与构造器的类型变量相同，否则会引发异常

类型变量

类型变量习惯上使用大写字母且较短：

  • E：表示集合元素类型
  • K和V：表示关键字与值的类型
  • T(或者U、S)：表示任意类型
  • ?：表示通配符，可以是任意类型的元素
public static <T extends Comparable & Serializable> T func(List<? extends T> list)
  • 无论类型参数是接口还是类，限定时都使用extends关键字，因为这样更加贴近子类的概念
  • 一个类型变量或通配符可以同时限定多个接口或者类，使用&连接
  • 通配符的限定T称为是类型通配符的上限

设定类型通配符的上限

如果将列表src的元素全部传给dest列表，那么src的元素类型必须是dest元素类型的子类才能满足要求，这就要用到了元素类型的上限限定了。

代码示例

import java.util.*;
public class NewGericDemo {
    public static <T> void copy(List<T> dest, List<? extends T> src) {
      //列表src的元素属性必须是dest元素属性的子类，或子接口
        for (int i = 0; i < src.size() ; i++ ) {
            dest.add(src.get(i));
        }
    }
    public static void main(String[] args) {
        List<Number> list1 = new ArrayList<>();
        List<Double> list2 = new ArrayList<>();
        list2.add(1.5);
        list2.add(2.2);
        list2.add(3.3);
        copy(list1, list2);
        System.out.println(list1);
    }
}

代码说明：

列表src的元素属性必须是dest元素属性的子类，或子接口；dest中初始时不能存在与src元素类型不同的元素。

设定类型通配符的下限

上方代码还可以写成这样：

import java.util.*;
public class NewGericDemo {
    public static <T> void copy(List<? super T> dest, List<T> src) {
        for (int i = 0; i < src.size() ; i++ ) {
            dest.add(src.get(i));
        }
    }
    public static void main(String[] args) {
        List<Number> list1 = new ArrayList<>();
        List<Double> list2 = new ArrayList<>();
        list2.add(1.5);
        list2.add(2.2);
        list2.add(3.3);
        copy(list1, list2);
        System.out.println(list1);
    }
}

两者都能实现将src元素复制到dest中，此处使用的是设置类型通配符的下限，dest元素类型是src元素类型的父类或父接口，这和设置类型通配符的上限意思相同！

泛型代码

类型擦除与转换

因为JVM中没有泛型类型对象，因此泛型代码只会存活在编译时期，.class文件中只有相应的原始类型。原始类型就是删除类型参数后的泛型类型名。比如上方的Pair类去除泛型后成为下方代码

class Pair {
    private Object first;
    private Object second;
    public Pair(Object first, Object second) {
        this.first = first;
        this.second = second;
    }
    public Object getFirst() {
        return first;
    }
    public Object getSecond() {
        return second;
    }
    public void setFirst(Object newValue) {
        first = newValue;
    }
    public void setSecond(Object newValue) {
        second = newValue;
    }
}

说明

泛型转换成原始类型时使用第一个限定的类型变量来替换泛型的类型变量，如果没有显式的限定就用Object替换。

代码示例

public class Interval<T extends Comparable & Serializable> implements Serializable{
    private T lower;
    private T upper;
    public Interval(T first,T second){
    }
}

等价于

public class Interval implements Serializable{
    private Comparable lower;
    private Comparable upper;
    public Interval(Comparable first,Comparable second){
    }
}

另外，因为原始类型替换了泛型类型变量，所以应该使用原始类型来操作结果元素，而不是泛型的变量类型。

代码示例

class Num<T extends Number> {
    private T num;
    public Num() {
    }
    public Num(T num) {
        this.num = num;
    }
    public void setNum(T num) {
        this.num = num;
    }
    public T getNum() {
        return this.num;
    }
}
public class NewGericDemo1 {
    public static void main(String[] args) {
        Num<Integer> num = new Num<>(56);
        Integer int1 = num.getNum();

        Num num1 = new Num();
        num1 = num;
        System.out.println(int1);

        Number int2 = num1.getNum();
        // Integer int2 = num1.getNum();
        System.out.println(int2);
    }
}

上方代码中将泛型类转赋值给了普通类，调用元素时，应该使用Number。注释掉的元素将会导致异常：无法将Number类型转换成Integer类型。

suiyu21
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java泛型的应用
05-08
泛型的基本应用
非凡的博客
03-28 547
泛型接口： 泛型即可以直接在类中进行操作，在Java中也可以在接口中定义和使用泛型 定义泛型接口： 声明泛型接口和声明泛型类的语法相似都是 访问权限 interface 接口名称 <标识符> {} interface USB <T> { //在接口上定义泛型 public T getWrite();//定义抽象方法，返回值就是泛型类型 } 泛型接口的实现： 1 .在...
程序中泛型的应用（一个小例子 经测试 正常）
linfanhehe的专栏
07-20 1306
在java 中 上网查了一下Class entityClass = (Class) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];    但是 这个无法得到自己本身的泛型。而调用getGenericSuperclass()方法得到的是父类的泛型。 话不多说 直接上代码
java泛型详解及它的应用
baoFeng_Li的博客
04-15 273
泛型的本质： 类型参数化 引入目的：建立具有类型安全的集合框架，如链表，散列表等数据结构 他山之石： 1.作者：VieLei 侧重：详解 地址：https://blog.csdn.net/s10461/article/details/53941091 2.作者：Josh Juneau 侧重：例子应用 地址：http://www.oracle.com/technetwork/cn/a...
泛型程序设计详解
qq_57150526的博客
09-11 281
Java核心教程——泛型程序设计笔记，其中不包含反射部分。
泛型程序设计基本概念
江南又一春
12-12 438
C++是一门很强大的语言，他有两种机制来提高代码的重用性，其中一种通过继承实现。另外一种就是泛型。使用模板的程序设计就是泛型程序设计。在C++中模板有两种体现形式，一种是类模板，一种是函数模板。 ...
第十三章 泛型程序设计
03-20
**第十三章 泛型程序设计** 泛型是Java编程语言中的一个重要特性，引入于Java 5.0，它允许在定义类、接口和方法时使用类型参数，从而提高了代码的类型安全性和重用性。泛型的主要目标是提供一种方式来限制容器对象...
类的编写与应用
06-12
类的编写与应用，构造与析构函数，函数的重载，类的继承，函数覆盖，基类与派生类的构造函数、析构函数先后调用顺序，
java程序设计实验代码
12-01
请应用泛型编写程序。首先定义一个接口，它至少包含一个可以计算面积的成员方法。然后，编写实现该接口的两个类：正方形类和圆类。接着编写一个具有泛型特点的类，要求利用这个类可以在控制台窗口中输出某种图形的面积，而且这个类的类型变量所对应的实际类型可以是前面编写的正方类或圆类。最后利用这个具有泛型特点的类在控制台窗口中分别输出给定边长的正方形的面积和给定半径的圆的面积。 编写一个类MyArray，包含一个复制数组的方法，功能与System.arraycopy()相同。请使用泛型改写MyArray类实现数组复制. 请编写程序。首先在程序中定义一个枚举类型，它含有7个枚举常量，分别表示一个星期每一天的名称。然后在控制台窗口中输出这些名称。 注：要求分别用一般形式的For 语句和For语句的简化写法在控制台窗口中输出这些名称。 java编码实现的这些题目的代码。
Educoder–Java面向对象-泛型程序设计【笔记+参考代码】
12-21
Java中的泛型是面向对象程序设计的一个重要特性，它允许我们在类、接口和方法中使用类型参数，从而创建可重用的组件，这些组件能够处理多种数据类型而无需显式进行类型转换。泛型的主要目标是提高代码的类型安全性和...
java泛型程序示例详解
weixin_30585437的博客
09-21 161
普通泛型 1 class Point<T>{ // 此处可以随便写标识符号，T是type的简称 2 private T var ; // var的类型由T指定，即：由外部指定 3 public T getVar(){ // 返回值的类型由外部决定 4 return var ; 5 } 6 ...
使用java泛型设计通用方法
weixin_30273175的博客
12-13 423
泛型是Java SE 1.5的新特性, 泛型的本质是参数化类型, 也就是说所操作的数据类型被指定为一个参数. 因此我们可以利用泛型和反射来设计一些通用方法. 现在有2张表, 一张user表和一张student表. user: student: 　　如果要根据id查询数据, 你会怎么做呢？写2个方法分别查询user和student？其实这时候我们就可以使用泛型和反射写一...
Java泛型、枚举与for语句的简化写法1
lonely_Quan的专栏
03-05 1281
请应用泛型编写程序。首先定义一个接口，它至少包含一个可以计算面积的成员方法。然后，编写实现该接口的连个类：正方形类和圆类。接着写一个具有泛型特点的类，要求利用这个类可以在控制台窗口输出某种图形的面积，而且这个类的类型变量所对应的实际类型可以说前面编写的正方形类或圆类。最后利用这个具有泛型特点的类在控制台窗口中分别输出给的边长的正方形的面积和给定半径的圆的面积。 L_Shape.java /
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 648
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
泛型程序设计与c++标准
06-08
泛型程序设计是一种编程范式，旨在实现通用的数据结构和算法，使得程序员能够编写高效、可重用的代码。C++标准库中的许多组件都是基于泛型编程实现的，例如STL（标准模板库）中的容器、算法和迭代器等。 C++11标准...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值