【JavaSE】泛型学习笔记

于 2025-06-07 17:58:12 发布
阅读量678 收藏 17
点赞数 15
分类专栏： JavaSE 文章标签： 学习 笔记 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24052051/article/details/148498660
版权

泛型

-泛型的理解和好处

  • 使用传统方法的问题

    1. 不能对加入到集合 ArrayList中的数据类型进行约束(不安全)
    2. 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

  • 泛型的好处

    1. 编译时，检查添加元素的类型，提高了安全性

    2. 减少了类型转换的次数,提高效率

      √ 不使用泛型

      Dog ->Object ->Dog //放入到ArrayList 会先转成 Object,在取出时，还需要转换成Dog

      √ 使用泛型Dog -> Dog -> Dog //放入时，和取出时，不需要类型转换，提高效率

    3. 不再提示编译警告

-泛型介绍

  1. 泛型又称参数化类型，是Jdk5.0 出现的新特性,解决数据类型的安全性问题
  2. 在类声明或实例化时只要指定好需要的具体的类型即可。
  3. Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
  4. 泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型

-泛型使用举例

package com.xijie.generic;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * 创建 3个学生对象放入到 HashMap中，要求Key 是 String name, Value就是 学生对象使用两种方式遍历
 */
public class GenericPractice {
    public static void main(String[] args) {
        HashMap<String, Student> map = new HashMap<String, Student>();

        map.put("xiaoming",new Student("xiaoming"));
        map.put("lala",new Student("lala"));
        map.put("xiaohong",new Student("xiaohong"));

        for (String key : map.keySet()) {
            Student student = map.get(key);
            System.out.println("key="+key+" value="+student);
        }

        Iterator<Map.Entry<String, Student>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String,Student> next =  iterator.next();
            System.out.println("key="+next.getKey()+" value="+next.getValue());
        }
    }
}

class Student{
    String name;

    public Student(String name) {
        this.name = name;
    }

    public String getName() {

        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

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

    1. interface List{},public class HashSet…等等

      说明:T,E只能是引用类型

      看看下面语句是否正确?:

      List list = new ArnayList();

      List list2 = new ArrayList();

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

    3. 泛型使用形式

      Listlist1 = new ArrayList();

      List list2 = new ArrayList<>();

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

-自定义泛型

  • 自定义泛型类

    基本语法

    class 类名<T, R...>{
	成员
}

  • 自定义泛型接口注意细节

    1. 普通成员可以使用泛型(属性、方法)
    2. 使用泛型的数组，不能初始化
    3. 静态方法中不能使用类的泛型
    4. 泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)
    5. 如果在创建对象时，没有指定类型，默认为Object

  • 自定义泛型接口

    基本语法

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

  • 自定义泛型接口注意细节

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

  • 自定义泛型方法

    基本语法

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

    }
    注意细节

    1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中
    2. 当泛型方法被调用时，类型会确定
    3. public void eat(E e)}，修饰符后没有<T,R…>eat方法不是泛型方法，而是使用了泛型

-泛型的继承和通配符

  • 泛型的继承和通配符说明
    1. 泛型不具备继承性
      List list = new ArrayList(); // 对吗?
    2. <?>:支持任意泛型类型
    3. <?extends A>:支持A类以及A类的子类，规定了泛型的上限
    4. <? super A>: 支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

-JUnit

  • 为什么需要JUnit

    1. 一个类有很多功能代码需要测试，为了测试就需要写入到main方法中
    2. 如果有多个功能代码测试，就需要来回注销，切换很麻烦
    3. 如果可以直接运行一个方法，就方便很多，并且可以给出相关信息，就好了->JUnit

  • 基本介绍

    1. JUnit是一个Java语言的单元测试框架
    2. 多数Java的开发环境都已经集成了JUnit作为单元测试的工具

-泛型练习

package com.xijie.generic;

import org.junit.jupiter.api.Test;

import java.util.*;

/**
 * 定义个泛型类 DAO<T>，在其中定义一个Map 成员变量，Map 的键为 String 类型，值为T 类型。
 *
 * 分别创建以下方法:
 * (1)public void save(String id,T entity): 保存T类型的对象到 Map 成员变量中
 * (2)publicT get(String id): 从 map 中获取 id 对应的对象
 * (3)public void update(String id,T entity):替换 map 中key为id的内容,改为 entity 对象
 * (4)public List<T> list():返回 map 中存放的所有T 对象
 * (5)public void delete(String id):删除指定 id 对象
 *
 * 定义一个 User 类:该类包含:private成员变量(int类型)id，age;(String 类型)name。
 *
 * 创建 DAO 类的对象，分别调用其 save、get、update、list、delete 方法来操作 User 对象
 *
 * 使用 Junit 单元测试类进行测试。
 */
public class GenericHomework {
    DAO<User> userDAO=new DAO<User>();

    {
        userDAO.save("1",new User(1,"aaa",18));
        userDAO.save("2",new User(2,"bbb",28));
        userDAO.save("3",new User(3,"ccc",38));
        userDAO.save("4",new User(4,"ddd",48));
    }

    @Test
    public void saveTest(){
        System.out.println("-------------saveTest-------------");
        userDAO.save("5",new User(5,"eee",58));
        System.out.println(userDAO);
        System.out.println("-------------saveTest-------------");
    }

    @Test
    public void getTest(){
        System.out.println("-------------getTest-------------");
        System.out.println(userDAO.get("3"));
        System.out.println("-------------getTest-------------");
    }

    @Test
    public void updateTest(){
        System.out.println("-------------updateTest-------------");
        userDAO.update("3",new User(333,"zzz",99));
        System.out.println(userDAO);
        System.out.println("-------------updateTest-------------");
    }

    @Test
    public void listTest(){
        System.out.println("-------------listTest-------------");
        System.out.println(userDAO.list());
        System.out.println("-------------listTest-------------");
    }

    @Test
    public void deleteTest(){
        System.out.println("-------------getTest-------------");
        userDAO.delete("3");
        System.out.println(userDAO);
        System.out.println("-------------getTest-------------");
    }
}

/**
 * 定义个泛型类 DAO<T>，在其中定义一个Map 成员变量，Map 的键为 String 类型，值为T 类型。
 *
 *  * 分别创建以下方法:
 *  * (1)public void save(String id,T entity): 保存T类型的对象到 Map 成员变量中
 *  * (2)publicT get(String id): 从 map 中获取 id 对应的对象
 *  * (3)public void update(String id,T entity):替换 map 中key为id的内容,改为 entity 对象
 *  * (4)public List<T> list():返回 map 中存放的所有T 对象
 *  * (5)public void delete(String id):删除指定 id 对象
 */
class DAO<T>{
    Map<String,T> map;

    public DAO() {
        this.map = new HashMap<>();
    }

    //保存T类型的对象到 Map 成员变量中
    public void save(String id,T entity){
        map.put(id,entity);
    }

    //publicT get(String id): 从 map 中获取 id 对应的对象
    public T get(String id){
        return map.get(id);
    }

    //public void update(String id,T entity):替换 map 中key为id的内容,改为 entity 对象
    public void update(String id,T entity){
        //有key才替换
        map.keySet().forEach(key->{
            if(key.equals(id)){
                map.put(id,entity);
            }
        });
    }

    //public List<T> list():返回 map 中存放的所有T 对象
    public List<T> list(){
        return new ArrayList<>(map.values());
    }

    //public void delete(String id):删除指定 id 对象
    public void delete(String id){
        map.remove(id);
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        map.forEach((key, value) -> sb.append(key).append(":").append(value).append("\n"));
        return sb.toString();
    }
}

/**
 * 定义一个 User 类:该类包含:private成员变量(int类型)id，age;(String 类型)name。
 */
class User{
    private int id;
    private String name;
    private int age;

    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值