自定义泛型，自定义泛型接口，自定义泛型方法，JUnit，

最新推荐文章于 2024-07-24 22:02:24 发布
最新推荐文章于 2024-07-24 22:02:24 发布
阅读量374 收藏
点赞数
文章标签： jvm java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43669384/article/details/130216905
版权
  1. class 类名<T,R....>{成员}//...表示可以有多个泛型
  2. 因义的为静态是和类相关的，在类加载时，对象还没有创建，
    泛型是对象创建的时候定
    所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
  3. 注意事项 
    package com.jshedu.generic;


import java.util.Arrays;

/**
 * @author 韩顺平
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class CustomGeneric_ {
    public static void main(String[] args) {

        //T=Double, R=String, M=Integer
        Tiger<Double,String,Integer> g = new Tiger<>("john");
        
        g.setT(10.9); //OK
        //g.setT("yy"); //错误，类型不对,T是Double类型
        System.out.println(g);
        Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
        g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
        System.out.println("g2=" + g2);

    }
}

//老韩解读
//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型 (属性、方法)
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型
class Tiger<T, R, M> {
    //static int age;
    String name;
    R r; //属性使用到泛型
    M m;
    T t;
    //因为数组在new 不能确定T的类型，就无法在内存开空间
    T[] ts;

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

    public Tiger(R r, M m, T t) {//构造器使用泛型

        this.r = r;
        this.m = m;
        this.t = t;
    }

    public Tiger(String name, R r, M m, T t) {//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在类加载时，对象还没有创建，
    //泛型是对象创建的时候定义的
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    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;
    }

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

    注意自定义泛型的大写字母代表的是什么类型，没有指定类型就是Object，

  4. interface 接口名<T,R....>{成员}//...表示可以有多个泛型

    1. package com.jshedu.generic;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class CustomInterfaceGeneric {
    public static void main(String[] args) {

    }
}

/**
 *  泛型接口使用的说明
 *  1. 接口中，静态成员也不能使用泛型
 *  2. 泛型接口的类型, 在继承接口或者实现接口时确定
 *  3. 没有指定类型，默认为Object
 */

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

}
//当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
//，在实现IUsu接口的方法时，使用String替换U, 是Double替换R
class AA implements IA {

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

    }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }
}

//实现接口时，直接指定泛型接口的类型
//给U 指定Integer 给 R 指定了 Float
//所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
class BB implements IUsb<Integer, Float> {

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

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}
//没有指定类型，默认为Object
//建议直接写成 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) {
    }
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }

}

interface IUsb<U, R> {

    int n = 10;
    //U name; 不能这样使用

    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1, R r2, U u1, U u2);

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

  5. 自定义泛型方法

    1. package com.jshedu.generic;

import java.util.ArrayList;

/**
 * @author 韩顺平
 * @version 1.0
 * 泛型方法的使用
 */
@SuppressWarnings({"all"})
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
        System.out.println("=======");
        car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型

        //测试
        //T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}

//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类

    public void run() {//普通方法
    }
    //说明 泛型方法
    //1. <T,R> 就是泛型
    //2. 是提供给 fly使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}

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

    }
    //说明
    //1. 下面hi方法不是泛型方法
    //2. 是hi方法使用了类声明的 泛型
    public void hi(T t) {
    }
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }

}

      注意格式

  6. 例题

    package com.hspedu.customgeneric;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class CustomMethodGenericExercise {
    public static void main(String[] args) {
        //T->String, R->Integer, M->Double
        Apple<String, Integer, Double> apple = new Apple<>();
        apple.fly(10);//10 会被自动装箱 Integer10, 输出Integer
        apple.fly(new Dog());//Dog

    }
}

class Apple<T, R, M> {//自定义泛型类

    public <E> void fly(E e) {  //泛型方法
        System.out.println(e.getClass().getSimpleName());
    }

    //public void eat(U u) {}//错误，因为U没有声明
    public void run(M m) {
    } //ok
}

class Dog {
}

    注意字母代表的什么类型

  7. 泛型的继承和通配符

    1. package com.hspedu;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 韩顺平
 * @version 1.0
 * 泛型的继承和通配符
 */
public class GenericExtends {
    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<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
//        printCollection2(list1);//×
//        printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×


        //冒泡排序

        //插入排序

        //....


    }
    // ? extends AA 表示 上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是Object
            System.out.println(object);
        }
    }



    // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

}

class AA {
}

class BB extends AA {
}

class CC extends BB {
}

      泛型没有继承性

  8. Junit测试框架

    1. 一个类有很多功能代码需要测试，为了测试，就需要写入main方法中，就需要来回注销，切换很麻烦。如果可以直接运行一个方法就方便很多。

    2. package com.jshedu;

import org.junit.jupiter.api.Test;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class JUnit_ {
    public static void main(String[] args) {
        //传统方式
        //new JUnit_().m1();
        //new JUnit_().m2();

    }


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

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

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

      @Test

    3. //定义一个Map 成员变量Map的键为String类型，值为T类型 
private Map<String,T> map = new HashMap<>();
枯寂麻辣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java泛型02：自定义泛型类、泛型方法
小贺想改变
10-16 1200
对自定义泛型类、泛型方法的详细解释
java基础之反射和泛型以及注解
08-30
泛型主要用于定义类、接口和方法，以限制可以传递给它们的对象类型。在上述代码中，`GenericTest`类展示了如何声明一个泛型类，`<T>`表示一个类型参数，可以由使用该类的代码指定。`save()`方法是一个泛型方法，`, K...
【Java】自定义泛型类
dengmsjava的博客
03-30 5462
自定义泛型类 (1) 语法：Class 类名<T, R…>{//…表示可以有多个泛型成员}，T，R和M为泛型的标识符，一般是单个大写字母。 (2) 使用注意事项： ① 普通成员（属性、方法）可以是使用泛型； ② 使用泛型的数组，不能初始化； ③ 静态方法中不能使用类的泛型，因为静态是和类相关的，在类加载时，对象还没有创建，所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化； ④ 泛型类的类型是在创建对象时确定的（因为创建对象时，需要指定确定类型）；
自定义泛型
weixin_53616401的博客
05-10 1073
class 类名{//...表示可以有多个泛型 成员interface接口名...修饰符返回类型 方法名(参数列表)代码演示：因为U没有声明，因此在编译的时候，会报错//10 会被自动装箱 Integer10, 输出Integer//Dogclass Apple {//自定义泛型类public void fly(E e) { //泛型方法//public void eat(U u) {}//错误，因为U没有声明。
Java初学笔记20-【泛型、自定义泛型类、自定义泛型接口、自定义泛型方法、泛型的继承和通配符、JUnit】
爱吃凉拌辣芒果的博客
10-25 236
Java初学笔记20
Java自学笔记——自定义泛型
weixin_43880212的博客
11-26 296
Java自学笔记——自定义泛型 特点 定义以下的Tiger类，省略部分get set 方法 class Tiger<T, R, M>{ String name; R r; T t; M m; //泛型数组不能初始化 //数组在 new 时无法确定T的类型，无法确定开辟多少空间，因此只能定义 //T[] ts = new T[8]; T[] ts; //静态和类相关，在类加载时，对象还没创建，如果使用泛型，JVM就无法完成
JDataStructures:Java中使用泛型的本地数据结构
05-17
使用泛型重新访问常见的数据结构是一种有趣的审查和学习方法。 该项目以TDD样式完成，仅使用Ant构建工具即可完成。 鉴于此，要使用此库，您将需要熟悉命令行/终端的用法。 可用的数据结构类 堆 单链表 进行中的作品...
黑马程序员----泛型与反射的小运用
04-04
泛型的基本语法是在类、接口或方法声明前加上尖括号`<>`，并在其中指定一个或多个类型参数。例如，一个简单的泛型列表类可以定义为`List<T>`，其中`T`就是类型参数，代表任意类型。使用泛型，我们可以创建一个能够...
TestMaximum：使用泛型测试三个值之间的最大整数，浮点数和字符串，并由JUnit测试
03-04
在Java编程语言中，泛型是一种强大的特性，它允许我们创建可以处理多种数据类型的类、接口和方法。在“TestMaximum”项目中，开发者利用泛型来实现一个通用的工具，用于找出三个值中的最大值，这些值可以是整数...
JUnit4.zip
09-06
每个版本都有其特定的改进和更新，例如，JUnit4.11增加了对Java 5和6的泛型支持，改进了测试运行器，添加了新的注解等。 3. **Javadoc**：junit-4.11-javadoc.jar是JUnit4.11版本的API文档，开发者可以通过查阅这个...
JVM 内存结构、垃圾回收机制与并发容器
XHgga_的博客
07-24 772
在现代程序设计中，Java 语言以其强大的功能和广泛的应用被广泛采用。理解 Java 虚拟机（JVM）的内存结构、垃圾回收机制以及并发容器，能够帮助开发人员有效管理内存、提升性能，并编写高效的并发程序。本文将深入探讨这些主题，以期帮助读者更好地理解 Java 的内在机制。
JVM 21 的优化指南：如何进行JVM调优，JVM调优参数有哪些
程序员Linc
07-23 1316
这篇文章将详细介绍如何进行JVM 21调优，包括JVM 21调优参数及其应用。此外，我将提供12个实用的代码示例，每个示例都会结合和Java代码。本文已收录于，我的技术网站，有大厂完整，工作技术，架构师成长之路，等经验分享随着JVM版本的不断更新，JVM 21 在性能和功能上都带来了显著的提升。合理的JVM调优不仅可以提高应用程序的性能，还能显著减少内存消耗和GC（垃圾回收）停顿时间。本文将详细介绍JVM 21 的优化指南，包含如何进行JVM调优以及常见的JVM调优参数，并提供3个实用的代码示例。
JVM系列(二) -类的加载过程
程序员志哥的博客
07-24 656
我们知道 Java 是先通过编译器将.java类文件转成.class字节码文件，然后再通过虚拟机将.class字节码文件加载到内存中来实现应用程序的运行。
JVM：垃圾回收器演进
玉汝于成
07-20 451
ZGC是一种可扩展的低延迟垃圾回收器。ZGC在垃圾回收过程中，STW的时间不会超过一豪秒，适合需要低延迟的应用。支持几百兆到16TB的堆大小，堆大小堆STW的时间基本没有影响。Shenandoah是由Red Hat开发的一款低延迟的垃圾收集器，Shenandoah并发执行大部分GC工作，包括并发的整理，堆大小对STW的时间基本没有影响。ZGC降低了停顿时间，能降低接口的最大耗时，提升用户体验。但是吞吐量不佳，所以如果Java服务比较关注OPS（每秒的查询次数）那么G1是比较不错的选择。
JVM基本知识——类加载机制
weixin_56392989的博客
07-23 841
（Custom ClassLoader）：继承java.lang.ClassLoader实现用户自己的类加载器，通常用来加载一些特殊的类，比如从网络、数据库或特定的二进制流中加载类。
Jvm基础（一）
G81948577的博客
07-19 1008
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
面试题：Java中堆内存和栈内存的区别，缓存数据是把数据放到哪里
weixin_73922932的博客
07-20 621
在Java中，堆内存（Heap）和栈内存（Stack）是两种不同类型的内存区域。它们各自扮演着不同的角色，并具有不同的特性。
秋招突击——7/24——知识补充——JVM类加载机制
最新发布
Blackoutdragon的博客
07-24 942
有攻克了一个难关，好好背一下，至少保证了以后在遇到类似的题目，基本上都能过了！ 今天本来是想看完垃圾回收机制的，但是晚上腰太疼了，就去推拿了，然后出去吃了点东西，回来的比较晚，剩下两个半小时，要把昨天的面经整理好的，就不看垃圾回收机制了！明天做个笔试，应该也不会刷题了，后续要出去旅游，请假三天！回来接着学！
golang 接口
m0_70982551的博客
07-24 869
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Java泛型接口详解与应用
在Java中定义泛型接口与定义泛型类的语法相似，都是在接口名称后加上尖括号`<>`来声明一个类型参数。例如，接口`info<T>`中的`T`就是一个类型参数，代表了某种未知的数据类型。这个`T`可以在接口的方法中使用，如`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值