第十四章：泛型

已于 2022-09-25 10:43:16 修改
阅读量207 收藏 1
点赞数
分类专栏： java 文章标签： java
于 2022-09-24 21:18:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_61927991/article/details/127028463
版权

编译时，检查添加元素的类型，提高安全性。减少了类型转换的次数，提高效率。不在提示编译警告..起到约束类型的作用

一、泛型

@SuppressWarnings({"all"}) //取消文件警告
public class Hello {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>(); //只能添加String类型的数据
        Person<String> person = new Person<>("你好");
        person.show();
        new Person<Integer>("你好");//报错因为指定的时int传入的是字符串
    }
}

class Person<E>{
    E s;//E 表示 s数据类型，该数据类型在定义Person对象时候指定，及编译期间，就确定E是什么类型
    public Person(E s){//E也是参照类型
        this.s = s;
    }
    public E f(){ //返回值用E
        return s;
    }
    public void show(){
        System.out.println(s.getClass()); //获取运行类型
    }
}

（1）案例：

       1.创建3个学生对象 2. 放入到HashSetr,促用I3.放入到 HashMap中，要求 Key是 String name, Value就是学生对象 4 .使用两种方式遍历

@SuppressWarnings({"all"}) //取消文件警告
public class Hello {
    public static void main(String[] args) {
        Map<String, Student> map = new HashMap<>();
        map.put("zs", new Student("张三", 19));
        map.put("ls", new Student("李四", 29));
        map.put("ww", new Student("王五", 39));
        System.out.println("==========第一种=========");
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key + "  ================>  " + map.get(key));
        }
        System.out.println("==========第二种=========");
        Set<Map.Entry<String, Student>> entrySet = map.entrySet();
        for (Object o : entrySet) {
            Map.Entry<String, Student> entry = (Map.Entry<String, Student>) o;
            System.out.println(entry.getKey() + "  ================>  " + entry.getValue());
        }
    }
}

class Student {
    public String name;
    public int age;

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

    @Override
    public String toString() {
        return "姓名: " + name + " 年龄: " + age;
    }
}

（2）注意事项：

  • interface List<T>{} , public  class  HashSet<E>{}...等等。说明：T，E只能是引用类型
  • 给泛型指定具体类型后，可以传入该类型或者子类类型
  • 开发中我们简写方式推荐写法 Map<String, Student> map = new HashMap<>(); 类型推断
  • List list = new ArrayList()  这样写默认添加的是Object

（3）案例：

        

@SuppressWarnings({"all"}) //取消文件警告
public class Hello {
    public static void main(String[] args) {
        ArrayList<Employee> arrayList = new ArrayList<>();
        arrayList.add(new Employee("张三", 1000, new MyDate(10, 10, 10)));
        arrayList.add(new Employee("李四", 3000, new MyDate(1, 12, 19)));
        arrayList.add(new Employee("王五", 2000, new MyDate(3, 11, 10)));
        //排序按工资升序
        arrayList.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                return (int) (o1.getSal() - o2.getSal());
            }
        });
        for (Employee employee : arrayList){
            System.out.println(employee);
        }
    }
}

class Employee {
    private String name;
    private double sal;
    private MyDate birthday;

    public Employee(String name, double sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public double getSal() {
        return sal;
    }

    @Override
    public String toString() {
        return "姓名：" + name + " 工资：" + sal + " 生日：" + birthday;
    }
}

class MyDate {
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public String toString() {
        return year + "年" + month + "月" + day + "日";
    }
}

 二、自定义泛型类

@SuppressWarnings({"all"}) //取消文件警告
public class Hello {
    public static void main(String[] args) {
        Tiger<String, Double, Integer> jhon = new Tiger("Jhon", 123, 1,123);
    }
}
//1.Tiger 后面泛型，所以我们把Tiger称为自定义泛型类
//2.T,R,M 泛型的标识符,一般是单个大写字母
//3.泛型标识符可以有多个
//4.普通成员可以使用泛型
//5.使用泛型不能初始化泛型
//6.静态方法不能使用泛型  因为静态的在类加载的时候创建，泛型在实例创建完才知道


class Tiger<T,R,M>{
    String name;
    T t;
    R r;
    M m;

    public Tiger(String name, T t, R r, M m) {
        this.name = name;
        this.t = t;
        this.r = r;
        this.m = m;
    }
}

三、自定义接口泛型

@SuppressWarnings({"all"}) //取消文件警告
public class Hello {
    public static void main(String[] args) {}
}

//1.接口中，静态成员也不能使用泛型(这个和泛型类的规定一样)
//2.泛型接口的类型，在继承接口或实现接口时确定
//3.没有指定类型，默认为Object
interface IUsb<U,R>{
    int n = 10;
//    U name; 报错

    R get(U u);

    void h1(R r);

    default R method(U u){
        return null;
    }
}

//继承接口的时候指定泛型的类型
interface IA extends IUsb<String,Integer>{}

class A implements IUsb<String,String>{

    @Override
    public String get(String s) {
        return null;
    }

    @Override
    public void h1(String s) {

    }
}

class Dog implements IA{

    @Override
    public Integer get(String s) {
        return null;
    }

    @Override
    public void h1(Integer integer) {

    }
}

四、自定义泛型方法

@SuppressWarnings({"all"}) //取消文件警告
public class Hello {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("123",123);
        System.out.println("第二组");
        car.fly(123,123);
    }
}
//泛型方法，可以定义在普通类中，也可以定义在泛型类中
class Car{//普通类
    public void run(){} //普通方法
    public <T,R> void fly(T t,R r){ //泛型方法
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}

class Fish<T,R>{//泛型类
    public void run(){}//普通方法
    public <U,M> void eat(U u , M m){} //泛型方法
    public void hi(T t){} //这不是泛型方法
}

（1）案例：

 五、泛型继承和通配

@SuppressWarnings({"all"}) //取消文件警告
public class Hello {
    public static void main(String[] args) {
        Object o = new String("xx");
        //泛型没有继承性
//        List<Object> list = new ArrayList<String>();

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是List<?>可以接受任意泛型类型
        print1(list1);
        print1(list2);
        print1(list3);
        print1(list4);
        print1(list5);

        //如果是List<? extends AA>  可以接收AA或者AA的子类
        //print2(list1); //x
        //print2(list2); //x
        print2(list3); //v
        print2(list4); //v
        print2(list5); //v

        //如果是List<? super AA> 可以接收AA或者AA的父类，不一定是直接父类
        print3(list1); //v
        //print3(list2); //x
        print3(list3); //v
        //print3(list4); //x
        //print3(list5); //x
    }
    //List<?> 表示任意泛型类型都可以接受
    public static void print1(List<?> c){
        for (Object o :c) {
            System.out.println(o);
        }
    }
    //? extends AA 表示上限 可以接受  AA或者AA的子类
    public static void print2(List<? extends AA> c){
        for (Object o :c) {
            System.out.println(o);
        }
    }
    //? super 子类类名AA支持AA类或者AA类的父类，不限于直接父类
    public static void print3(List<? super AA> c){
        for (Object o :c) {
            System.out.println(o);
        }
    }
}

class AA{}

class BB extends AA{}

class CC extends BB{}

@SuppressWarnings({"all"}) //取消文件警告
public class Hello {
    public static void main(String[] args) {
        DAO<User> userDAO = new DAO<>();
        //save方法
        userDAO.save("zs", new User(1, 19, "张三"));
        userDAO.save("ls", new User(2, 20, "李四"));
        userDAO.save("ww", new User(3, 21, "王五"));
        //get
        System.out.println("get返回的值" + userDAO.get("zs"));
        //update 更新张三的年龄为30岁
        userDAO.update("zs", new User(1, 30, "张三"));
        //删除王五
        userDAO.delete("ww");
        //获取所有对象
        System.out.println(userDAO.list());
        ArrayList<User> list = (ArrayList<User>) userDAO.list();
        System.out.println("======遍历所有对象======");
        for (User user : list) {
            System.out.println(user);
        }
    }
}

class DAO<T> {
    private final Map<String, T> map = new HashMap<>();

    public void save(String id, T entity) {
        map.put(id, entity);
    }

    public T get(String id) {
        return map.get(id);
    }

    public void update(String id, T entity) {
        map.put(id, entity);
    }

    public List<T> list() {
        ArrayList<T> list = new ArrayList<>();
        list.addAll(map.values());
        return list;
    }

    public void delete(String id) {
        map.remove(id);
    }
}

class User {
    private int id;
    private int age;
    private String name;

    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 + '\'' +
                '}';
    }
}

六、JUnit测试框架

1.使用junit5.4，可以快速测试某个方法

import org.junit.jupiter.api.Test;

public class Hello {
    public static void main(String[] args) {
        //传统的太麻烦了
//        new Hello().m1();
//        new Hello().m2();
    }

    @Test
    public void m1(){
        System.out.println("m1被调用");
    }

    @Test
    public void m2(){
        System.out.println("m2被调用");
    }
}
(delphi11最新学习资料) Object Pascal 学习笔记---第14章泛型第3节（泛型约束）
langfengyl的专栏
06-13 381
方法的类，当数据对象是特定类型时，该版本将被调用，而不管提供的实际类型是什么。将在数据对象是特定类型时被调用，而不管提供给泛类型的实际类型是什么。​ 正如我们所看到的，您在泛型类的方法中可以做的事情非常少。您还可以进一步限制类为给定层次结构的一部分，或实现特定接口，从而可以在泛型类型的实例上调用类或接口方法。值传递，也可以定义特定的泛型类型实例，在这两种情况下，调用One方法最终会执行特定版本的。​ 但是，不同的记录之间共同点很少（没有共同的祖先），因此这种声明有些受限。函数不同，后者返回引用类型的大小。
第十章 泛型
daxi13的博客
10-21 856
10.1 泛型的理解和好处 10.1.1使用传统方法的问题分析 1）不能加入到集合ArrayList中的数据类型进行约束(不安全) 2）遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响 10.1.2泛型的好处 1)编译时，检查添加元素的类型，提高了安全性 2)减少了类型转换的次数，提高效率[说明] √不使用泛型 Dog -加入->Object·取出-> Dog//放入到ArrayList会先转成Object，在取出时，还需要转换成Dog √便用泛型 Dog-
JDK8 函数式编程【java进阶笔记九】
yuyu的博客
03-04 803
目录 lamda 表达式 函数式接口 SAM （single Abstract Method) 方法引用 CPS（continuation-passing style） Stream Stream.collect() Optional lamda 表达式 使用 lambda 表达式首先需要一个接口： 函数式接口 SAM （single Abstract Method) @FunctionInterface //【非必须】，如果加上，编译器会进行校验 .
泛型（总结完整）
laity__c的博客
12-06 1490
1、泛型的理解和好处 1.1 使用传统方法的问题分析 无法对加入到几个ArrayList中的数据类型进行约束（不安全） 抛出ClassCastException异常 遍历的时候需要进行类型转化（向下转型），如果集合中的数据量较大，对效率有影响 1.2使用泛型 编译时，添加检查元素的类型，提高了安全性 减少了类型转化的次数 1.3小结（重点） 不使用泛型 Dog -加入-> Object -取出-> Dog 放入ArrayList中会先转成Object，取出再转成Dog 使用泛型 Dog
Java之泛型
y_k_j_c的博客
08-03 719
可以把泛型理解为可以表示数据类型的一种数据类型4的解释//如果你不写的话，默认为ObjectobjectPerson.s=newString("c");//现在Person里面的s只能是String了Person.s="小袁";//传入其他类型的会报错}}classPerson<T>{//代表我们的name是String类型Ts;//s则是T类型，这个T类型是你在创建的时候定义的类型}就是相当于把你里面传入的类型(实参).........
public static ＜T＞ R＜T＞ success(T object)的解读
qq_45007794的博客
08-21 718
public static：这是访问修饰符，表示这个方法是公共的（可以从任何地方访问）和静态的（可以直接通过类名调用，不需要创建实例）。<T>：这是一个泛型参数的声明。它告诉编译器这个方法接受一个泛型类型，并且后续代码中可以使用T作为类型参数来表示这个泛型类型。R<T>：这是方法的返回类型。R<T> 表示一个泛型类型 R，它接受一个类型参数 T，这里 R 可能是某种包装类或者自定义类。success(T object)：这是方法的名称和参数列表。方法接受一个参数 object，其类型为泛型类型 T。
重学Java 8新特性 | 第5讲——函数式接口
李阿昀的博客
12-31 1115
我们都知道Lambda表达式需要接口的支持，并且接口中的抽象方法还不能多，只能有一个，不然就没法区分它实现的到底是哪个抽象方法了。一般，我们会称该接口为函数式接口，在上一讲中我就已经提到过了，大家还记得吧！这一讲我们就来具体唠唠它。 什么是函数式接口？ Lambda表达式可以很简洁的代替匿名内部类的代码编写，而匿名内部类往往是实现某一接口的一个抽象方法。所以，在使用Lambda表达式时，我们最应该关注的应该是接口的抽象方法，并且这个接口还必须只有一个抽象方法。我们称这种只有一个抽象方法的接口为函数式接口，而
Delphi泛型集合数据持久化：泛型序列化技术详解
[泛型序列化](https://www.guru99.com/images/c-sharp-net/052716_0700_CFileOperat14.png) # 摘要 泛型集合与数据持久化是软件开发中的关键概念，涉及到数据结构的组织与存储。本文首先探讨了泛型序列化的核心机制...
C++模板编程：泛型数据结构设计原理，高级应用全攻略
C++模板编程是C++语言的一个核心特性，它支持泛型编程范式，为开发者提供了强大的代码复用和类型安全。本文首先介绍了C++模板编程的基础知识和泛型数据结构的设计原理，包括标准模板库（STL）的内部实现机制及其设计...
C++模板编程深度探索：泛型编程实践与技巧
在第3部分（第14至18章），作者介绍了C++模板支持的基本设计技术，这些技术在泛型编程中至关重要，例如，如何利用模板实现类型安全的容器、算法和功能，以及模板在STL（标准模板库）中的应用。这部分还可能涉及到...
C++模板编程详解：泛型编程的艺术
!... # 摘要 本文旨在全面概述C++模板编程，从基础概念和语法开始，逐步深入到模板的高级特性和在现代C++中的应用。首先，文章介绍了模板的基本类型、声明和参数，接着探讨了模板特化、模板元编程以及与标准库的关系。...
Java泛型中的T,R,K,V,E：一探究竟
最新发布
Java技术乐园
01-08 2652
Java泛型中的T、R、K、V、E等符号都是为了简化代码和提高代码的可读性而引入的。Java的泛型，作为一种强大的编程工具，让代码更具复用性，同时避免了类型转换的繁琐操作。在使用泛型时，我们经常会遇到一些特定的类型参数符号，如T、R、K、V、E等。这种表示方法使得我们可以为不同类型的集合指定不同的元素类型，从而避免了类型转换的繁琐操作。
泛型方法003
m0_57611012的博客
03-24 107
1.泛型方法是指将方法的参数定义成泛型，以便在调用时接收不同类型的参数。类型参数可以有多个，用逗号隔开，如<K,T>。定义时，类型参数一般放到返回值前面。 //非静态方法 public class MethodGenerics { public <T> void setName(T name){ System.out.println(name); } public <T> T getName(T name){
Java中的泛型 --- Java 编程思想
weixin_34326179的博客
03-01 139
前言 ​ 我一直都认为泛型是程序语言设计中一个非常基础，重要的概念，Java 中的泛型到底是怎么样的，为什么会有泛型，泛型怎么发展出来的。通透理解泛型是学好基础里面中非常重要的。于是，我对《Java编程思想》这本书中泛型章节进行了研读。可惜遗憾的是，自己没有太多的经验，有些东西看了几次也是有点懵。只能以后有机会，再进行学习了。但是自己也理解了挺多的。下面就是自己对于泛型的理解与感悟。如有不对，望指...
java 泛型引入及详解，泛型通配符使用示例，JUnit 单元类测试框架
m0_62780707的博客
01-24 853
一、引入 1、泛型是什么 泛型 ，顾名思义就是 广泛的数据类型，也就是说什么数据类型都可以。一般来说，我们见到的泛型就是这个样子，用 T 表示。如下所示，在类名后方申明泛型 T，接着就可以在成员变量、方法中使用泛型了。其中我们在java 集合构架中以及以后将会广泛的应用到泛型。 首先告诉大家ArrayList就是泛型之一。 首先让我们来看一个例子，认识一下泛型的作用之一。 在ArrayList 集合遍历中，我们又是在处理时将会用到泛型，但若保存了不同的对象，在遍历时就将报类型转换错误： pac
关于public <T> T method(T t)函数的说明
天马行空的专栏
07-19 9270
关注公众号“码农帮派”，查看更多系列技术文章： 现有这么一个函数： ［正确示例］ public <T> T method(T t){ // CODE return t; } 上面的代码，在public和method之间有两个部分<T>和T。 其中<T>是为了定义当前我有一个 范型变量类型，类型名...
JAVA8 Function＜T,R＞ 和 BiFunction＜T,U,R＞ 接口
xjj1314的专栏
08-11 2516
Function是名字一般是一个函数接口，是JDK 1.8 新增加的函数式接口。 public interface Function<T, R> { /** * 将此函数应用于给定参数 * 真正执行函数接口的方法 */ R apply(T t); /** * 函数链，before执行的结果做根函数为参数 */ default <V> Function<V, R> compose.
[Java]public <T> void method，此地泛型的意思
Runstoppable的博客
04-03 1783
今天项目中遇到这样一个方法： public &lt;T&gt; void method(T var) 不太明白什么意思，后来搜索下几篇文章，自己总结一下，和大家分享。 先看例子： static void fromArrayToCollection(Object[] a, Collection&lt;?&gt; c) { for (Object o : a) { ...
13.泛型
qq_25830587的博客
12-20 571
泛型
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值