进入泛型的世界

已于 2024-05-12 17:12:20 修改
阅读量267 收藏 3
点赞数 4
文章标签： java android 开发语言
于 2024-05-11 23:44:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Islucas/article/details/138720396
版权

泛型的理解和好处

泛型的好处

  • 编译时，检查添加元素的类型，提高了安全性
  • 减少了类型转换的次数，提高效率
    不使用泛型
    Dog-加入->Object-取出->Dog（向下转型） Dog放入到ArrayList 会先转成Object，在转出时，还需要转换成Dog
    使用泛型
    Dog->Dog->Dog 放入和取出时，不需要类型转换，提高效率
  • 不再提示编译警告

泛型的介绍

泛型：广泛类型

  • 泛型又称参数化类型，是JDK5.0 出现的新特性，解决数据类型的安全性问题
  • 在类声明或实例化时（在定义对象时，即编译期间），只要指定好需要的具体类型即可
  • Java 泛型可以保证如果程序在编译时，没有发出警告，运行时就不会产生，ClassCastException异常。同时，代码更加简洁
  • 泛型的作用：可以在类声明时通过一个标识表示类中某个属性的类型，或者某个方法的返回值类型，或者是参数类型
public class Generic01 {
    public static void main(String[] args) {
        //注意：E 具体的数据类型在定义Person对象时指定（即在编译期间），就确定E是什么类型
        Person<Integer> integerPerson = new Person<>(1);//E的数据类型是Integer
        integerPerson.show();
    }
}
//泛型的作用：可以在类声明时通过一个标识表示类中某个属性的类型、某个方法的返回值类型 或 参数类型
class Person<E>{
    E S;//E表示s的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型

    public Person(E s) {//E也可以是参数类型
        S = s;
    }
    public E f(){//E也可以是返回类型
        return S;
    }
    public void show(){
        System.out.println("S的运行类型="+S.getClass());
    }
}

结果
在这里插入图片描述

泛型的语法

泛型的声明

  • interface 接口{} 和 class类<K,V>{}
    1，其中 T K V 不代表值，而是表示类型
    2，任意字母都可以，常用T表示，是Type的缩写

泛型的实例化

要在类名后面指定类型参数的值（类型）。如：

  • 1，List strList = new ArrayList();
  • 2，Iterator iterator = customers.iterator();

泛型使用实例

在这里插入图片描述

public class GenericExercise {
    public static void main(String[] args) {
        //使用泛型方式给HashSet放入三个学生对象，遍历时可以直接调用Student1中的方法
        Set<Student1> objects = new HashSet<Student1>();
        objects.add(new Student1("jack"));//当调用add方法时，显示调用Student1 对象
        objects.add(new Student1("tom"));
        objects.add(new Student1("smith"));

        // 遍历
        for(Student1 o:objects){
            System.out.println(o.getName());
        }
        //使用泛型方式给 HashMap 放入 3 个学生对象
        //K -> String V->Student
        //一旦添加了泛型，编译器就会规范调用类型
        Map<String, Student1> map = new HashMap<String, Student1>();
        //public class HashMap<K,V> {}

        Student1 student1 = new Student1("jack");
        Student1 student2 = new Student1("tom");
        Student1 student3 = new Student1("smith");
        map.put("jack",student1);
        map.put("tom",student2);
        map.put("smith",student3);

        //遍历
        //迭代器 EntrySet
        /*
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
             return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }
        */
        //1,map.entrySet();
        Set<Map.Entry<String, Student1>> entries = map.entrySet();

        /*
        public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
        }
        */
        //2,调迭代器 entries.iterator()
        Iterator<Map.Entry<String, Student1>> iterator = entries.iterator();
        //3，先判断hasNext  下一个是否还有
        while (iterator.hasNext()) {
            Map.Entry<String, Student1> next = iterator.next();
            System.out.println(next.getKey()+"-"+next.getValue());
        }
    }
}
class Student1{
    private String name;

    public Student1(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                '}';
    }
}

结果
在这里插入图片描述

泛型的注意事项

  • 1，interface List{} public class HashSet{}
    说明：T E 只能是引用类型
  • 2，在给泛型指定具体类型后，可以传入该类型或其子类类型
  • 3，泛型使用形式
    List list1 = new ArrayList ();
    List list1 = new ArrayList <>();
    如果我们这样写List list1 = new ArrayList (); 默认他的泛型是 E 就是Object
public class GenericDetail {
    public static void main(String[] args) {
        //1,泛型指向的数据类型是引用类型Integer，不能是基本数据类型int
        List<Integer> list = new ArrayList<Integer>();
        //List<int> list = new ArrayList<int>();  错误

        //2,E指定了A类型，构造器传入 new A()
        //  在给泛型指定具体类型后，可以传入该类型或者子类类型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();
        Pig<A> aPig1 = new Pig<A>(new B());
        aPig1.f();

        //3，泛型的使用形式
        List<Integer> list1 = new ArrayList <Integer>();
        //实际开发中往往简写为：
        List<Integer> list2 = new ArrayList <>();

        //4，如果我们这样写List list1 = new ArrayList ();  默认他的泛型是 <E> E 就是Object
        List list3 = new ArrayList ();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
        
    }
}
class A{

}
class B extends A{}
class Pig<E>{
    E e;

    public Pig(E e) {
        this.e = e;
    }
    public void f(){
        System.out.println("Pig类中的f方法");
    }
}

自定义泛型

自定义泛型类

  • 基本语法
    class 类名<T,R…>{//…表示可以有多个泛型
    成员}
  • 注意细节
    1，普通成员可以使用泛型（属性，方法）
    2，使用泛型的数组，不能初试化
    3，静态方法中不能使用类的泛型
    4，泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）
    5，如果在创建对象时，没有指定类型默认为Object
public class CustomGeneric {
    public static void main(String[] args) {
        //4，泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）
        //T=Double, R=String, M=Integer
        Tiger<Double, String, Integer> g = new Tiger<Double, String, Integer>("john");
        g.setT(10.9);//ok
        //g.setT("yy");//错误，类型不对
        System.out.println(g);
        //5，如果在创建对象时，没有指定类型默认为Object
        Tiger g2 = new Tiger("john~~~");//ok   T=Object R=Object M=Object
        //等价于  Tiger<Object,Object,Object> g2 = new Tiger<Object,Object,Object>("john~~~")
        g2.setT("yy"); //OK 因为 T=Object  "yy" = String 是 Object 子类
        System.out.println("g2="+g2);
    }
}
//T, R, M 泛型的标识符, 一般是单个大写字母,泛型标识符可以有多个
class Tiger<T,R,M>{
    String name;
    //1，普通成员可以使用泛型 (属性、方法)
    R r;//属性使用到泛型
    M m;
    T t;
//    T[] ts = new T[4];//报错，不能初试化
    //2，使用泛型的数组，不能初试化
    //因为数组在new时，便要去开辟数组的空间，但是 还现在还不能确定T的类型，就无法在内存开空间
    T[] ts;

    public Tiger(String name) {
        this.name = name;
    }

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

    //3，静态属性和方法中不能使用类的泛型
    //因为：静态是和类相关的，在类加载时，对象还没有创建. 但是泛型是和对象相关，但是泛型类型是在对象创建时指定
    //static R r2; 报错
//    public static void m1(M m){ 报错}

    //方法使用到泛型

    public String getName() {
        return name;
    }

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

    public R getR() {
        return r;
    }

    public void setR(R r) {
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    public T[] getTs() {
        return ts;
    }

    public void setTs(T[] ts) {
        this.ts = ts;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

结果
在这里插入图片描述

自定义泛型接口

  • 基本语法
    interface 接口名<T,R…>{//…表示可以有多个泛型
    成员}
  • 注意细节
    1，接口中，静态成员也不能使用泛型（原因同类：一般是先有类才选择是否创建对象。而静态是与类相关的，泛型是当创建对象时才会指定。）
    2，泛型接口的类型，在继承接口或实现接口时确定
    3，没有指定对象，默认为Object
public class CustomInterface {
    public static void main(String[] args) {

    }
}

//2,泛型接口的类型，在继承接口时确定
interface IA extends IUsb<String,Double>{

}
//2,BB在实现IUsb接口时，指定了泛型的接口类型
class BB implements IUsb<Integer, Float>{

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }
}
//3,CC类，在实现IUsb接口时，因为没有指定泛型类型，，默认为<Object,Object>
class CC implements IUsb{//等价 class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }
}
//AA在实现IA接口时，自动确定了U为String  R为Double；因为IA在继承IUsb时确定了接口类型，而AA有实现了IA
class AA implements IA{

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

    @Override
    public void hi(Double aDouble) {

    }
}

interface IUsb<U,R>{
    int n = 10;
    //U name;报错//1,接口中的属性只能是public static final 修饰的，而静态属性和方法中不能使用接口的泛型
    //普通方法，可以使用接口泛型
    R get(U u); //R表示返回值类型，U表示传入参数类型
    void hi(R r);//R表示传入参数类型

    //在 jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

自定义泛型方法

  • 基本语法：
    修饰符<T,R…>返回类型 方法名(参数列表){}
  • 注意事项
    1，泛型方法，可以定义在普通类中，也可以定义在泛型类中
    2，当泛型方法被调用时，类型会确定
    3，public void eat(E e){} 修饰符后没有<T,R…>eat 方法，不是泛型方法，而是使用了泛型
public class CustomMethodGeneric {
    public static void main(String[] args) {
        //T-String, R-Integer
        Car car = new Car();
        //2，当泛型方法被调用时，类型会确定
        car.fly("宝贝", 100);

        //K->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello("zl",new ArrayList());
    }
}

class Car {//普通类

    //普通方法
    public void run() {
    }

    //泛型方法
    // <T,R> 就是泛型，是提供给fly使用的
    public <T, R> void fly(T t, R r) {
        System.out.println("T的类型=" + t.getClass());//String
        System.out.println("R的类型=" + r.getClass());//Integer
    }

}

class Fish<T, R> {//泛型类

    //1，泛型方法，可以定义在普通类中，也可以定义在泛型类中
    //普通方法
    public void run() {
    }

    //泛型方法
    public <U, M> void eat(U u, M m) {
    }

    //3,hi方法不是泛型方法，只是使用了类声明的泛型
    public void hi(T t) {

    }
    //泛型方法可以使用类声明的泛型，也可以使用自己声明的泛型
    public <K> void hello(K k,R r) {
        System.out.println("K的数据类型"+k.getClass());
        System.out.println("R的数据类型"+r.getClass());
    }
}

结果
在这里插入图片描述

泛型的继承和通配符

  • 1，泛型不具备继承性
    List list = new ArrayList(); 报错
  • 2，<?>：支持任意泛型类型
  • 3，<？ extends A>：支持A类以及A类的子类，规定了泛型的上限
  • 4，<? Super A>：支持A类以及A类的父类， 不限于直接父类，规定了泛型的下限
public class GenericExtends {
    public static void main(String[] args) {
        //1,泛型不具备继承性
        //String类是Object的子类
        Object o = new String("xx");//可以
        //但是不能继承
//        List<Object> list = new ArrayList<String>(); 报错
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AAA> list3 = new ArrayList<>();
        List<BBB> list4 = new ArrayList<>();
        List<CCC> list5 = new ArrayList<>();

        //2,List<?> c  可以接收任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //3，<? extends A>：支持A类以及A类的子类，规定了泛型的上线
        //printCollection2(list1);//报错，会只限AAA 或者 AAA 子类
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);

        //4，<? Super A>：支持A类以及A类的父类， 不限于直接父类，规定了泛型的下限
        printCollection3(list1);//Object 为所有类的父类
        //printCollection3(list2);// String类 报错
        printCollection3(list3);//AAA类

    }
    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是 Object
            System.out.println(object);
        }
    }
    // ? extends AA 表示 上限，可以接受 AA 或者 AA 子类
    public static void printCollection2(List<? extends AAA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
    // ? super 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AAA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}


class AAA {
}

class BBB extends AAA {
}

class CCC extends BBB {
}

JUnit

为什么需要JUnit

  • 一个类有很多功能代码需要测试，为了测试，就需要写入到main中
  • 如果有多个功能代码测试，就需要来回注销，切换很麻烦
  • 如果可以直接运行一个方法，就方便很多，并且可以给出相关信息

基本介绍

  • 1，JUnit是一个Java语言的单元测试框架
  • 2，多数Java的开发环境都已经集成JUnit作为单元测试的工具

怎么使用

  • 1，不用在主方法中测试
  • 2，在想要测试的方法前加@Test 键入Ait+Enter,
public class JUnit_ {
    public static void main(String[] args) {

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

结果
在这里插入图片描述

Islucas
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
泛型
一个有梦想的年轻人
10-08 178
1、定义时 泛型是一个特殊的数据类型 定义类时，可以定义一个，或多个泛型类型 每个泛型可以代表任何多个、任意的数据类型 每个泛型类型可以作用于变量，方法返回类型 只能是引用类型 2、 使用时 要指明具体的数据类型，指明完成后，这个类型不可以再次发生改变。 3、 示例如下 package com.iss.user; import qh.Log; public c
基础篇-泛型Generics
雷鑫宇的博客
08-17 106
世界上只有想不通的人，没有走不通的路。
C++ 模板 与 泛型编程
热门推荐
AoboSir.com
09-27 1万+
C++ 模板 与 泛型编程前言模板有两种：类模板和函数模板 。模板是泛型编程的基础。什么叫：泛型编程？使用独立于特定类型的方式进行编程。也就是我们在编程的时候不明确的写上类型，而是使用一个模板参数来代表某种类型。所以泛型编程就需要使用模板。泛型编程这种编程方法，主要使用于：容器、迭代器、算法 。比如C++著名的标准模板库中都是使用模板和泛型编程。并且数据结构和算法，都是大量的使用泛型编程的。所以本篇
竞争性编程：我进入竞争性编程世界
02-20
"竞争性编程：我进入竞争性编程世界"这一主题揭示了作者踏入这个领域的经历和所学知识。在这里，我们将深入探讨与C++语言相关的竞争性编程知识点，帮助你更好地理解和掌握这个领域。 首先，C++是一种静态类型的、...
数据结构--队列-泛型OC&C++混编-泛型编程
李聪的博客
01-02 2309
在这篇文章里, 您可以学习到: 数据结构简介数据结构的逻辑结构和物理结构队列OC和C++在Xcode中的混编泛型编程思想泛型编程实现循环队列和链表队列博客中使用的图片均来自网络 一.数据结构简介 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检
"Java*中运行时泛型的高效编译与实现技术
理论计算机科学电子笔记138（2005）95-116www.elsevier.com/locate/entcsJava*中运行...然而，与当前的.NET公共语言的实现不同的是，没有提供对泛型的运行时支持（通常也称为类型参数的重新定义），这导致了许多众所周
完美世界2014校园招聘笔试题c++
11-09
【完美世界2014校园招聘笔试题C++】是一场针对应届毕业生的编程能力测试，主要考察应聘者的C++基础知识、...对于那些想要进入游戏开发公司如完美世界的人来说，熟练掌握C++语言至关重要，因为它是许多游戏引擎的基础。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1187
浅析synchronized锁升级的原理与实现
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
最新发布
weixin_53180424的博客
09-03 675
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 559
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
操作系统原子操作
zzt_is_me的博客
08-28 8680
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 399
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 841
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 1682
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 544
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
Java并发编程 进程与线程
m0_56369671的博客
08-28 1385
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms 注：需要在多核 cpu 才能提高效率，单核仍然时是轮流执行。
C++CLI：连接本地与托管世界的泛型与模板集成
C++/CLI是C++程序员进入.NET世界的一个重要途径，它结合了两种编程范式的优点，让开发者可以利用C++的强大功能和.NET Framework的便利。然而，这也意味着开发者需要理解和掌握两套不同的编程模式和规则，这对于熟练...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值