泛型generic

最新推荐文章于 2024-10-24 18:32:01 发布
最新推荐文章于 2024-10-24 18:32:01 发布
阅读量110 收藏
点赞数
分类专栏： java基础 文章标签： 多态 java 泛型 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/by2233/article/details/109481262
版权

Java泛型

一、什么是泛型？

Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常.

泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

参数化类型:

  • 把类型当作是参数一样传递
  • <数据类型> 只能是引用类型

相关术语：

  • ArrayList<E>中的E称为类型参数变量
  • ArrayList<Integer>中的Integer称为实际类型参数
  • 整个称为ArrayList<E>泛型类型
  • 整个ArrayList<Integer>称为参数化的类型ParameterizedType
  • 作用：使用多种不同类型的对象重复使用。类型复用。
  • 为什么要用泛型？使用继承，使用Object类同样可以实现类型复用，但是Object是所有类的父类，一但遇到向下转型进行强制类型转换，这样很容易产生错误，还有就是使用对象带有Object参数，对象类型的值不明确，容易出错。（不熟悉向下转型可以看看多态）。 泛型使用的是类型参数，不需要类型转换，编译器会检查对象的类型。
    • Collection、Map集合对元素的类型是没有任何限制的。本来我的Collection集合装载的是全部的Dog对象，但是外边把Cat对象存储到集合中，是没有任何语法错误的。
    • 把对象扔进集合中，集合是不知道元素的类型是什么的，仅仅知道是Object。因此在get()的时候，返回的是Object。外边获取该对象，还需要强制转换

    有了泛型以后：

    • 代码更加简洁【不用强制转换】
    • 程序更加健壮【只要编译时期没有警告，那么运行时期就不会出现ClassCastException异常】
    • 可读性和稳定性【在编写集合的时候，就限定了类型】
    public class Gen{
private Object one;
private Object two;
public Gen(){
super();// 默认调用Object构造器
}
public Gen(Object one，Object two){
this.one = one;this.two=two;
}
/**
* 省略 get set
*/
}
 public static void main(String[] args) {
       Gen gen0 = new Gen();
       Object gen1 = new Gen();
       Gen gen2 = (Gen)new Object();
   }

    public class Gen<T>{
private T one;
private T two;
public Gen(){
super();// 默认调用Object构造器
}
public Gen(T one，T two){
this.one = one;this.two=two;
}
/**
* 省略 get set
*/
}
  public static void main(String[] args) {
      Gen<String> stringGen = new Gen<>();
      Object o = new Gen<>();
      Gen gen = new Gen();
  }

    补充:

    泛型的上限：

    • 格式： 类型名称 <? extends 类 > 对象名称
    • 意义： 只能接收该类型及其子类

    泛型的下限：

    • 格式： 类型名称 <? super 类 > 对象名称

    • 意义： 只能接收该类型及其父类型

    <T extends BoundingType>
// T 是 限定类型(BoundingType)的 子类型(SubType)
// T 和 限定类型(BoundingType)可以是类也可以是接口
// T extends Comparable & Serializable 限定类型用"&" 分隔,T 类型变量用","分隔
// 最多有一个限定类型是类,且必须是第一个限定

    类型擦除

    1. 定义一个泛型类型,都会提供一个相应的原始类型(raw type)
    2. 原始类型名就是去掉类型参数后的泛型类型名
    3. 类型变量会被擦除(erased),并替换为其限定类型,无限定类型替换为Object

    限制与局限性

    1. 不能用基本类型实例化类型参数

    2. 运行时查询只适用于原始类型

    3. 不能创建参数化类型数组

      new  Object<String>[10];   // error

    4. 不能实例化类型变量

      T t = new T();  //error

    5. 不能构造泛型数组

      T[] t = new T[10]; //error

    6. 泛型类的静态上下文中引用类型变量无效,不能在静态字段和静态方法中引用类型变量

      static T t; //error 
static T hello(){}; // error

    7. 不能抛出或捕获泛型类的实例,catch语句中不能引用类型变量

       try{...}catch(T e){}   // error

    8. 可以取消对检查型异常的检查,使用注解 @SuppressWarning(“unchecked”) 设置为非检查型异常

    9. 擦除后的冲突

      1,当泛型类型被擦除后,不允许创建引发冲突的条件.

      // 冲突
public class OBJ<T>{
    public boolean equals (T t){...}
}
public class OBJ<String>{
    public boolean equals (String str){...}
    public boolean equals (Object obj){...}
}
// 解决办法 重命名冲突方法

      2,限制: 一个类或是类型变量不能同时作为两个接口是同一接口的不同参数化的子类

    泛型继承

    public class Person<T extends Employee>{}
/**
* 类的继承
*/
class Employee{} // 父类
class Manager extends Employee{} // 子类
/**
* 泛型 中	<> 没有任何关系
* 类型安全
*/
class Person<Employee>{}
class Person<Manager>{}
/**
* 泛型的继承
* ArrayList<T>类 实现了 List<T>接口
* ArrayList<Employee> 可以转化成 List<Employee>
*/
interface List<Employee>{}
class ArrayList<Employee> implement List<Employee>{}

    通配符类型

    1. 通配符概念

      // ? 允许参数类型变化
Person<? extends Employee> p;   // 变量
public class Employee {
    @Override
    public String toString() {
        return "Employee";
    }
}
public class Manager extends Employee{
    @Override
    public String toString() {
        return "Manager";
    }
}
public class Person<T extends Employee>{ // 需要 Employee 某个子类型
    public static void main(String[] args) {
        Person<? extends Employee> p1 = new Person<Employee>();
        Person<? extends Employee> p2 = new Person<Manager>(); // 参数类型变化
        System.out.println(p1.toString());
        System.out.println(p2.toString());
        Person<Employee> p3 = new Person<Employee>();
        // Person<Employee> p4 = new Person<Manager>(); // 参数类型不同
        System.out.println(p3.toString());
    }

    @Override
    public String toString() {
        return "Person";
    }
}

    2. 通配符的超类型限定

      /**
* 超类型限定 (supertype bound)
* 类型名称 <? super 类 > 对象名称
* 只能接收该类型及其父类型
**/
Admin<? super Manager> a; 

public class Admin<T extends Manager>{
    public static void main(String[] args) {
        Admin<? super Manager> a = new Admin<Manager>();
        Admin<? super Manager> a2 = new Admin<>();
        System.out.println(a.toString());
        System.out.println(a.toString());
        //Admin<? super Manager> a1 = new Admin<Employee>();
        set(a);
    }
    private static void set(Admin<? super Manager> admin){ 
        // 使用超类型限定通配符的方法不能有返回值
        System.out.println(admin);
    }
    @Override
    public String toString() {
        return "admin";
    }
}

    3. 无限定通配符

      // One<?> o;
public class One<T>{
    public static void main(String[] args) {
        System.out.println(getInstance());
        System.out.println(get(new One<>()));
    }
    public static One<?> getInstance(){ 
        // 返回值只能赋值给Object
        return new One<String>();
    }
    public static String get(One<?> one){ //不需要实际的类型
        return one.toString();
    }

    @Override
    public String toString() {
        return "one";
    }
}

      1. 通配符捕获

        public class BuHuo {
    public static void main(String[] args) {
        Po<Object> po = new Po<>();
        System.out.println(po.getFirst(po.getSecond()));
        swap(po);
    }
    static class Po<T>{

        public Po<T> getFirst(Po<?> po) {
            return new Po<T>();
        }
        public Po<T> getSecond(){
            return new Po<>();
        }

        @Override
        public String toString() {
            return "innerClassPo";
        }
    }
    static void swap(Po<?> p){
       // ? t = p.getFirst();//error
        p.getFirst(p.getSecond());
    }
    static <T> void swapHelper(Po<T> p){ // T 指向那个类型
        Po<T> t = p.getFirst(p.getSecond());
        Po<T> t1 = p.getSecond();
        p.getFirst(t);
        p.getFirst(t1);
    }
}

    .

Tirzano
关注
专栏目录
JVM中的[Ljava.lang.Object； 究竟是什么意思？
daobuxinzi的博客
10-23 2701
这就是表示一个方法，方法有三个参数，类型分别为I，D，L。然后L类型要跟具体的类型，然后以"/"替换包名的"."，L类型的要以“;先来简单的说一下， "["表示数组，后面跟着的是具体的类型。你是不是经常看到控制台输出如题的日志，而似懂非懂的。今天我们就来介绍下这些L啦究竟是些什么东东。大多是基本类型的首字母大写，
泛型Generic
qq_48914206的博客
02-19 389
文章目录泛型为什么要使用泛型Generic泛型的使用泛型类泛型接口泛型方法泛型通配符 泛型 为什么要使用泛型Generic 泛型,JDk1.5新加入的,解决数据类型的安全性问题,其主要原理是在类声明时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型.这样在类声明或实例时只要指定好需要的具体的类型即可. Java泛型可以保证如果程序在编译时没有发出警告,运行时就不会产生ClassCastException异常.同时,代码更加简洁、健壮. Java中的泛型,只在编译阶段有效.在编译过程中,
泛型 Generic
m0_59564754的博客
04-02 535
1. 泛型类 泛型类的定义格式： 格式：修饰符 class 类名 <类型>() 例如：public class Generic T 可以使用任意表示，常见的有 T，E，K，V 等。 1.1泛型类 public class Generic2<T> { private T t; public Generic2() { } public Generic2(T t) { this.t = t; } publ
.Net进阶 —— 泛型generic使用和原理 封装泛型缓存
Cool2Feel的博客
10-08 890
泛型generic使用和原理 封装泛型缓存 一.泛型的由来 泛型基本概念：.NET 泛型是一个很强大的新特性，它为每一种对象生成一份单独的代码(也就是所谓的“实例化”),这一份量身顶做的代码具有很高的效率,是强类型的,不需要运行期多态的支持和负担,有了泛型，就不再需要Object类来参与实现一些通用类或方法了． 泛型的作用： 在CLR(common language runtime)1.0中，当要创建一个灵活的类或方法，但该类或方法在编译期问不知道使用什么类，就必须以System.Object类为基础进.
Java泛型Generic
最新发布
2301_80096362的博客
10-24 345
定义类，接口，方法时，同时声明了一个或多个类型变量，如泛型类，泛型接口，泛型方法泛型可以约束在编译阶段能操作的数据类型，并自动检查。如ArrayList List =new ArrayList();E代表element，元素类型，T代表返回值类型，K键类型，V值类型。一般用E就可以。
泛型Generic的使用
suwu150
08-21 568
编译器的泛型兼容性检查: I.泛型类型和原始类型的兼容性 原始类型可以引用一个泛型类型 eg:List list = new ArrayList<String>(); 泛型类型可以引用一个原始类型的对象eg:List<String> list = new ArrayList();II.类型参数不同的泛型类型不能互相引用,不考虑类型参数间的继承性 List<Object> l = new ArrayList<String>(); //错误 List list ; List<Object> oList ;
泛型Generic2
tangshuai96的博客
10-09 161
调用泛型方法 代码： public class GenericMethodTest { //调用泛型方法 public static void main(String[] args) { GenericMethod gc=new GenericMethod(); gc.mehtod1(12);//传递啥数据就是什么类型； gc.method2("静态方法："); /...
淺談 TypeScript 泛型 Generic
weixin_46803507的博客
05-27 440
淺談 TypeScript 泛型 Generic前言正文什麼是泛型？函數泛型接口泛型React + TS 泛型jsx 泛型組件結語參考 前言 也是最近除了 react 之外之外因應實習的技術棧要求，所以也在學習 ts 相關東西。這篇來說說對於 ts 泛型的一些比較基本，常用的用法吧！常常在看一些源代碼像是 react 源碼時，都會看到這樣的用法，但都不明所以，趁此機會補補下這方面的東西。 正文 什麼是泛型？ 在軟件開發中，我們不僅要創建一致的、定義良好的 API，同時也要考慮可重用性。我們希望組件不僅要能夠
【JAVASE基础】泛型Generic
yu_fu_a_bu的博客
03-15 1274
1.泛型Generic 泛型技术是DK版本一大升级,源自于JDK1.5 泛型就是集合类<泛型> 1.1泛型的安全机制 软件升级:安全性提高,修复Bug错误改善用户体验增加功能,提升性能 JDK1.5里程碑版本 泛型作用 :强制了集合存储固定的数据类型 泛型的书写格式: 集合类<存储的数据类型>变量名 = new集合类<>b; 选择 ●使用泛型的好处: 。安全性提高了 。程序的代码量减少 。避免了类型的强制转换 。程序的问题,由运行时期,提前到编译时期 1.2泛型中的E问
泛型（Generic）
来杯奶茶
09-23 282
泛型的简介： 泛型：标签 举例：中药店每个抽屉外面贴着标签；超市购物架上有很多瓶子，每个瓶子装着什么有标签 泛型的设计背景： 集合容器类在设计阶段、声明阶段不能确定这个容器到底实际存的是什么类型的对象，多以在JDK1.5前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素是如何保存，如何管理等是确定的，因此此时把元素类型设计成一个参数，这个类习惯参数叫做泛型。Collection<E>，...
Dephi泛型generic的应用 .mht
06-10
Dephi泛型generic的应用 .mht
java 泛型Generic
chengyu0726的博客
05-09 237
1. 背景 泛型技术诞生之前（JDK5以前），创建集合的类型都是Object 类型的元素，存储内容没有限制，编译时正常，运行时容易出现ClassCastException 异常。 public class Test { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("java"); list.add(100); list.add(true); for(int i =
QueryRunner常用方法
孔的博客
12-11 5338
maven依赖： <!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils --> <dependency> <groupId>commons-dbutils</groupId> <artifactId>commons-dbutils</artifactId> <version>1.6</version> </dep
Java 打印Hello World
孔的博客
10-30 3981
Java 打印Hello World public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } } Java 环境变量—JDK1.8及以下不能配置ClassPath,会报错找不到主类 JAVA_HOME D:\Programs\win64\Java\jdk1.8.0_201 PAT
java http状态码枚举类
孔的博客
03-16 3861
package com.kongjs.toutiao.common.enums; public enum HttpStatusCode { /** * http状态码枚举所有状态码注解 */ CONTINUE(100, "Continue", "请继续发送请求的剩余部分"), SWITCHING_PROTOCOLS(101, "Switching Protocols", "协议切换"), PROCESSING(102, "Processing", "请求
遍历字符串分别筛选出数字和字母，按照字母在前数字在后的规则组成一个新的字符串
孔的博客
11-01 2601
/* 需求: 提示用户键盘录入一个包含数字和字母的字符串（不做是否包含数字和字母的判断）， 遍历字符串分别筛选出数字和字母（如有符号不包含在字母里）， 按照字母在前数字在后的规则组成一个新的字符串，把组成的新字符串打印在控制台。*/ public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入一个字符串"); .
ArrayList 删除指定元素
孔的博客
10-30 2109
** ArrayList 删除指定元素 ** ArrayList<String> list = new ArrayList<>(); // 直观添加元素 list.add("b"); list.add("a"); list.add("v"); list.add("d"); list.add("b"); list.add("a"); list.add("n"); /** * 正向遍历 删除指定元素 */ for(int i=0;i<list.size(); i++) {
springboot,redis自定义缓存时间配置
孔的博客
06-08 909
@EnableCaching @Configuration(proxyBeanMethods = false) public class RedisCacheManagerConfiguration { // springboot 官方写法 @Bean public RedisCacheManagerBuilderCustomizer myRedisCacheManagerBuilderCustomizer() { return (builder) -> builde
generic 泛型
09-04
泛型（Generic）是一种编程概念，它允许在代码中定义和使用通用的数据类型或函数，而不必指定具体的数据类型。通过使用泛型，我们可以编写更灵活、可复用和类型安全的代码。 在很多编程语言中，泛型可以应用于类、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值