Java基础篇泛型补充

最新推荐文章于 2024-07-14 22:18:32 发布
最新推荐文章于 2024-07-14 22:18:32 发布
阅读量148 收藏 8
点赞数 15
分类专栏： # JavaSE 文章标签： java 开发语言 java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44606952/article/details/124806864
版权

CSDN话题挑战赛第1期
活动详情地址：https://marketing.csdn.net/p/bb5081d88a77db8d6ef45bb7b6ef3d7f
参赛话题：Java学习记录
话题描述：可以记录一下平时学习Java中的一些知识点、心得、例题、常见的问题解决

说明

泛型重要的知识点就在于对集合中泛型的使用，以及在开发时中实现对数据库的操作，其他的细小知识点理解即可,不必深究

代码目录

1.1 泛型在继承上的使用

说明
主要测试泛型类被其他的类继承之后的不同情形
Order类

public class Order <T>{

    private String orderName;
    private int orderAge;

    T orderT;

    public Order() {
    }

    public Order(String orderName, int orderAge, T orderT) {
        this.orderName = orderName;
        this.orderAge = orderAge;
        this.orderT = orderT;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public int getOrderAge() {
        return orderAge;
    }

    public void setOrderAge(int orderAge) {
        this.orderAge = orderAge;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    //静态方法中不能使用类的泛型，静态方法的加载是在类的创建的时候，但是泛型的指定是在实例化的时候
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }

    public void test1(){
    }

    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
    //换句话说：泛型方法所属的类是不是泛型类都没有关系
    //在返回值类型前面加一个<E>表示E是一个泛型
    //泛型方法，可以声明为静态的。原因为：泛型参数是在调用方法时确定的，并非在实例化类时确定
    public <E> List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();
        for (E e: arr){
            list.add(e);
        }
        return list;
    }
}

sunOrder类
指名泛型的类型，此时subOrder已经不是一个泛型类

public class subOrder extends Order<Integer>{
    public subOrder() {
    }

    public subOrder(String orderName, int orderAge, Integer orderT) {
        super(orderName, orderAge, orderT);

    }
}

subOrder2类

public class subOrder2<T> extends Order{
}

测试类

public class GenericTest1 {

    @Test
    public void test1(){
        //在Order内定义泛型的属性之后，在进行实例化的时候要指明泛型的类型，
        Order<String> order = new Order<>("李华",25,"2020-05-16");

        //创建一个子类，在继承时直接声明泛型的类型，这样来说子类就不算是泛型类，把泛型的属性已经规定了
        subOrder order1 = new subOrder("李华",15,16);

        //创建一个子类，在继承时没有直接声明泛型的类型，这样来说子类就是泛型类，需要在实例化的时候声明
        //subOrder类中也要将类修改为泛型类才可以
        subOrder2<String> order2 = new subOrder2();

        //静态方法中不能使用类的泛型，静态方法的加载是在类的创建的时候，但是泛型的指定是在实例化的时候
        //    public static void show(T orderT){
//        System.out.println(orderT);
//    }
        }

        @Test
        public void test2(){
            //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
            //    //换句话说：泛型方法所属的类是不是泛型类都没有关系
            //    //在返回值类型前面加一个<E>表示E是一个泛型
            //    public <E> List<E> copyFromArrayToList(E[] arr){
            //
            //        ArrayList<E> list = new ArrayList<>();
            //        for (E e: arr){
            //            list.add(e);
            //        }
            //        return list;
            //    }

            //测试泛型方法
            Order<String> order = new Order<>();
            Integer[] arr = new Integer[]{1,2,3,4,5,6};
            //泛型在调用的时候指明了泛型的类型
            List<Integer> list = order.copyFromArrayToList(arr);
            System.out.println(list);
        }
        //泛型数组的创建
//        E[] e = (E[]) new Object[15];
}

1.2 泛型在开发中的使用举例

模拟实现对数据的增删改查功能
DAO类

public class DAO<T> {//表的共性操作的DAO
    //添加一条数据
    public  void add(T t){

    }

    //删除一条记录
    public boolean delete(T t){
        return false;
    }
    //修改一条数据
    public void update(int index,T t){

    }
    //查询一条数据
    public T getIndex(int index){
        return null;
    }

    //查询多条记录
    public List<T> getForList(int index){
        return null;
    }

    //泛型方法
    public <E> E getIndex(){
        return null;
    }
}

Customer类

public class Customer {

}

CustomerDAO类

public class CustomerDAO extends DAO<Customer>{//只操作客户表
}

Student类

public class Student {
}

StudentDAO类
操作学生类

public class StudentDAO extends DAO<Student>{//只操作学生表

}

测试类

public class DAOTest {
    @Test
    public void test1(){

        CustomerDAO dao = new CustomerDAO();
        dao.add(new Customer());
        List<Customer> list = dao.getForList(10);

        StudentDAO dao1 = new StudentDAO();
        dao1.add(new Student());
        //获取编号在10以下的写生
        List<Student> list1 = dao1.getForList(10);
    }
}

1.3 泛型使用示例

【理解这个最重要】
题目说明
定义个泛型类 DAO，在其中定义一个 Map 成员变量，Map 的键为 String 类型，值为 T 类型。
分别创建以下方法：
public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中
public T get(String id)：从 map 中获取 id 对应的对象
public void update(String id,T entity)：替换 map 中 key 为 id 的内容,改为 entity 对象
public List list()：返回 map 中存放的所有 T 对象
public void delete(String id)：删除指定 id 对象
定义一个 User 类：
该类包含：private 成员变量（int 类型） id，age；（String 类型）name。
定义一个测试类：
创建 DAO 类的对象， 分别调用其 save、get、update、list、delete 方
法来操作 User 对象，
使用 Junit 单元测试类进行测试

DAO类

public class DAO<T>{

    private Map<String,T> map = new HashMap<>();

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

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

    //替换 map 中 key 为 id 的内容,改为 entity 对象
    public void update(String id,T entity){
        if (map.containsKey(id)){//判断此id对应的键值对对象是否存在
            map.put(id, entity);
        }
    }

    //：返回 map 中存放的所有 T 对象
    public List<T> list(){

        //思想：首先得到values对应的集合，再利用迭代器或者增强for将内容装到list集合中
        //返回的value 是在Collection集合中，要向下转（强转是不可以的，父类不能赋给子类）

        Collection<T> values = map.values();
        Iterator<T> iterator = values.iterator();
        List<T> list = new ArrayList<>();
        while (iterator.hasNext()){
            T value = iterator.next();
            list.add(value);
        }
        return list;
    }

    //：删除指定 id 对象
    public void delete(String id){

        map.remove(id);
    }
}

User类

public class User {
    //该类包含：private 成员变量（int 类型） id，age；（String 类型）name。
    private int id;
    private int age;
    private String name;

    public User() {
    }

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (id != user.id) return false;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + age;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

DAOTest类：

public class DAOTest {
    public static void main(String[] args) {

        DAO<User> dao = new DAO<>();

        dao.save("1001",new User(1001,25,"Jerry"));
        dao.save("1002",new User(1002,24,"Jack"));
        dao.save("1003",new User(1003,23,"Jane"));

        User user = dao.get("1003");
        System.out.println(user);

        System.out.println("****************");

        dao.update("1003",new User(1003,22,"Ken"));

        List<User> list = dao.list();
        System.out.println(list);

        System.out.println("**************");
        dao.delete("1003");
        List<User> list1 = dao.list();
        System.out.println(list1);
    }
}
皮皮皮皮皮皮皮卡乒
关注
  • 15
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
java 关于泛型知识点的两题
weixin_44193337的博客
01-19 856
第一题：开发一个泛型Apple类，要求有一个重量属性weight在测试类中实例化不同的泛型对象，要求对象a1的这一属性是String类型，对象a2的这一属性是Integer型，a3的这一属性是Double型。分别为a1，a2，a3的重量属性赋值为：”500克”，500,500.0，在测试类中通过对象调用访问器得到属性值并输出。 public class Apple<T> { private T weight; public T getWeight() { ret
Java基础之泛型
mojiezhao的博客
02-09 133
十八 泛型 泛型（Generic）的作用，在JDK5以前，对象保存到集合中就会失去其特性（任何类型传入，都会变成Object），取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引起程序的一些安全性问题，例如： ArrayList list =new ArrayList(); list.add("abc"); Integer num=(Integer)list.get[0];//运行时会...
第12章 泛型
m0_59157761的博客
12-16 355
一、为什么要有泛型 二、在集合中使用泛型 泛型的使用 1.jdk 5.0新增的特性 2.在集合中使用泛型： 总结： ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。 ② 在实例化集合类时，可以指明具体的泛型类型 ③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。 比如：add(E e) --->实例化以后：add(Integer e) ④ ...
12-3 泛型 ---- 自定义范型结构练习
wp_886的博客
02-19 275
12-3 泛型 ---- 自定义范型结构练习 1.定义个泛型类 DAO，在其中定义一个Map 成员变量，Map 的键为 String 类型，值为 T 类型。 分别创建以下方法： public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中 public T get(String id)：从 map 中获取 id 对应的对象 public void update(String id,T entity)：替换 map 中key为id的内容,改为 enti
Java基础——泛型的使用
snduh的博客
03-23 609
泛型在Java中定义就是允许在定义接口或者类的对象时指定形参的类型，集合接口或集合类在JDK5.0时修改为带泛型的结构，主要作用就是规定集合中元素的类型，更便于操作。在实际开发中可以自定义泛型结构——泛型类、泛型接口或是泛型方法，可以把一个泛型类的泛型类型设为不确定的某个值，然后让子类继承，在子类中指明泛型的类型，或者可以在实例化子类对象时，指明泛型。 泛型的使用有很多的优点，其中最显著的就是在集合中声明了泛型之后，可以避免强制转换类型所带来的风险，且泛型的应用也十分广泛，尤其是自定义...
java练习--泛型 实验1，实验2
qq_41048982的博客
11-11 1188
1. 定义一个 Employee 类。 该类包含：private 成员变量 name,age,birthday，其中 birthday 为 MyDate 类的对象； 并为每一个属性定义 getter, setter 方法； 并重写 toString 方法输出 name, age, birthday MyDate 类包含: private 成员变量 year,month,day；并为每一个属性定义 getter, setter 方法； 创建该类的 5 个对象，并把这些对象放入.
Java基础篇泛型的总结
iijik55的博客
05-17 66
CSDN话题挑战赛第1期 活动详情地址：活动链接地址 参赛话题：Java学习记录 话题描述：可以记录一下平时学习Java中的一些知识点、心得、例题、常见的问题解决 泛型总结目录 1. 泛型概述 1.1 泛型的概念 1.2 泛型的引入 2. 泛型在集合中的使用 2.1 泛型在集合Collection及Map中的使用 2.2 泛型在 Comparable及Comparator中使用泛型 2.3 自定义泛型结构 3. 小知识点 3.1 泛型在继承上的使用 3.2 通配符的使用 1. 泛
关于java基础的泛型的练习
04-24
Java泛型是Java SE 5.0引入的一个重要特性，它极大地增强了代码的类型安全...在进行"关于Java基础的泛型的练习"时，可以尝试编写不同的泛型类、泛型方法，体验泛型带来的便利，并理解其背后的类型系统和类型擦除机制。
java基础-泛型学习总结
03-12
思维导图
java基础学习笔记之泛型
09-02
泛型是Java编程语言中的一个重要特性，首次在JDK 1.5版本中引入，它允许程序员在定义类、接口和方法时使用类型参数，从而实现了类型的安全性和代码的复用性。泛型的主要目标是增强类型安全，避免在运行时出现...
Java基础篇：泛型.pdf
04-24
该文档主要包括为什么使用泛型、在集合中使用泛型、自定义泛型结构、泛型在集成上的体现以及通配符的使用等内容
java基础-泛型通配符
03-12
java基础-泛型通配符
使用泛型的Map集合案例
a805814077的博客
08-10 2278
HashMap:Map的主要实现类以键值对,允许使用 null键null值
泛型练习(创建泛型类操作Map集合里的对象)
热门推荐
java_raylu的博客
04-14 1万+
泛型学习练习。。 建立DAO.java 泛型类，用来操作Map集合里的对象(增删改查) 创建User.java，含有属性name, id, age；也可以创建其他对象进行map集合操作 创建TestDao.java进行泛型类测试. 首先是User对象类 package Test8; public class User { /* * 定义一个 User 类： 该类包含：priv
java学习----递归
qq_56798493的博客
07-13 162
【代码】java学习----递归。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
最新发布
m0_73456341的博客
07-14 787
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 627
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 868
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 995
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
JAVA基础：深入理解泛型与集合类
泛型是Java编程语言中的一个重要特性，引入于JDK 5.0，主要用于增强类型安全性和提高代码的可读性。泛型允许在编译时检查类型，避免了运行时的类型转换，并且可以消除类型转换的异常。在集合类中使用泛型，可以确保...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

皮皮皮皮皮皮皮卡乒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值