泛型语法与使用

已于 2023-07-01 00:34:47 修改
阅读量58 收藏
点赞数
分类专栏： 笔记周志 文章标签： 学习 java
于 2023-04-23 23:04:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74163755/article/details/130332784
版权
本文介绍了Java中的泛型概念，包括泛型的声明、使用实例，如ArrayList和HashSet等集合类的泛型应用。同时，讨论了泛型的注意事项，如类型只能是引用类型，以及泛型的继承和通配符的使用，如<?>、<?>extendsA、<?>superA的含义和应用场景。
摘要由CSDN通过智能技术生成

文章目录

泛型的语法

  • 泛型的声明

    interface接口< T >{}和class 类 <K,V>{}

    1. 其中T,K,V代表类型
    2. 任意字母都可以

  • 泛型的实例化

    要在类名后面指定类型参数的值

    eg：

    1. List< String > strlist = new ArrayList< String >();
    2. Iterator< Customer > iterator = customer.iterator
    /**
*泛型使用实例
*/
public class GenericExercise {
    public static void main(String[] args) {

        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 28));
        students.add(new Student("mary", 19));
        for (Student student : students) {
        	System.out.println(student);
        }

        HashMap<String, Student> hm = new HashMap<String, Student>();

        hm.put("milan", new Student("milan", 38));
        hm.put("smith", new Student("smith", 48));
            hm.put("hsp", new Student("hsp", 28));

        Set<Map.Entry<String, Student>> entries = hm.entrySet();
  
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        System.out.println("==============================");
        while (iterator.hasNext()) {
        	Map.Entry<String, Student> next = iterator.next();
        	System.out.println(next.getKey() + "-" + next.getValue());
        }
    }
}

class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
    	this.name = name;
    	this.age = age;
    }
    public String getName() {
    	return name;
    }
    public void setName(String name) {
    	this.name = name;
    }
    public int getAge() {
    	return age;
    }
        public void setAge(int age) {
    	this.age = age;
    }
    @Override
    public String toString() {
    	return "Student{" +
        "name='" + name + '\'' +
        ", age=" + age +
        '}';
    }
}

    泛型使用的注意事项和细节

    1. interface List< T>{ , public class HashSet< E>()… 等等
      说明：T,E只能是引用类型
      看看下面语句是否正确？：
      List< Integer > list=new ArrayList< Integer>0:/
      List< int> list2 = new ArrayList< int>0://错误

    2. 在给泛型指定具体类型后，可以传入该类型或者其子类类型

    3. 泛型使用形式
      List< Integer> list1 = new ArrayList< Integer>0;
      List< Integer> list2=new ArrayList<>();[说明：］
      如果我们这样写 List list3=new ArrayList();默认给它的泛型是［＜E>E就是 Object]

    /**
*泛型注意事项
*/
public class GenericDetail {
  public static void main(String[] args) {

      List<Integer> list = new ArrayList<Integer>(); 

      Pig<A> aPig = new Pig<A>(new A());
      aPig.f();
      Pig<A> aPig2 = new Pig<A>(new B());
      aPig2.f();

      ArrayList<Integer> list1 = new ArrayList<Integer>();
      List<Integer> list2 = new ArrayList<Integer>();

      ArrayList<Integer> list3 = new ArrayList<>();
      List<Integer> list4 = new ArrayList<>();
      ArrayList<Pig> pigs = new ArrayList<>();

      ArrayList arrayList = new ArrayList();
      
      Tiger tiger = new Tiger();

  }
}
class Tiger<E> {
      E e;
      public Tiger() {}
      public Tiger(E e) {
      	this.e = e;
      }
}
class A {}
class B extends A {}
class Pig<E> {
      E e;
      public Pig(E e) {
      	this.e = e;
      }
      public void f() {
          System.out.println(e.getClass());
      }
}

自定义泛型类

  • 基本语法

    class类名<T,R…>{}

  • 注意细节

    1. 普通成员可以使用泛型（属性、方法）
    2. 使用泛型的数组，不能初始化
    3. 静态方法中不能使用类的泛型
    4. 泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）
    5. 如果在创建对象时，没有指定类型，默认为Object
    /**
*泛型基本使用
*/
public class CustomGeneric_ {
    public static void main(String[] args) {

        Tiger<Double,String,Integer> g = new Tiger<>("john");
        g.setT(10.9); 
        System.out.println(g);
        Tiger g2 = new Tiger("john~~");
        g2.setT("yy"); 
        System.out.println("g2=" + g2);
    }
}

class Tiger<T, R, M> {
    String name;
    R r; 
    M m;
        T 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;
    }
}

    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() {
    }
    public void setM(M m) {
        his.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) +
        '}';
    }
}

  • 自定义泛型接口

    • 基本语法

      interface接口名<T,R…>{}

    • 注意细节

      1. 接口中，静态成员也不能使用泛型（和泛型类规定一样）
      2. 泛型接口的类型，在继承接口或者实现接口时确定
      3. 没有指定类型，默认为Object
    /**
*自定义泛型接口
*/


interface IA extends IUsb<String, Double> {
}

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) {
    }
}

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) {
    }
}

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 IUsb<U, R> {
    int n = 10;

    R get(U u);
    void hi(R r);
    void run(R r1, R r2, U u1, U u2);

    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) {
        Car car = new Car();
        car.fly("宝马", 100);
        System.out.println("=======");
        car.fly(300, 100.1);

        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}

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) {
    }

    public<K> void hello(R r, K k) {
    	System.out.println(r.getClass());
    	System.out.println(k.getClass());
    }
}

泛型的继承和通配符

  • 泛型的继承和通配符说明

    1. 泛型不具备继承性

    2. <?>:支持任意泛型类型
    3. <?extends A>:支持A类以及A类的子类，规定了泛型的上限
    4. <?super A>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限 
      /**
*泛型的继承
*/
public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("xx");
        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<>();
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);

        printCollection3(list1);
        printCollection3(list3);
            }
        public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
        	System.out.println(object);
        }
	}
    public static void printCollection1(List<?> c) {
        for (Object object : c) { 
        	System.out.println(object);
        }
    }
    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 {
}
Rillia
关注
专栏目录
Java 7菱形语法与泛型构造器实例分析
08-25
Java 7菱形语法与泛型构造器实例分析 Java 7菱形语法与泛型构造器是 Java 语言中的两个重要概念，本文将对其进行详细的分析和讲解。菱形语法是 Java 7 中引入的一种新的语法特性，它可以简化泛型类型的书写，使...
集合与泛型
01-12
- **语法**：定义一个泛型类或接口时，在类名或接口名后加上尖括号`<>`，并在其中指定类型参数，通常使用大写字母如`T`、`E`等表示。例如，`class MyGenericClass<T>`。 - **类型参数使用**：类型参数可以在类或接口...
学习泛型语法3
05-16
标题"学习泛型语法3"表明我们将深入探讨泛型的高级用法和实践，这通常包括对之前学习的泛型语法1和泛型语法2的巩固和扩展。 在描述中提到，“泛型语法1 和 泛型语法2 练习实例”意味着我们已经接触过泛型的基本概念...
学习泛型语法1
05-16
泛型是Java编程语言中的一个强大特性，它允许在类、接口和方法中使用类型参数，从而...文件“01_泛型语法(上).wmv”很可能是这个教程的视频部分，包含了上述所有概念的详细讲解，帮助你更直观地理解和掌握泛型的使用。
Java中泛型通配符的使用方法示例
08-25
Java 中泛型通配符的使用方法示例主要介绍了 Java 中泛型通配符的使用方法，结合实例形式分析了 Java 中泛型通配符的功能、语法及在泛型类创建泛型对象中的使用方法。以下是 Java 中泛型通配符的使用方法示例的知识...
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 811
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
【学习笔记】手写Tomcat 二
LearnTech_123的博客
09-11 1055
在昨天的基础上，再进一步优化，能够响应HTML文件，图片等静态资源。
看Threejs好玩示例，学习创新与技术(二)
最新发布
htsitr2的专栏
09-14 240
它的主要特点是确保生成的点之间保持一定的最小距离，从而避免点的聚集。这种方法在计算机图形学、游戏开发、物理模拟等领域中非常有用，尤其是在需要生成自然分布的对象（如树木、石头等）时。如果不进行裁剪，那么效果如下（初步的锯齿感是因为矩形内采样的结果）。为啥这么复杂呢，为啥不开始存储每个方块的UV呢？下面代码的vTexCoords（=savedModelMatrix，已修改）记录方块所在的位置，vWorldPosition表示方块中像素的偏移。在上面那副图中，聪明的你一定初步猜到了每个方块的纹理是怎么得到的。
计算几何学习
网安小白
09-12 427
学习计算几何过程中对经典算法的记录
网络工程师学习笔记——网络互连与互联网
2301_77279557的博客
09-14 664
网络互连相关技术
Qt之OpenCv 灰度处理、均值滤波、边缘检测学习
weixin_57695658的博客
09-11 1208
本章来学习一下opencv常见的操作，首先看下我们的Qt制作好的界面：源码在后面。
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
2401_84466224的博客
09-11 873
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
【学习笔记】SSL密码套件之哈希
Taki_UP的博客
09-12 1079
本篇介绍了TLS/SSL密码套件中常用的哈希算法，包括Poly1305、SHA384、SHA256、SHA、MD5
区块链学习笔记2--区块链技术的形成 以太坊
weixin_61074128的博客
09-10 377
以太坊的定义：以太坊是运行在一个计算机网络中的软件，他确保数据以及智能合约的小程序可以在没有宗信协调者的情况下，被所有网络中的计算机复制和处理。以太坊的改进： 交易速度加快；pow+pos算法，逐步向pos算法过渡；智能合约：不受人为因素影响，没有黑幕；比特币的出现让经济贸易变得简单，而比特币系统的不足，也同样被人诟病。于是出现了致力解决比特币不足的“V神”。以太坊的愿景是创建一个无法停止，抗屏蔽（审查）和自我维持的去中心化世界计算机。比特币的不足：交易速度慢；仅仅完成了货币的去中心化。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 430
继续学习头文件的数学函数。
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
nanxiaotao的博客
09-11 856
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
【学习笔记】SSL证书之前向保密
Taki_UP的博客
09-10 713
本篇介绍了密码学中前向保密（Forward Secrecy）的相关内容
java开发中间件学习记录（持续更新中~）
m0_74969835的博客
09-14 1175
Java,Springboot,Springcloud,Redis,Mysql,Rabbitmq,Jvm,Juc等等
多线程学习篇二：Thread常见方法
好记性不如烂笔头
09-14 485
Java 中线程状态有6个，分别为:NEW，RUNNABLE，BLOCKED，WAITING，TIMED_WAITING，TERMINATED。t1 是非守护线程， t2 是守护线程，当 t1 执行完 JVM 中不存在非守护线程，即使 t2 未执行完，也会退出 JVM。运行到 t1 的 join 方法时，t1 运行结束，t2 已运行 1s，所以还需要等到 1s 就可以运行完毕。运行结果：通过打印日志的时间戳，我们可以看出来，如果一个线程的打断标记为 true，则 park 失效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值