Java泛型之自定义泛型结构（二）

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

文章目录

一、自定义泛型类和泛型接口

  • 泛型的声明
    interface List 和 class GenTest<K,V>
    其中，T,K,V不代表值，而是表示类型。这里使用任意字母都可以。
    常用T表示，是Type的缩写。
  • 泛型的实例化
    一定要在类名后面指定类型参数的值（类型）。如：
    List strList = new ArrayList();
    Iterator iterator = customers.iterator();
    ①T只能是类，不能用基本数据类型填充。但可以使用包装类填充。
    ②把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想。

体会：使用泛型的主要优点是能够在编译时而不是在运行时检测错误。

1）自定义泛型类举例

自定义泛型类Order

public class Order<T> {
    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型
    T orderT;

    public Order(){

    }

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

    //如下的三个方法都不是泛型方法
    public T getOrderT() {
        return orderT;
    }

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

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
}

测试代码

	@Test
    public void test1() {
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果大家定义了类是带泛型的，建议在实例化是要指明类的泛型
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<String>("orderAA", 1001, "order:AA");
        order1.setOrderT("AA:hello");
    }

自定义类SubOrder

public class SubOrder extends Order<Integer>{//SubOrder:不再是泛型类
	
}

自定义泛型类SubOrder1

public class SubOrder1<T> extends Order<T>{//SubOrder1<T>:仍然是泛型类
    
}

测试代码

@Test
    public void test2() {
        SubOrder sub1 = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子烈对象时，不再需要指明泛型。
        sub1.setOrderT(1122);

        SubOrder1<String> sub2 = new SubOrder1<String>();
        sub2.setOrderT("order2...");
    }

2）自定义泛型类泛型接口的注意点

  • 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>
  • 泛型类的构造器如下：public GenericClass(){}。而下面是错误的：
    public GenericClass(){}
  • 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
  • 泛型不同的引用不能相互赋值。
    尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。
@Test
    public void test3() {
        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        //泛型不同的引用不能相互赋值
//        list1 = list2;

        Person p1 = null;
        Person p2 = null;
        p1 = p2;
    }
  • 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
  • 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
  • jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
  • 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
  • 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
    //静态方法中不能使用类的泛型
    public static void show(T orderT){
        System.out.println(orderT);
    }
  • 异常类不能是泛型的。
//异常类不能声明为泛型类
public class MyException<T> extends Exception{

}

	//不能在try-catch中使用泛型定义
    public void show() {
        //编译不通过
//        try {
//
//        }catch (T t){
//
//        }
    }
  • 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
public Order() {
        //编译不通过
//        T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

具体存放数据时，要求存放T和T的子类的对象

  • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
    ①子类不保留父类的泛型：按需实现
    没有类型 擦除
    具体类型
    ②子类保留父类的泛型：泛型子类
    全部保留
    部分保留
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}

// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}

// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}

结论：子类除了指定或保留父类的泛型，还可以增加自己的泛型

二、自定义泛型方法

  • 方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
  • 泛型方法的格式：
    [访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
  • 泛型方法声明泛型时也可以指定上限。

代码举例

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

        for (E e : arr) {
            list.add(e);
        }

        return list;
    }

测试代码

	//测试泛型方法
    @Test
    public void test4() {
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1, 2, 3, 4};
        //泛型方法在调用时，指明泛型参数的类型
        List<Integer> list = order.copyFromArrayToList(arr);
        System.out.println(list);
    }

三、举例泛型类和泛型方法的使用情境

DAO: data(base) access object

public class DAO<T> {//表的共性操作的DAO

    //添加一条记录
    public void add(T t) {

    }

    //删除一条记录
    public boolean remove(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 getValue() {
        return null;
    }
}

Customer

public class Customer {//此类对应数据路中的Customers表

}

CustomerDAO

public class CustomerDAO extends DAO<Customer> {

}

Student

public class Student {//此类对应数据路中的Student表

}

StudentDAO

public class StudentDAO extends DAO<Student> {//只能操作某一个表的DAO

}

DAOTest

public class DAOTest {
    @Test
    public void test1() {
        CustomerDAO dao1 = new CustomerDAO();

        dao1.add(new Customer());
        List<Customer> forList = dao1.getForList(10);

        StudentDAO dao2 = new StudentDAO();
        Student student = dao2.getIndex(1);
    }
}

四、泛型在继承上的体现

1）体现一

	/*
	类A是类B的父类，但是G<A>和G<B>二者不具备子父类关系，二者是并列关系
     */
    @Test
    public void test1() {
        Object obj = null;
        String str = null;
        obj = str;

        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;

        //编译不通过
//        Date date = new Date();
//        str = date;

        List<Object> list1 = null;
        List<String> list2 = new ArrayList<String>();
        //此时的list1和list2的类型不具有子父类关系
        //编译不通过
//        list1 = list2;

        /*
        反证法：
        假设list1 = list2；
            list1.add(123);导致混入非String的数据。出错。
         */

        show(list1);
        show1(list2);
    }

    public void show(List<Object> list) {

    }

    public void show1(List<String> list) {

    }

2）体现二

	/*
    补充：类A是类B的父类，A<G>是B<G>的父类
     */
    @Test
    public void test2() {
        AbstractList<String> list1 = null;
        List<String> list2 = null;
        ArrayList<String> list3 = null;

        list1 = list3;
        list2 = list3;

        List<String> list4 = new ArrayList<>();
    }

五、自定义泛型类练习

练习题

定义个泛型类 DAO<T>，在其中定义一个 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<T> 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<String, T>();

    //保存 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)) {
            map.put(id, entity);
        }
    }

    //返回 map 中存放的所有 T 对象
    public List<T> list() {
        //错误的
//        Collection<T> values = map.values();
//        return (List<T>)values;

        //正确的
        List<T> list = new ArrayList<>();
        Collection<T> values = map.values();
        for (T t : values) {
            list.add(t);
        }
        return list;
    }

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

User

public class User {
    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 == user.name;
    }
}

DAOTest

public class DAOTest {
    public static void main(String[] args) {
        DAO<User> dao = new DAO<>();

        dao.save("1001", new User(1001, 34, "123"));
        dao.save("1002", new User(1002, 20, "456"));
        dao.save("1003", new User(1003, 25, "789"));

        dao.update("1003", new User(1003, 30, "147"));

        dao.delete("1002");

        List<User> list = dao.list();
//        System.out.println(list);
        list.forEach(System.out::println);
    }
}
lanan_lzp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java编程思想里的泛型实现一个堆栈类 分享
09-05
介绍了Java编程思想里的泛型实现一个堆栈类，有需要的朋友可以参考一下
java自定义泛型方法
lindiwo的博客
09-16 587
按照惯例（也不知道哪来的惯例），先上代码： package com.tongdatech.winterspring.cwgx.utils; import java.util.ArrayList; import java.util.List; import com.ld.ClassA; /** * * @author ld * 数据转成tree供页面展示 * */ public class TreeTableSunYi { public static <E extends Cl
Java泛型（1）--集合使用泛型Generic、自定义泛型、泛型在继承上的体现、通配符的使用
叶绿体不忘呼吸
09-24 302
文章目录泛型的概念集合中使用泛型自定义泛型结构泛型在继承上的体现通配符的使用 泛型的概念 集合容器类在设计阶段/声明阶段不能确定这个容器实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>，ArrayList<E> 中<E>就是类
java自定义泛型_Java自定义泛型
weixin_29584723的博客
02-15 345
上一小节讲解了在集合上如何使用泛型，那么在程序中是否能自定义泛型呢? 假设要实现一个简单的容器，用于缓存程序中的某个值，此时在这个容器类中势必要定义两个方法save()和get()，一个用于保存数据，另一个用于取出数据，这两个方法的定义如下：voidsave(参数类型参数){……}返回值参数类型get(){……}为了能存储任意类型的对象，save()方法的参数需要定义为Object类型，同样ge...
java中怎么给集合定义泛型_java中集合里的泛型
weixin_39680121的博客
02-27 542
import java.util.ArrayList;/** 泛型 ： java jdk1.5新特性。* 泛型的好处 ：* 1。将运行时的错诶提前到编译时。* 2.避免无谓的强制类型转换。** 自定义方法泛型： 自定义泛型就是一个数据类型的占位或一个数据类型变量， 一般T type或E element来做这个占位的符号* 占位符号是可以...
【泛型】java泛型之自定义泛型extends,super
皇夜_的博客
11-19 633
自定义泛型：extends,super关键字的使用 1.泛型类的使用 public class ResponseResult<T> {} 2.泛型方法的使用 public static <T extends String> T concat(T... ts) {} 3.泛型接口的使用 public interface StringBufferInterface&...
Java泛型02：自定义泛型类、泛型方法
小贺想改变
10-16 1165
对自定义泛型类、泛型方法的详细解释
java自定义泛型出错_Java 自定义泛型
weixin_29062613的博客
02-27 165
/*** 自定义泛型** @author ASAS**/public class demo1 {public static void main(String[] args) {int in = print(12);String s = print("abc");}/*** 把T 字母声明为自定义的泛型* @param i* @return*/private static T print(T i...
java中自定义泛型类_Java自定义泛型类和泛型接口
weixin_31727797的博客
02-28 474
泛型类中的类型参数几乎可以用于任何可以使用接口名、类名的地方，下面我们先通过 JDK 5.0 中集合框架中的 Map 接口定义的一部分来简单了解一下：public interface Map {public void put(K key, V value);public V get(K key);//......}对于常见的泛型模式，推荐的名称是：K ——键，比如映射的键。V ——值，比如 Lis...
JAVA泛型——自定义比较器的3种方式
小乖乖的臭坏坏
01-05 990
方式一：通过实现Comparator接口对对象完成排序属性 例子：初始化一个TreeSet类型的集合，当集合中有元素时即对集合中元素以字符串长度为规则进行排序 import java.util.*; class GenericDemo2 { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>(new LenComparator()); ts.add("ab
应用Java泛型和反射导出CSV文件的方法
09-04
主要介绍了应用Java泛型和反射导出CSV文件的方法,通过一个自定义函数结合泛型与反射的应用实现导出CSV文件的功能,具有一定的参考借鉴价值,需要的朋友可以参考下
链表+泛型+反射实现自定义的LinkedList集合类
09-11
该资源利用基础的链表结构，结合泛型和反射的知识点，实现重写LinkedList集合类，可以存放任意类型数据。比较推荐对Java有稳固基础的同学来阅读，为了方便阅读，代码的注释写的非常的清楚
Java.SE 自定义泛型与泛型的常见陷阱
02-06
Java.SE 自定义泛型与泛型的常见陷阱Java.SE 自定义泛型与泛型的常见陷阱
Java基础篇：泛型.pdf
04-24
该文档主要包括为什么使用泛型、在集合中使用泛型、自定义泛型结构、泛型在集成上的体现以及通配符的使用等内容
jdk8新特性----Lambda表达式
最新发布
w_t_y_y的博客
05-11 182
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
java jar包如何运行或调用
NLP与推荐算法
05-08 253
java服务启动
【数据结构】二叉树
m0_73911405的博客
05-05 645
前序：根，左子树，右子树中序：左子树，根，右子树后序：左子树，右子树，根N代表空元素前序 1 2 3 N N N 4 5 N N 6 N N中序 N 3 N 2 N 1 N 5 N 4 N 6 N后序 N N 3 N 2 N N 5 N N 6 4 1层序 1 2 4 3 5 6一层层从左到右一个树分成根和子树，子树再分为根和子树。
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 341
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java 泛型数组参数
09-07
总结：Java泛型数组参数可以提供更加灵活和通用的方法设计，可以处理不同类型的数组。虽然不能直接创建泛型数组，但可以通过类型擦除和强制类型转换的方式创建泛型数组的引用。 ### 回答3： Java中的泛型数组参数...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值