码农知识堂 - 1000bd
  •   Python
  •   PHP
  •   JS/TS
  •   JAVA
  •   C/C++
  •   C#
  •   GO
  •   Kotlin
  •   Swift

  • Java筑基28-泛型

    目录

    一、泛型入门

    二、泛型介绍

    三、泛型语法和应用

    1.泛型语法

    2.泛型案例

    3.泛型使用细节

    4.泛型经典练习题

    四、自定义泛型

    1.自定义泛型类

    案例1

    2.自定义泛型接口

    3.自定义泛型方法

    自定义泛型方法练习

    五、泛型的继承和通配符

    六、泛型作业（练习）

    一、泛型入门

    1.使用传统方式

    1. package com.feiyang.basic14;
    2.  
    3. import com.feiyang.static1.main;
    4.  
    5. import java.util.ArrayList;
    6.  
    7. /**
    8.  * @author:飞扬
    9.  * @公众hao：程序员飞扬
    10.  * @description:泛型
    11.  */
    12. public class Generic01 {
    13.     public static void main(String[] args) {
    14.  
    15.         //使用传统方式解决
    16.         ArrayList arrayList = new ArrayList();
    17.         arrayList.add(new Dog("大黄",5));
    18.         arrayList.add(new Dog("黑子",6));
    19.         arrayList.add(new Dog("小花",2));
    20.  
    21.         //加入不小心添加了只猫
    22.         arrayList.add(new Cat("咪咪",3));
    23.  
    24.         for (Object o : arrayList) {
    25.             //向下转型（影响效率）
    26.             Dog o1 = (Dog) o;
    27.             System.out.println(o1.getName() + "-" + o1.getAge());
    28.         }
    29.     }
    30. }
    31.  
    32. class Dog{
    33.     private String name;
    34.     private Integer age;
    35.  
    36.     public Dog(String name, Integer age) {
    37.         this.name = name;
    38.         this.age = age;
    39.     }
    40.  
    41.     public String getName() {
    42.         return name;
    43.     }
    44.  
    45.     public void setName(String name) {
    46.         this.name = name;
    47.     }
    48.  
    49.     public Integer getAge() {
    50.         return age;
    51.     }
    52.  
    53.     public void setAge(Integer age) {
    54.         this.age = age;
    55.     }
    56.  
    57.     @Override
    58.     public String toString() {
    59.         return "Dog{" +
    60.                 "name='" + name + '\'' +
    61.                 ", age='" + age + '\'' +
    62.                 '}';
    63.     }
    64. }
    65.  
    66. class Cat{
    67.     private String name;
    68.     private Integer age;
    69.  
    70.     public Cat(String name, Integer age) {
    71.         this.name = name;
    72.         this.age = age;
    73.     }
    74.  
    75.     public String getName() {
    76.         return name;
    77.     }
    78.  
    79.     public void setName(String name) {
    80.         this.name = name;
    81.     }
    82.  
    83.     public Integer getAge() {
    84.         return age;
    85.     }
    86.  
    87.     public void setAge(Integer age) {
    88.         this.age = age;
    89.     }
    90.  
    91.     @Override
    92.     public String toString() {
    93.         return "Dog{" +
    94.                 "name='" + name + '\'' +
    95.                 ", age='" + age + '\'' +
    96.                 '}';
    97.     }
    98. }

    打印输出：

    大黄-5

    黑子-6

    小花-2

    Exception in thread "main" java.lang.ClassCastException: com.feiyang.basic14.Cat cannot be cast to com.feiyang.basic14.Dog

    at com.feiyang.basic14.Generic01.main(Generic01.java:22)

    2.用泛型解决上面的问题

    1. /**
    2.  * @author:飞扬
    3.  * @公众hao：程序员飞扬
    4.  * @description:泛型
    5.  */
    6. public class Generic02 {
    7.     public static void main(String[] args) {
    8.  
    9.         //使用传统方式解决
    10.         ArrayList arrayList = new ArrayList();
    11.         arrayList.add(new Dog("大黄",5));
    12.         arrayList.add(new Dog("黑子",6));
    13.         arrayList.add(new Dog("小花",2));
    14.  
    15.         //加入不小心添加了只猫
    16.         //arrayList.add(new Cat("咪咪",3));
    17.  
    18. //        for (Object o : arrayList) {
    19. //            //向下转型（影响效率）
    20. //            Dog o1 = (Dog) o;
    21. //            System.out.println(o1.getName() + "-" + o1.getAge());
    22. //        }
    23.  
    24.         for (Dog o : arrayList) {
    25.             System.out.println(o.getName() + "-" + o.getAge());
    26.         }
    27.     }
    28. }

    打印输出：

    大黄-5

    黑子-6

    小花-2

    二、泛型介绍

    1. package com.feiyang.basic14;
    2.  
    3. /**
    4.  * @author:飞扬
    5.  * @公众hao：程序员飞扬
    6.  * @description:泛型介绍
    7.  */
    8. public class Generic03 {
    9.     public static void main(String[] args) {
    10.  
    11.     }
    12. }
    13.  
    14. class Person{
    15.     //属性类型泛型化
    16.     E s;//E表示s的数据类型，该数据类型在定义Person对象的时候指定，即在编译时就确定E是什么类型。
    17.  
    18.     //参数类型泛型化
    19.     public Person(E s) {
    20.         this.s = s;
    21.     }
    22.  
    23.     //返回值类型泛型化
    24.     public E func(){
    25.         return s;
    26.     }
    27. }

    三、泛型语法和应用

    1.泛型语法

    2.泛型案例

    1. package com.feiyang.basic14;
    2.  
    3. import java.util.HashMap;
    4. import java.util.HashSet;
    5. import java.util.Map;
    6. import java.util.Set;
    7.  
    8. /**
    9.  * @author:飞扬
    10.  * @公众hao：程序员飞扬
    11.  * @description:泛型应用案例
    12.  */
    13. public class GenericExercise {
    14.     public static void main(String[] args) {
    15.         HashSet hashSet = new HashSet<>();
    16.         hashSet.add(new Student("tom",35));
    17.         hashSet.add(new Student("jack",16));
    18.         hashSet.add(new Student("feiyang",28));
    19.  
    20.         for (Student student : hashSet) {
    21.             System.out.println(student.getName() + "-" + student.getAge());
    22.         }
    23.  
    24.         HashMap hm = new HashMap<>();
    25.         hm.put("tom",new Student("tom",35));
    26.         hm.put("jack",new Student("jack",16));
    27.         hm.put("feiyang",new Student("feiyang",28));
    28.         Set> entries = hm.entrySet();
    29.         for (Map.Entry entry : entries) {
    30.             System.out.println(entry.getKey() + "-" + entry.getValue());
    31.         }
    32.     }
    33. }
    34.  
    35. class Student{
    36.     private String name;
    37.     private int age;
    38.  
    39.     public Student(String name, int age) {
    40.         this.name = name;
    41.         this.age = age;
    42.     }
    43.  
    44.     public String getName() {
    45.         return name;
    46.     }
    47.  
    48.     public void setName(String name) {
    49.         this.name = name;
    50.     }
    51.  
    52.     public int getAge() {
    53.         return age;
    54.     }
    55.  
    56.     public void setAge(int age) {
    57.         this.age = age;
    58.     }
    59.  
    60.     @Override
    61.     public String toString() {
    62.         return "Student{" +
    63.                 "name='" + name + '\'' +
    64.                 ", age=" + age +
    65.                 '}';
    66.     }
    67. }

    打印输出：

    jack-16

    tom-35

    feiyang-28

    tom-Student{name='tom', age=35}

    jack-Student{name='jack', age=16}

    feiyang-Student{name='feiyang', age=28}

    3.泛型使用细节

    1. package com.feiyang.basic14;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. /**
    7.  * @author:飞扬
    8.  * @公众hao：程序员飞扬
    9.  * @description:泛型使用细节
    10.  */
    11. public class GenericDetail {
    12.     public static void main(String[] args) {
    13.  
    14.         //1.给泛型指定数据类型，要求是引用数据类型，不能是基本数据类型
    15.         ArrayList arrayList = new ArrayList();//OK
    16.         //ArrayList arrayList2 = new ArrayList();//error
    17.  
    18.         //2.给泛型指定具体类型后，可以传入该类型或其子类型
    19.         Pig aPig = new Pig(new A());
    20.         aPig.f();
    21.  
    22.         //Pig bPig = new Pig(new B());//error
    23.         Pig bPig2 = new Pig(new B());//
    24.         bPig2.f();
    25.  
    26.         //3.泛型的使用
    27.         ArrayList list = new ArrayList();
    28.         List list2 = new ArrayList();
    29.  
    30.         //也可以简写（推荐）,编译器会进行类型推断
    31.         ArrayList list3 = new ArrayList<>();
    32.         List list4 = new ArrayList<>();
    33.         List pig = new ArrayList<>();
    34.         
    35.         //如果这样写，泛型默认是Object,
    36.         ArrayList list5 = new ArrayList();//等价与=>ArrayList arrayList1 = new ArrayList();
    37.  
    38.     }
    39. }
    40.  
    41. class A{}
    42. //class B{}
    43. class B extends A{}
    44. class Pig{
    45.     E e;
    46.  
    47.     public Pig(E e) {
    48.         this.e = e;
    49.     }
    50.  
    51.     public void f(){
    52.         System.out.println(e.getClass());
    53.     }
    54. }
      55.  

       

      4.泛型经典练习题
       

       

      1. package com.feiyang.basic14;
      2.  
      3. /**
      4.  * @author:飞扬
      5.  * @公众hao：程序员飞扬
      6.  * @description:生日日期类
      7.  */
      8. public class MyDate implements Comparable{
      9.     private int year;
      10.     private int month;
      11.     private int day;
      12.  
      13.     public MyDate(int year, int month, int day) {
      14.         this.year = year;
      15.         this.month = month;
      16.         this.day = day;
      17.     }
      18.  
      19.     public int getYear() {
      20.         return year;
      21.     }
      22.  
      23.     public void setYear(int year) {
      24.         this.year = year;
      25.     }
      26.  
      27.     public int getMonth() {
      28.         return month;
      29.     }
      30.  
      31.     public void setMonth(int month) {
      32.         this.month = month;
      33.     }
      34.  
      35.     public int getDay() {
      36.         return day;
      37.     }
      38.  
      39.     public void setDay(int day) {
      40.         this.day = day;
      41.     }
      42.  
      43.     @Override
      44.     public String toString() {
      45.         return "MyDate{" +
      46.                 "year=" + year +
      47.                 ", month=" + month +
      48.                 ", day=" + day +
      49.                 '}';
      50.     }
      51.  
      52.  
      53.     //把对日期的排序抽取出来放到MyDate类
      54.     @Override
      55.     public int compareTo(MyDate o) {
      56.         int yearMinus = this.year - o.getYear();
      57.         if(yearMinus !=0){
      58.             return yearMinus;
      59.         }
      60.  
      61.         int monthMinus = this.month - o.getMonth();
      62.         if(monthMinus !=0){
      63.             return monthMinus;
      64.         }
      65.  
      66.         return this.day - o.getDay();
      67.     }
      68. }
      69.  
      70.  
      71. package com.feiyang.basic14;
      72.  
      73. /**
      74.  * @author:程序员飞扬
      75.  * @公众hao：程序员飞扬
      76.  * @description:雇员类
      77.  */
      78. public class Employee {
      79.     private String name;
      80.     private Double sal;
      81.     private MyDate birthday;
      82.  
      83.     public Employee(String name, Double sal, MyDate birthday) {
      84.         this.name = name;
      85.         this.sal = sal;
      86.         this.birthday = birthday;
      87.     }
      88.  
      89.     public String getName() {
      90.         return name;
      91.     }
      92.  
      93.     public void setName(String name) {
      94.         this.name = name;
      95.     }
      96.  
      97.     public Double getSal() {
      98.         return sal;
      99.     }
      100.  
      101.     public void setSal(Double sal) {
      102.         this.sal = sal;
      103.     }
      104.  
      105.     public MyDate getBirthday() {
      106.         return birthday;
      107.     }
      108.  
      109.     public void setBirthday(MyDate birthday) {
      110.         this.birthday = birthday;
      111.     }
      112.  
      113.     @Override
      114.     public String toString() {
      115.         return "Employee{" +
      116.                 "name='" + name + '\'' +
      117.                 ", sal=" + sal +
      118.                 ", birthday=" + birthday +
      119.                 '}';
      120.     }
      121. }
      122. package com.feiyang.basic14;
      123.  
      124. import java.util.ArrayList;
      125. import java.util.Comparator;
      126.  
      127. /**
      128.  * @author:程序员飞扬
      129.  * @公众hao：程序员飞扬
      130.  * @description:泛型案例
      131.  */
      132. public class GenericExercise02 {
      133.     public static void main(String[] args) {
      134.         ArrayList employees = new ArrayList();
      135.         employees.add(new Employee("alice",2000.00,new MyDate(1980,10,21)));
      136.         employees.add(new Employee("bob",1800.00,new MyDate(2002,6,18)));
      137.         employees.add(new Employee("alice",3500.00,new MyDate(1980,10,22)));
      138.  
      139.         employees.sort(new Comparator() {
      140.             @Override
      141.             public int compare(Employee o1, Employee o2) {
      142.                 int i = o1.getName().compareTo(o2.getName());
      143.                 if(i != 0 ){
      144.                     return i;
      145.                 }
      146.  
      147.                 int i1 = o1.getBirthday().compareTo(o2.getBirthday());
      148.                 return i1;
      149.             }
      150.         });
      151.  
      152.         //lambda写法
      153.         employees.sort((o1, o2) -> {
      154.             int i = o1.getName().compareTo(o2.getName());
      155.             if(i != 0 ){
      156.                 return i;
      157.             }
      158.  
      159.             int i1 = o1.getBirthday().compareTo(o2.getBirthday());
      160.             return i1;
      161.         });
      162.  
      163.         employees.forEach(employee -> System.out.println(employee));
      164.     }
      165.  
      166. }
       

      打印输出：
       

      Employee{name='alice', sal=2000.0, birthday=MyDate{year=1980, month=10, day=21}}
       

      Employee{name='alice', sal=3500.0, birthday=MyDate{year=1980, month=10, day=22}}
       

      Employee{name='bob', sal=1800.0, birthday=MyDate{year=2002, month=6, day=18}}
       

       

      四、自定义泛型
       

      1.自定义泛型类
       

       

       

      1. package com.feiyang.basic14;
      2.  
      3. /**
      4.  * @author:飞扬
      5.  * @公众hao：程序员飞扬
      6.  * @description:自定义泛型类
      7.  */
      8. public class CustomGeneric_ {
      9.     public static void main(String[] args) {
      10.  
      11.     }
      12. }
      13.  
      14. /**
      15.  * 1.Tiger后面有泛型，所以我们把Tiger成为自定义泛型类
      16.  * 2. T,R,M是泛型的标识类，一般是单个大写字母
      17.  * 3. 泛型标识符可以有多个
      18.  * 4. 普通成员可以使用泛型（属性，方法）
      19.  * 5，使用泛型的数据不能初始化
      20.  * @param 
      21.  * @param 
      22.  * @param 
      23.  */
      24. class Tiger{
      25.     String name;
      26.     T t; //属性使用泛型
      27.     R r;
      28.     M m;
      29.     //T[] tarr = new T[8]; //不可以，因为数组在 new时不能确定T的类型，所有不能开辟内存空间
      30.  
      31.  
      32.     //1. 静态和类相关，在类加载时对象还未创建
      33.     //2. 所以静态方法和静态属性使用了泛型，JVM就无法完成初始化
      34.     //static R r2;
      35.     //public static void m1(M m){
      36.     //
      37.     //}
      38.  
      39.     public Tiger(String name, T t, R r, M m) { //构造器使用泛型
      40.         this.name = name;
      41.         this.t = t;
      42.         this.r = r;
      43.         this.m = m;
      44.     }
      45. }
       

       

      案例1
       

       

      1. package com.feiyang.basic14;
      2.  
      3. /**
      4.  * @author:飞扬
      5.  * @公众hao：程序员飞扬
      6.  * @description:自定义泛型类
      7.  */
      8. public class CustomGeneric_ {
      9.     public static void main(String[] args) {
      10.         Tiger g = new Tiger<>("john");
      11.         g.setT(10.9);//OK
      12.         //g.setT("yy");//错误，类型不对
      13.         System.out.println(g);
      14.         Tiger g2 = new Tiger("john~~");//OK,默认T=Object,R=Object,M=Object
      15.         g2.setT("yy");//OK,因为此时T=Object,而"yy"=String,是Object的子类
      16.         System.out.println(g2);
      17.  
      18.     }
      19. }
      20.  
      21. /**
      22.  * 1.Tiger后面有泛型，所以我们把Tiger成为自定义泛型类
      23.  * 2. T,R,M是泛型的标识类，一般是单个大写字母
      24.  * 3. 泛型标识符可以有多个
      25.  * 4. 普通成员可以使用泛型（属性，方法）
      26.  * 5，使用泛型的数据不能初始化
      27.  * @param 
      28.  * @param 
      29.  * @param 
      30.  */
      31. class Tiger{
      32.     String name;
      33.     T t; //属性使用泛型
      34.     R r;
      35.     M m;
      36.     //T[] tarr = new T[8]; //不可以，因为数组在 new时不能确定T的类型，所有不能开辟内存空间
      37.  
      38.  
      39.     //1. 静态和类相关，在类加载时对象还未创建
      40.     //2. 所以静态方法和静态属性使用了泛型，JVM就无法完成初始化
      41.     //static R r2;
      42.     //public static void m1(M m){
      43.     //
      44.     //}
      45.  
      46.     public Tiger(String name, T t, R r, M m) { //构造器使用泛型
      47.         this.name = name;
      48.         this.t = t;
      49.         this.r = r;
      50.         this.m = m;
      51.     }
      52.  
      53.     public Tiger(String john) {
      54.     }
      55.  
      56.     public String getName() {
      57.         return name;
      58.     }
      59.  
      60.     public void setName(String name) {
      61.         this.name = name;
      62.     }
      63.  
      64.     public T getT() {
      65.         return t;
      66.     }
      67.  
      68.     public void setT(T t) {
      69.         this.t = t;
      70.     }
      71.  
      72.     public R getR() {
      73.         return r;
      74.     }
      75.  
      76.     public void setR(R r) {
      77.         this.r = r;
      78.     }
      79.  
      80.     public M getM() {
      81.         return m;
      82.     }
      83.  
      84.     public void setM(M m) {
      85.         this.m = m;
      86.     }
      87.  
      88.     @Override
      89.     public String toString() {
      90.         return "Tiger{" +
      91.                 "name='" + name + '\'' +
      92.                 ", t=" + t +
      93.                 ", r=" + r +
      94.                 ", m=" + m +
      95.                 '}';
      96.     }
      97. }
       

      输出：
       

      Tiger{name='null', t=10.9, r=null, m=null}
       

      Tiger{name='null', t=yy, r=null, m=null}
       

       

      2.自定义泛型接口
       

       

      1. package com.feiyang.basic14;
      2.  
      3. /**
      4.  * @author:飞扬
      5.  * @公众hao：程序员飞扬
      6.  * @description:
      7.  */
      8. public class CustomInterfaceGeneric_ {
      9. }
      10.  
      11. interface IUsb{
      12.     //普通方法中可以使用接口泛型
      13.     R get(U u);
      14.  
      15.     void hi(R r);
      16.  
      17.     void run(R r1,R r2,U u1,U u2);
      18.  
      19.     //在jdk8中，可以在接口中使用默认方法，也是可以使用泛型
      20.     default R method(U u){
      21.         return null;
      22.     }
      23.  
      24.     /**
      25.      * 泛型接口使用说明：
      26.      * 1. 接口中，静态成员不能使用泛型
      27.      */
      28.     int n = 10;
      29.     //U name;//静态成员不能使用泛型
      30.  
      31. }
      32.  
      33. //在继承接口时，指定泛型接口的类型
      34. interface IA extends IUsb{
      35.  
      36. }
      37.  
      38. //当我们继承IA接口时，因为IA接口继承IUsb接口时指定了U为String,R为Double,
      39. //所以重写IUsb接口的方法时，用String替换了U，用Double替换了R。
      40. class AA implements IA{
      41.  
      42.     @Override
      43.     public Double get(String s) {
      44.         return null;
      45.     }
      46.  
      47.     @Override
      48.     public void hi(Double aDouble) {
      49.  
      50.     }
      51.  
      52.     @Override
      53.     public void run(Double r1, Double r2, String u1, String u2) {
      54.  
      55.     }
      56. }
      57.  
      58. //在实现接口时直接指定泛型接口的类型
      59. //给U指定Integer，给R指定Float
      60. //所以当我们实现IUsb接口时，会用Integer替换U，用Float替换R
      61. class BB implements IUsb{
      62.  
      63.     @Override
      64.     public Float get(Integer integer) {
      65.         return null;
      66.     }
      67.  
      68.     @Override
      69.     public void hi(Float aFloat) {
      70.  
      71.     }
      72.  
      73.     @Override
      74.     public void run(Float r1, Float r2, Integer u1, Integer u2) {
      75.  
      76.     }
      77. }
       

       

      3.自定义泛型方法
       

       

       

       

      自定义泛型方法练习
       

       

      1. package com.feiyang.basic14;
      2.  
      3. /**
      4.  * @author：飞扬
      5.  * @公众hao：程序员飞扬
      6.  * @description:
      7.  */
      8. public class CustomMethodGenericExercise {
      9.     public static void main(String[] args) {
      10.         Apple apple = new Apple<>();
      11.         apple.fly(10);
      12.         apple.fly(new Dog2());
      13.  
      14.     }
      15. }
      16.  
      17. class Dog2{}
      18.  
      19. class Apple{
      20.     public  void fly(E e){
      21.         System.out.println(e.getClass().getSimpleName());
      22.     }
      23.  
      24.     //错误，下面的方法并不是泛型方法，只是想使用类声明的泛型，然而类并没有声明泛型U
      25.     //public void eat(U u){}
      26.  
      27.     //使用了泛型类声明的泛型M
      28.     public void rnn(M m){}
      29. }
       

      输出：
       

      Integer
       

      Dog2
       

       

      五、泛型的继承和通配符
       

       

      1. package com.feiyang.basic14;
      2.  
      3. import java.util.ArrayList;
      4. import java.util.List;
      5.  
      6. /**
      7.  * @author：飞扬
      8.  * @公众hao：程序员飞扬
      9.  * @description:
      10.  */
      11. public class GenericExtends {
      12.     public static void main(String[] args) {
      13.         Object xx = new String("xx");//这样可以
      14.  
      15.         List list = new ArrayList();//可以，多态的体现
      16.         //List list0 = new ArrayList();//不可以，泛型不具有继承性
      17.  
      18.         //举例说明几个方法的使用
      19.         List list1  = new ArrayList();
      20.         List list2  = new ArrayList();
      21.         List list3  = new ArrayList();
      22.         List list4  = new ArrayList();
      23.         List list5  = new ArrayList();
      24.  
      25.         //List
      26.         printCollection1(list1);
      27.         printCollection1(list2);
      28.         printCollection1(list3);
      29.         printCollection1(list4);
      30.         printCollection1(list5);
      31.  
      32.         //List
      33. //        printCollection2(list1);//×
      34. //        printCollection2(list2);//×
      35. //        printCollection2(list3);//√
      36. //        printCollection2(list4);//√
      37. //        printCollection2(list5);//√
      38.  
      39.         //List
      40. //        printCollection3(list1);//√
      41. //        printCollection3(list2);//×
      42. //        printCollection3(list3);//√
      43. //        printCollection3(list4);//×
      44. //        printCollection3(list5);//×
      45.  
      46.  
      47.  
      48.     }
      49.  
      50.     //几个方法说明：
      51.     //List表示任意的泛型类型都可以接受
      52.     public static void printCollection1(List c){
      53.         for (Object o : c) {
      54.             System.out.println(o);
      55.         }
      56.  
      57.     }
      58.     //List表示上限，可以接受AAA或AAA的子类
      59.     public static void printCollection2(List c){
      60.         for (Object o : c) {
      61.             System.out.println(o);
      62.         }
      63.  
      64.     }
      65.     //List表示下限，可以接受AAA类或AAA类的父类
      66.     public static void printCollection3(Listsuper AAA> c){
      67.         for (Object o : c) {
      68.             System.out.println(o);
      69.         }
      70.  
      71.     }
      72. }
      73.  
      74. class AAA{
      75.  
      76. }
      77.  
      78. class BBB extends AAA{
      79.  
      80. }
      81.  
      82. class CCC extends BBB{
      83.  
      84. }
        85.  

         

        六、泛型作业（练习）
         

         

        1. package com.feiyang.basic14;
        2.  
        3. /**
        4.  * @author：飞扬
        5.  * @公众hao：程序员飞扬
        6.  * @description:
        7.  */
        8. public class User {
        9.     private int id;
        10.     private int age;
        11.     private String name;
        12.  
        13.     public User() {
        14.     }
        15.  
        16.     public User(int id, int age, String name) {
        17.         this.id = id;
        18.         this.age = age;
        19.         this.name = name;
        20.     }
        21.  
        22.     public int getId() {
        23.         return id;
        24.     }
        25.  
        26.     public void setId(int id) {
        27.         this.id = id;
        28.     }
        29.  
        30.     public int getAge() {
        31.         return age;
        32.     }
        33.  
        34.     public void setAge(int age) {
        35.         this.age = age;
        36.     }
        37.  
        38.     public String getName() {
        39.         return name;
        40.     }
        41.  
        42.     public void setName(String name) {
        43.         this.name = name;
        44.     }
        45.  
        46.     @Override
        47.     public String toString() {
        48.         return "User{" +
        49.                 "id=" + id +
        50.                 ", age=" + age +
        51.                 ", name='" + name + '\'' +
        52.                 '}';
        53.     }
        54. }
        55. package com.feiyang.basic14;
        56.  
        57. import org.junit.jupiter.api.Test;
        58. import java.util.*;
        59.  
        60. /**
        61.  * @author：飞扬
        62.  * @公众hao：程序员飞扬
        63.  * @description:泛型作业练习
        64.  */
        65. public class HomeWork01 {
        66.     public static void main(String[] args) {
        67.  
        68.     }
        69.  
        70.     @Test
        71.     public void testList(){
        72.         DAO dao = new DAO<>();
        73.         dao.save("01",new User(1,10,"tom"));
        74.         dao.save("02",new User(2,15,"rose"));
        75.         dao.save("03",new User(3,18,"jack"));
        76.  
        77.         //返回所有对象
        78.         List list = dao.list();
        79.         System.out.println(list);
        80.  
        81.         //更新
        82.         dao.update("03",new User(4,20,"bella"));
        83.         List list2 = dao.list();
        84.         System.out.println(list2);
        85.  
        86.         //删除
        87.         dao.delete("01");
        88.         List list3 = dao.list();
        89.         System.out.println(list3);
        90.  
        91.         //根据id获得
        92.         System.out.println("02===" + dao.get("02"));
        93.  
        94.     }
        95. }
        96.  
        97. class DAO {
        98.     private Map map = new HashMap<>();
        99.  
        100.     public T get(String id){
        101.         return map.get(id);
        102.     }
        103.  
        104.     public void update(String id,T entity){
        105.         map.put(id,entity);
        106.     }
        107.  
        108.     //返回map中存放的所有T对象
        109.     public List list(){
        110.         List list = new ArrayList();
        111.  
        112.         Set keySet = map.keySet();
        113.         for (String key : keySet) {
        114.             list.add(get(key));
        115.         }
        116.         return list;
        117.     }
        118.  
        119.     public void save(String id,T entity){
        120.         map.put(id,entity);
        121.     }
        122.  
        123.     public void delete(String id){
        124.         map.remove(id);
        125.     }
        126.  
        127. }
         

        
                
                    
                

                
      85. 

                    相关阅读:
        
                    
并发线程特性-可见性和有序性                            
        
Java开发学习(二十七)----SpringMVC之Rest风格解析及快速开发                            
        
理解http中cookie！C/C++实现网络的HTTP cookie                            
        
python实现Map+函数式接口替换多级if-else结构                            
        
基于springboot，vue停车管理系统                            
        
数据分析方法总结                            
        
轻松驾驭！Prometheus 如何监控指标，快速定位故障                            
        
springboot 链接doris 配置                            
        
教你自己写Arcpy批处理程序                            
        
4.git本地仓库操作（操作命令）                            
        
                            
                
        86. 
                
      86. 
                    原文地址：https://blog.csdn.net/lu_xin5056/article/details/126193147
                
        87. 

            
        

        
        
            
          
                
        • 
                    最新文章
                
          • 
                
        • 
                    
攻防演习之三天拿下官网站群                            
          
数据安全治理学习——前期安全规划和安全管理体系建设                            
          
企业安全 | 企业内一次钓鱼演练准备过程                            
          
内网渗透测试 | Kerberos协议及其部分攻击手法                            
          
0day的产生 | 不懂代码的"代码审计"                            
          
安装scrcpy-client模块av模块异常，环境问题解决方案                            
          
leetcode hot100【LeetCode 279. 完全平方数】java实现                            
          
OpenWrt下安装Mosquitto                            
          
AnatoMask论文汇总                            
          
【AI日记】24.11.01 LangChain、openai api和github copilot                            
          
                              
                
          • 
            
        

            
          
                
        • 
                    热门文章
                
          • 
                
        • 
                    
十款代码表白小特效 一个比一个浪漫 赶紧收藏起来吧！！！                            
          
奉劝各位学弟学妹们，该打造你的技术影响力了！                            
          
五年了，我在 CSDN 的两个一百万。                            
          
Java俄罗斯方块，老程序员花了一个周末，连接中学年代！                            
          
面试官都震惊，你这网络基础可以啊！                            
          
你真的会用百度吗？我不信 — 那些不为人知的搜索引擎语法                            
          
心情不好的时候，用 Python 画棵樱花树送给自己吧                            
          
通宵一晚做出来的一款类似CS的第一人称射击游戏Demo！原来做游戏也不是很难，连憨憨学妹都学会了！                            
          
13 万字 C 语言从入门到精通保姆级教程2021 年版                            
          
10行代码集2000张美女图，Python爬虫120例，再上征途                            
          
                              
                
          • 
            
        

        
        
    




    
    
    
    

        
    
        
        
        
            
        
                
        
                    Copyright © 2022 侵权请联系2656653265@qq.com   
                    京ICP备2022015340号-1
                
        
                
        
                    正则表达式工具
                    cron表达式工具
                    密码生成工具
                
        
                
        
                    
                    
        京公网安备 11010502049817号