java高级篇--泛型

已于 2023-03-03 11:09:53 修改
阅读量483 收藏 1
点赞数
分类专栏： Java高级篇 文章标签： java 后端 开发语言 junit spring
于 2022-07-14 10:42:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xzh_java/article/details/125772675
版权

一.什么是泛型?

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

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

这个<T>它就是泛型。

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

二. 为什么使用泛型?

例子: 要求定义一个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<E> {
    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<Integer> point = new Point(10, 20);
        point.show();
        //坐标为小数
        Point<Double> point1 = new Point(25.2, 23.2);
        point1.show();
        //坐标为字符串
        Point<String> point2 = new Point("北纬29°", "东经45度");
        point2.show();
    }
}

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

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

三. 如何定义泛型

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

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

 格式:

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

     //类成员
}

package com.xzh.demo03;

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

       info<String> 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<E>{
    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<Integer> info = new info<>(10);
        fun(info);

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

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

//E标志可以任意起名 A B C D T都可以----> 那么在创建对象时，必须为每个泛型指定数据类型。
class info<E>{
    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 类> 对象名称;
定义类:  [访问权限] 类名称<泛型标识 extends 类>{}

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

package com.xzh;

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


        info<Object> i2 = new info<>("123");
        fun(i2);
    }

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

//当创建该类对象时，泛型必须为Number的子类以及Number类型
class People<T extends  Number> {

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

六. 泛型接口

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

语法:

public interface 接口名<泛型标志,泛型标志....>{
   //静态常量
   //抽象方法。
}

类如何实现泛型接口:  

package com.xzh.demo06;

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

        Upan upan = new Upan();
        String fun = upan.fun();
        System.out.println(fun);


        Mouse<Integer> mouse=new Mouse<>();
        Integer fun1 = mouse.fun();
        System.out.println(fun1);

    }
}

//泛型接口
interface Usb<E>{
    String NAME=""; //常量的命名必须为大写
    E fun();//抽象方法
}
//子类在实现接口时 确定泛型类型
class Upan implements Usb<String>{

    @Override
    public String fun() {
        return "hello,java";
    }
}

//当子类也实现泛型和父类相同的泛型
class Mouse<E> implements Usb<E>{

    @Override
    public E fun() {
        return null;
    }
}

七. 泛型方法

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

package com.xzh.demo05;

public class Test01 {
    public static void main(String[] args) {
        String hello = Student.fun("hello");
        Integer fun = Student.fun(123);
        Double fun1 = Student.fun(123.1);

    }
}
class Student{
    //泛型方法: static静态成员，随着类的加载而被加载到JVM内存中。常量池
    public static <E> E fun(E e){
        return e;
    }
}

测试题:

第一题：开发一个泛型Apple类，要求有一个重量属性weight在测试类中实例化不同的泛型对象，要求对象a1的这一属性是String类型，对象a2的这一属性是Integer型，a3的这一属性是Double型。分别为a1，a2，a3的重量属性赋值为：”500克”，500,500.0，在测试类中通过对象调用访问器得到属性值并输出。

第二题：自己定义一个泛型接口，其中有一个eat方法。用一个Person类实现这个接口，传入的泛型实参是String类型，实现的方法内容自己定义，最后在main中调用eat方法。

练习三：定义个泛型类 DAO，在其中定义一个 Map 成员变量，Map 的键为 String 类型，值为 T 类型。分别创建以下方法：public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中public T get(String id)：从 map 中获取 id 对应的对象public void update(String id,T entity)：替换 map 中 key 为 id 的内容,改为 entity 对象public List list()：返回 map 中存放的所有 T 对象public void delete(String id)：删除指定 id 对象定义一个 User 类：该类包含：private 成员变量（int 类型） id，age；（String 类型）name。定义一个测试类：创建 DAO 类的对象， 分别调用其 save、get、update、list、delete 方法来操作 User 对象，使用 Junit 单元测试类进行测试。

 第一题

package com.xzh.demo01;

public class Test01 {
    public static void main(String[] args) {
        Apple<String> a1 = new Apple<>("500克");
        a1.show();

        Apple<Integer> a2 = new Apple<>(500);
        a2.show();

        Apple<Double> a3 = new Apple<>(500.0);
        a3.show();

    }
}
class Apple<E>{
    private E weight;

    public void show(){
        System.out.println(weight);
    }
    public Apple() {
    }

    public Apple(E weight) {
        this.weight = weight;
    }

    public E getWeight() {
        return weight;
    }

    public void setWeight(E weight) {
        this.weight = weight;
    }
}

 第二题

package com.xzh.demo02;

public class Test01 {
    public static void main(String[] args) {
        Person<String> p = new Person<>();
        String eat = p.eat();
        System.out.println(eat);
    }


}
interface chi<E>{
    E eat();
}
class Person<E> implements chi<String>{


    @Override
    public String eat() {
        return "吃饭";
    }
}

 第三题

package com.xzh.demo03;

import java.util.*;
public class Dao<E> {

    Map<String,E> map = new HashMap<>();

    //保存 T 类型的对象到 Map 成员变量中
    public void save(String id,E entity){
        map.put(id,entity);
    }

    //从 map 中获取 id 对应的对象
    public E get(String id){
        return map.get(id);
    }

    //替换 map 中 key 为 id 的内容,改为 entity 对象
    public void update(String id,E entity) {
        map.replace(id,entity);
    }
    //返回 map 中存放的所有 T 对象
    public List list(){
        List<E> list = new ArrayList<>();
        Set<String> strings = map.keySet();
        for (String user :strings
                ) {
            E e = map.get(user);
            list.add(e);
        }
        return list;
    }

    //删除指定 id 对象
    public void delete(String id){
        map.remove(id);
    }
}


package com.xzh.demo03;

public class User {
    private int id;
    private int age;
    private String name;
    public User() {

    }

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.xzh.demo03;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test01 {
    public static void main(String[] args) {
        User user = new User();

        //添加
        Dao<User> userDao = new Dao<>();
        userDao.save("1",new User(1,23,"张三"));
        userDao.save("2",new User(2,23,"王五"));

        //根据id
        User user1 = userDao.get("2");
        System.out.println(user1.getName());

        //修改
        userDao.update("2",new User(3,243,"赵六"));

        //删除
        userDao.delete("1");

        //获取所有
        List list = userDao.list();
        System.out.println(list);
    }
}

一个小哑巴
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java高级-泛型
weixin_45900005的博客
10-26 957
12.泛型 1.泛型的概念 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时确定（即传入实际的类型参数，也称为类型实参)。 12.1.为什么要用泛型 泛型与File中使用泛型举例 泛型的使用 泛型即传入实际的参数类型,也称类型实参 1.jdk5.0新增的特性 2.在集合中使用泛型: 总结: ①集合接口或集合类在jdk5.0时都修改为带泛型的就够. ②在实例化集合类时
Java 泛型 ? extends 与 ? super
热门推荐
ikun 的博客
02-11 1万+
我们经常在集合的泛型中用到 extends、super 关键字。先看下 List 集合中获取和放入接口的定义： 通过类定义可以看到，泛型的具体类型在创建集合实例时指定，用于限定该实例的 get/set 取出和放入时的集合元素类型。了解上述后，再看下面你就不会觉得奇怪。 第一条语句编译错误，为什么呢？第二条语句正常编译，为什么呢？ 第一条语句编译正常，为什么呢？第二条语句正常编译，为什么呢？在上面的例子中，我们至少能看出：我们用 Java 对现实世界的水果进行简单的抽象，水果抽象为 Fruit，Apple
（小白一看就会）JAVA泛型
weixin_73027603的博客
08-01 209
（全网最细，小白一看就会）
浅显理解Java泛型的super和extends(1)
最新发布
2401_84046816的博客
04-22 901
其中囊括了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。
对Java的Map的Value字段进行排序
Heyyouare的博客
11-22 952
这是我在eclipse运行过的代码 package text; import java.util.Comparator; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class text3 { public static void main(String[] a...
Java 泛型详解(超详细的java泛型方法解析)
qq_66912832的博客
06-14 1万+
超详细的java泛型方法解析
JAVA学习资料-高级篇
07-26
总的来说，这份"JAVA学习资料-高级篇"涵盖了Java多线程、集合框架、反射、I/O流、异常处理、泛型以及模块化等多个核心主题。通过深入学习这些内容，有经验的JAVA开发人员能够进一步提升自己的专业水平，更好地应对...
黑马程序员----泛型与反射的小运用
04-04
泛型和反射的结合可以实现更高级的功能。例如，我们可以通过反射创建一个未知类型的集合，然后利用泛型的边界类型进行操作。这样在运行时可以根据实际需求动态地处理各种类型的数据，同时保持类型安全。此外，反射还...
Java程序设计--复习要点.doc
09-30
Java程序设计是计算机科学中的一个重要领域，尤其对于软件...掌握这些基本知识点，有助于深入理解Java程序设计，并为进一步学习Java的高级特性，如异常处理、集合框架、I/O流、多线程编程、反射、泛型等奠定坚实基础。
javapractice-udemy
03-28
本篇将围绕"javapractice-udemy"这一主题，深入探讨该课程中的核心知识点，帮助你提升Java编程技能。 首先，"javapractice-udemy"可能是一个Udemy平台上关于Java编程的实践课程。Udemy是全球知名的在线学习平台，...
java-GenericSort-源码.rar
10-10
本篇将深入解析Java泛型排序的源码，理解其背后的工作原理。 1. **泛型的概念与作用** 泛型是Java SE 5.0引入的新特性，它允许在定义类、接口和方法时使用类型参数，从而提高了代码的灵活性和安全性。通过泛型，...
java泛型类的定义与使用详解
08-27
主要为大家详细介绍了java泛型类定义与使用的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
无参数泛型方法反模式
最佳 Java 编程
06-03 435
最近，有关Java泛型的一个非常有趣的问题发布到Stack Overflow和reddit上。 请考虑以下方法： <X extends CharSequence> X getCharSequence() { return (X) "hello"; } 尽管这种不安全的转换看起来有些古怪，并且您可能会猜这里有些问题，但是您仍然可以继续并在Java 8中编译以下赋值： ...
Java高级编程——泛型
qq_61524266的博客
06-12 692
Java高级编程——泛型
【Java】泛型中extends和super的理解
helloxiefei的博客
02-17 2414
是用来限制泛型类型参数的上限和下限的关键字。它们可以在定义泛型类、泛型方法、泛型接口时使用。关键字用于限制泛型类型参数的上限，表示该泛型类型参数必须是指定类型或指定类型的子类。关键字用于限制泛型类型参数的下限，表示该泛型类型参数必须是指定类型或指定类型的父类。关键字的作用是限制泛型类型参数的范围，使得泛型类型参数在使用时更加安全和可靠。这样定义后，如果我们创建这个泛型类的实例时，这样定义后，如果我们创建这个泛型类的实例时，
泛型特殊用法 java_java泛型，泛型的高级用法详解
weixin_39991222的博客
02-16 248
下面的文章要给大家介绍的就是java泛型的高级用法方面的内容，主要介绍了三个方面，限制泛型可用类型、使用类型通配符、继承泛型类和实现泛型接口等，一起通过下面的文章来了解一下吧。1、限制泛型可用类型在java当中，默认可以使用任何类型来实例化一个泛型类对象，当然了，也可以对泛型类实例的类型进行限制。语法格式：class类名称在这当中，anyClass指某个接口或类，使用泛型限制之后，泛型类的类型必...
JAVA泛型
qq_56064498的博客
06-20 105
JAVA泛型 什么是泛型？ 背景:   JAVA推出泛型以前，程序员可以构建一个元素类型为Object的集合，该集合能够存储任意的数据类型对象，而在使用该集合的过程中，需要程序员明确知道储存每个数据的数据类型，否则很容易引发ClassCastException异常 什么是泛型？   泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型   Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常. 小结：   泛型的本质就是参数化
Java 泛型的介绍
超烦豆先森
05-31 730
什么是泛型、引入泛型、泛型类的使用、泛型的上界、泛型的方法、通配符、包装类
Java学习笔记 --- 自定义泛型
乌云的博客
11-11 726
自定义泛型

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值