Java自学笔记——自定义泛型

本文深入探讨Java中的自定义泛型类,包括泛型标识符的使用、泛型在属性和方法中的应用,以及静态成员与泛型的限制。接着,我们讨论泛型接口,如何在实现接口时指定泛型类型,并通过示例展示了泛型方法的定义与使用。此外,还提到了泛型的通配符使用,以及JUnit测试框架的基础知识。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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就无法完成初始化
    //static R r2;

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

    //方法使用泛型
    public R getR() {
        //返回类型返回泛型
        return r;
    }
}
  1. Tiger 后有泛型,所以把 Tiger 称为自定义泛型类
  2. T, R, M 泛型标识符 一般为单个大写字母
  3. 标识符可以有多个
  4. 普通成员可以用泛型(属性、方法)使
  5. 用泛型的数组不能初始化
  6. 静态属性、静态方法不能使用泛型

泛型接口

  • 静态成员不能使用泛型
  • 接口的类型在继承或实现接口时确定
//实现接口时,直接指定泛型接类型  U为Integer  R为Float
//实现IUsb方法时,U替换为Integer  R替换为Float
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替换
//最好写成 class CC implements IUsb<Object, Object>{}
class CC implements IUsb{
    @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 IA extends IUsb<String, Double>{

}

//当我们实现IA接口时,因为IA在继承IUsb接口时,指定T为String R为Double
//在实现IUsb接口时,使用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) {

    }
}
interface IUsb<U, R>{
    //普通方法中,可以使用接口泛型
    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;
    }

}

泛型方法

  • 泛型方法,可以定义在普通类中,也能定义在泛型类中
  • 注意区分泛型方法和使用泛型的方法
/**
 * @author Lspero
 * @version 1.0
 */
public class CustomMethodGenertic {
    public static void main(String[] args) {
        Car car = new Car();
        //调用方法时,传入参数,编译器会自动确认
        car.fly("宝马", 100);
    }
}

//泛型方法,可以定义在普通类中,也能定义在泛型类中
//普通类
class Car{
    public void run(){

    }

    //<T, R>是泛型 提供给fly使用
    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){

    }

    //不是泛型方法,而是hi()方法使用了类申明的泛型
    public void hi(T t){

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

通配符

public class GenerticExtends {
    public static void main(String[] args) {
        Object o = new String("xx");
        //泛型没有继承性
        //List<Object> list = new ArrayList<String>();

        /*
        通配符
        <?> 任意类型
        <? extends A> A及其子类,表示上限
        <? super A>   A及其父类,表示下限
         */
    }
}

JUnit

JUnit是Java的一种测试框架,测试时不需要在main方法里调用即可运行,方法前加@Test

/**
 * @author Lspero
 * @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 方法");
    }

    public void m2(){
        System.out.println("m2 方法");
    }

}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值