泛型 (generic)

最新推荐文章于 2024-10-12 22:35:37 发布
最新推荐文章于 2024-10-12 22:35:37 发布
阅读量191 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56023706/article/details/123809627
版权

声明:以下笔记来源于韩顺平视频https://www.bilibili.com/video/BV1fh411y7R8?p=1，笔记为楼主亲手劳动，劳动不易，转载请标明谢谢。

泛型 (generic)

泛型的介绍
  1. 泛(广泛)型(类型) => Integer, String,Dog.
  2. 泛型又称参数化类型，是Jdk5.0出现的新特性,解决数据类型的安全性问题
  3. 在类声明或实例化时只要指定好需要的具体的类型即可。
  4. Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
  5. 泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。
  6. 特别强调: E具体的数 据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
泛型的理解与好处

  1. 在不使用泛型时

    • 不能对加入到集合ArrayList中的数据类型进行约束(不安全),在预编译时不提示类型错误

    • 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响。

  2. 使用泛型时

    • 编译时，检查添加元素的类型，提高了安全性
    • 减少了类型转换的次数，提高效率
    • 不在提示编译警告
泛型的语法

  • 泛型的声明

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

  • 泛型的实例化

  • List<String> strList = new ArrayList <String> ();
Iterator<Customer> iterator = customers.iterator();

  • @SuppressWarnings({"all"})
public class GenericExercise {
 public static void main(String[] args) {
     System.out.println("===========HashSet泛型===========");
     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);
     }

     System.out.println("===========HashMap泛型===========");
     HashMap<String,Student> students1 = new HashMap<String,Student>();
     students1.put("jack",new Student("jack",18));
     students1.put("Tom",new Student("Tom",28));
     students1.put("Mary",new Student("Mary",19));

     Set<Map.Entry<String, Student>> entries = students1.entrySet();
     Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
     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{}，public class HashSet {}…等等 T, E 只能是引用类型

    • List <Integer> list = new ArrayList <Integer> ();//正确
List<int> list2 = new ArrayList<int> ();//错误

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

    • Pig<A> aPig = new Pig<A>(new A());
Pig<A> aPig = new Pig<A>(new B());

class A{}
class B extend A{}

  3. 泛型使用形式

    • List<Integer> list1 = new ArrayList< Integer> );
List< Integer> list2 = new ArrayList<>();//推荐使用

  4. 如果我们这样写List list3 = new ArrayList(); 默认给它的泛型是[ E就是Object ]

    • ArrayList arrayList = new ArrayList();
//等价于
ArrayList<Object> arrayList = new ArrayList<>();
泛型练习题

要求:

  1. 该类包含: private成员变量name,sal,birthday,其中birthday为MyDate类的对象;
  2. 为每一个属性定义getter, setter方法;
  3. 重写toString方法输出name, sal, birthday
  4. MyDate类包含: private成员变量month,day,year;并为每一个属性定义 getter,setter方法;
  5. 创建该类的3个对象，并把这些对象放入ArrayList集合中(ArrayList 需使用泛型来定义)，对集合中的元素进行排序，并遍历输出:
  6. 没基础的先自己想一遍最好。
@SuppressWarnings({"all"})
public class MyDate_  implements Comparable<MyDate_>{
 private int year;
 private int month;
 private int day;

 public MyDate_(int year, int month, int day) {
     this.year = year;
     this.month = month;
     this.day = day;
 }

 public int getYear() {
     return year;
 }

 public void setYear(int year) {
     this.year = year;
 }

 public int getMonth() {
     return month;
 }

 public void setMonth(int month) {
     this.month = month;
 }

 public int getDay() {
     return day;
 }

 public void setDay(int day) {
     this.day = day;
 }

 @Override
 public String toString() {
     return "MyDate_{" +
             "year=" + year +
             ", month=" + month +
             ", day=" + day +
             '}';
 }


 @Override
 public int compareTo(MyDate_ o) {//面向对象复用法
     //如果name相同就比较年。
     int yearMinus = year - o.getYear();
     if (yearMinus != 0) {
         return yearMinus;
     }
     //如果name相同就比较月。
     int monthMinus = month - o.getMonth();
     if (monthMinus != 0) {
         return monthMinus;
     }
     //如果name相同就比较日。
     return day - o.getDay();
 }
}


@SuppressWarnings({"all"})
public class Employee_ {
 private String name;
 private double sal;
 private MyDate_ birthday;

 public Employee_(String name, double sal, MyDate_ birthday) {
     this.name = name;
     this.sal = sal;
     this.birthday = birthday;
 }

 public String getName() {
     return name;
 }

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

 public double getSal() {
     return sal;
 }

 public void setSal(double sal) {
     this.sal = sal;
 }

 public MyDate_ getBirthday() {
     return birthday;
 }

 public void setBirthday(MyDate_ birthday) {
     this.birthday = birthday;
 }

 @Override
 public String toString() {
     return "\nEmployee_{" +
             "name='" + name + '\'' +
             ", sal=" + sal +
             ", birthday=" + birthday +
             '}';
 }
}

@SuppressWarnings({"all"})
public class GenericExercise02 {
 public static void main(String[] args) {
     ArrayList<Employee_> employee_s = new ArrayList<>();
     employee_s.add(new Employee_("tom",20000,new MyDate_(2000,11,11)));
     employee_s.add(new Employee_("jack",12000,new MyDate_(2000,12,12)));
     employee_s.add(new Employee_("tom",50000,new MyDate_(1980,10,10)));

     System.out.println(employee_s);

     System.out.println("====对雇员进行排序====");

     employee_s.sort(new Comparator<Employee_>() {
         @Override
         public int compare(Employee_ emp1, Employee_ emp2) {
             //先对传入的参数进行验证
             if (!(emp1 instanceof Employee_ && emp2 instanceof Employee_)) {
                 System.out.println("类型不匹配！");
                 return 0;
             }
             //比较name
             int i = emp1.getName().compareTo(emp2.getName());
             if (i != 0) {
                 return i;
             }
             return emp1.getBirthday().compareTo(emp2.getBirthday());
         }
     });

     System.out.println(employee_s);
 }
}
自定义泛型类

  1. 基本语法

    • class/interface 类名/接口名 <T,R,M,…> {

      成员

      }

  2. 使用细节

      1. 普通成员可以使用泛型(属性、方法)—>(构造器，getter与setter方法)
      2. 使用泛型的数组，不能初始化(因为数组在new不能确定T的类型，就无法在内存开空间)
      3. 静态方法,静态属性中不能使用类的泛型
      4. 泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)
      5. 如果在创建对象时，没有指定类型，默认为Object
      6. T, R, M泛型的标识符，一般是单个大写字母

  3. 自定义泛型类

    • @SuppressWarnings({"all"})
public class CustorGeneric_ <T, R, M>{
 String name;
 T t;
 R r;
 M m;

 //使用泛型的数组，不能初始化(因为数组在new不能确定T的类型，就无法在内存开空间)
//    M[] mm = new M[8];

 //静态方法,静态属性中不能使用类的泛型
//     static T tt;
//    public static void m1(M m){}


 public CustorGeneric_(String name, T t, R r, M m) {
     this.name = name;
     this.t = t;
     this.r = r;
     this.m = m;
 }



 public T getT() {
     return t;
 }

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

 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;
 }
}
自定义泛型接口

  1. 基本语法

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

  2. 使用细节

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

  3. 自定义接口

    • @SuppressWarnings({"all"})
public class CustorInterfaceGeneric_ {
}

class CC implements IUsb {//不指定参数类型默认为default
 @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 BB extends IUsb<String,Integer> {}
class AA implements IUsb<String, Integer> {
 @Override
 public Integer get(String s) {
     return null;
 }

 @Override
 public void hi(Integer integer) {

 }

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

 }
}

interface IUsb<U, R> {
 //接口的参数是 public static final
 //    U 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;
 }
}
自定义泛型方法

  1. 基本语法

    • 修饰符<T,R… >返回类型方法名(参数列表) {
      }

  2. 注意细节

      1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中
      2. 当泛型方法被调用时，类型会确定
      3. public void eat(E e) {},修饰符后没有<T,R…> eat方法不是泛型方法，而是使用了泛型
      4. 当调用方法时，传入参数，编译器，就会确定类型
      5. 泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型

  3. 自定义泛型接口

    • @SuppressWarnings({"all"})
public class CustorMethodGeneric_ {
 public static void main(String[] args) {
     Car car = new Car();
     car.fly("宝马",100);//当调用方法时，传入参数，编译器，就会确定类型
     System.out.println("===============");
     fish<String, ArrayList> fish = new fish<>();
     fish.hello(new ArrayList(),13.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 fly(U u,M m) {}//泛型方法
 public void hi(T t1) {//使用了泛型，并非泛型方法
 }
 //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
 public<K> void hello(R r, K k){
     System.out.println(k.getClass());
     System.out.println(r.getClass());
 }
}
泛型的类型及通配符

  1. 泛型不具有继承性

    •      Object obj = new String("xx");//可以
//      泛型没有继承性
//        ArrayList<Object> strings = new ArrayList<String>();
  2. <?> :`支持任意泛型类型`
  3. <? extends A>:支持A类以及A类的子类，`规定了泛型的上限`
  4. <? super A>:支持A类以及A类的父类，不限于直接父类，`规定了泛型的下限` 
  5. @SuppressWarnings({"all"})
public class GenericExtends_ {
 public static void main(String[] args) {

     Object obj = new String("xx");//可以
     //      泛型没有继承性
     //        ArrayList<Object> strings = new ArrayList<String>();

     ArrayList<Object> l1 = new ArrayList<>();
     ArrayList<String> l2 = new ArrayList<>();
     ArrayList<AA> l3 = new ArrayList<>();
     ArrayList<BB> l4 = new ArrayList<>();
     ArrayList<CC> l5 = new ArrayList<>();

     // public static void printCollection1(List<?> c)
     //? 表示可以接收任意类型
     printCollection1(l1);//√
     printCollection1(l2);//√
     printCollection1(l3);//√
     printCollection1(l4);//√
     printCollection1(l5);//√


     //public static void printCollection2(List<? extends AA> c)
     //? extends AA 表示可以接收AA或其子类
     //        printCollection2(l1);//√
     //        printCollection2(l2);//√
     printCollection2(l3);//√
     printCollection2(l4);//√
     printCollection2(l5);//√


     //public static void printCollection3(List<? super AA> c)
     //? super AA 表示可以接收AA或父类 ，不限于直接父类
     printCollection3(l1);//√
     //        printCollection3(l2);//√
     printCollection3(l3);//√
     //        printCollection3(l4);//√
     //        printCollection3(l5);//√


 }

 //? 表示可以接收任意类型
 public static void printCollection1(List<?> c) {
     for (Object o : c) {
         System.out.println(o);
     }
 }

 //? extends AA 表示可以接收AA或其子类
 public static void printCollection2(List<? extends AA> c) {
     for (Object o : c) {
         System.out.println(o);
     }
 }

 //? super AA 表示可以接收AA或父类 ，不限于直接父类
 public static void printCollection3(List<? super AA> c) {
     for (Object o : c) {
         System.out.println(o);
     }
 }
}

class AA{}
class BB extends AA{}
class CC extends BB{}
JUnit 单元测试类
  1. JUnit是一个Java语言的单元测试框架
  2. 多数Java的开发环境都已经集成了JUnit作为单元测试的工具
何患现在@何惧将来
关注
专栏目录
泛型Generic
qq_48914206的博客
02-19 382
文章目录泛型为什么要使用泛型Generic泛型的使用泛型类泛型接口泛型方法泛型通配符 泛型 为什么要使用泛型Generic 泛型,JDk1.5新加入的,解决数据类型的安全性问题,其主要原理是在类声明时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型.这样在类声明或实例时只要指定好需要的具体的类型即可. Java泛型可以保证如果程序在编译时没有发出警告,运行时就不会产生ClassCastException异常.同时,代码更加简洁、健壮. Java中的泛型,只在编译阶段有效.在编译过程中,
泛型 Generic
m0_59564754的博客
04-02 525
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 869
泛型generic使用和原理 封装泛型缓存 一.泛型的由来 泛型基本概念：.NET 泛型是一个很强大的新特性，它为每一种对象生成一份单独的代码(也就是所谓的“实例化”),这一份量身顶做的代码具有很高的效率,是强类型的,不需要运行期多态的支持和负担,有了泛型，就不再需要Object类来参与实现一些通用类或方法了． 泛型的作用： 在CLR(common language runtime)1.0中，当要创建一个灵活的类或方法，但该类或方法在编译期问不知道使用什么类，就必须以System.Object类为基础进.
泛型Generic的使用
suwu150
08-21 566
编译器的泛型兼容性检查: 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 151
调用泛型方法 代码： public class GenericMethodTest { //调用泛型方法 public static void main(String[] args) { GenericMethod gc=new GenericMethod(); gc.mehtod1(12);//传递啥数据就是什么类型； gc.method2("静态方法："); /...
淺談 TypeScript 泛型 Generic
weixin_46803507的博客
05-27 427
淺談 TypeScript 泛型 Generic前言正文什麼是泛型？函數泛型接口泛型React + TS 泛型jsx 泛型組件結語參考 前言 也是最近除了 react 之外之外因應實習的技術棧要求，所以也在學習 ts 相關東西。這篇來說說對於 ts 泛型的一些比較基本，常用的用法吧！常常在看一些源代碼像是 react 源碼時，都會看到這樣的用法，但都不明所以，趁此機會補補下這方面的東西。 正文 什麼是泛型？ 在軟件開發中，我們不僅要創建一致的、定義良好的 API，同時也要考慮可重用性。我們希望組件不僅要能夠
【JAVASE基础】泛型Generic
yu_fu_a_bu的博客
03-15 1261
1.泛型Generic 泛型技术是DK版本一大升级,源自于JDK1.5 泛型就是集合类<泛型> 1.1泛型的安全机制 软件升级:安全性提高,修复Bug错误改善用户体验增加功能,提升性能 JDK1.5里程碑版本 泛型作用 :强制了集合存储固定的数据类型 泛型的书写格式: 集合类<存储的数据类型>变量名 = new集合类<>b; 选择 ●使用泛型的好处: 。安全性提高了 。程序的代码量减少 。避免了类型的强制转换 。程序的问题,由运行时期,提前到编译时期 1.2泛型中的E问
泛型（Generic）
来杯奶茶
09-23 273
泛型的简介： 泛型：标签 举例：中药店每个抽屉外面贴着标签；超市购物架上有很多瓶子，每个瓶子装着什么有标签 泛型的设计背景： 集合容器类在设计阶段、声明阶段不能确定这个容器到底实际存的是什么类型的对象，多以在JDK1.5前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素是如何保存，如何管理等是确定的，因此此时把元素类型设计成一个参数，这个类习惯参数叫做泛型。Collection<E>，...
泛型Generic理解
YK
12-02 309
测试
泛型generic： 泛型类 泛型方法
sasasada的博客
01-26 209
泛型泛型**泛型类**： 是在实例化的时候指明泛型的具体类型。**泛型方法:** 是在调用方法的时候指明泛型的具体类型. 泛型 泛型类： 是在实例化的时候指明泛型的具体类型。 pubilc class GenericClass<T> { private T attr; pubilc void setValue(T a) { this.attr = a; } public T getValue() { return this.attr; } } 泛型方法: 是在调
Dephi泛型generic的应用 .mht
06-10
Dephi泛型generic的应用 .mht
java 泛型Generic
chengyu0726的博客
05-09 226
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 =
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1465
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Java分布式锁
最新发布
juanmiao的专栏
10-12 655
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 870
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 675
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Backend - Java 基础
是萝卜干呀的博客
10-11 832
知识量决定了未来能走多远
JavaSE——认识异常
wx2023_10_15的博客
10-12 955
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
generic 泛型
09-04
泛型（Generic）是一种编程概念，它允许在代码中定义和使用通用的数据类型或函数，而不必指定具体的数据类型。通过使用泛型，我们可以编写更灵活、可复用和类型安全的代码。 在很多编程语言中，泛型可以应用于类、接口和方法。通过使用泛型，我们可以定义一些可以适用于多种数据类型的类或方法，从而提高代码的灵活性和重用性。 泛型的优势包括： 1. 类型安全：泛型可以在编译时检查类型匹配，避免在运行时出现类型错误。 2. 代码重用：通过使用泛型，可以编写通用的代码，适用于多种数据类型，减少代码冗余。 3. 灵活性：使用泛型可以将类型检查和转换的责任移到编译时，可以更方便地处理不同类型的数据。 例如，在Java中，我们可以使用泛型来创建通用的集合类（如List、Map等），以及定义可以适用于多种数据类型的方法。通过使用泛型，我们可以避免在使用集合时进行类型转换，提高代码的可读性和安全性。 总结来说，泛型是一种编程技术，它提供了一种通用的方式来处理不同类型的数据，增加了代码的灵活性和可复用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值