精华内容
下载资源
问答
  • Java 泛型
    2021-03-10 00:39:34

    1、泛型的由来

    我们先看下面这段代码:

    报错信息如下:

    94e31814909e3c98809221ffa95f27b4.png

    也就是 集合中第二个数据是 Integer,但是我们取出来的时候将其转换为 String 了,所以报错。

    那么这个如何解决呢?

    ①、我们在遍历的时候,根据每个数据的类型判断,然后进行强转。

    那么我们说这个集合只有两条数据,我们可以进行判断强转,如果数据有成千上万条呢,我们都通过这样判断强转肯定不可取

    ②、在往集合中加入数据的时候,我们就做好限制,比如这个集合只能添加 String 类型的;下一个集合只能添加 Integer 类型的,那么我们在取数据的时候,由于前面已经限制了该集合的数据类型,那么就很好强转了。

    这第二种解决办法,也就是我们这篇文章讲的 泛型

    2、什么是泛型?

    泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

    在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。

    3、泛型的基本用法

    3.1 对于上面的问题我们只需要将上述代码的 List list = new ArrayList()  改为   List list = new ArrayList();

    3.2 泛型是在编译阶段有效

    上述代码,由于我们知道反射是在运行时阶段,c1==c2为 true,说明了编译之后的 class 文件中是不包含任意的泛型信息的。如果不信,我们可以看 class 文件的反编译信息

    我们可以看到 反编译之后的 list1和 list2完全一样。

    结论:Java 泛型只在编译阶段有效,即在编译过程中,程序会正确的检验泛型结果。而编译成功后,class 文件是不包含任何泛型信息的

    3.3 泛型类和泛型方法

    输出结果为:

    3.4 泛型通配符

    在泛型中,我们可以用 ? 来代替任意类型

    3.5 泛型的上限和下限

    ①、上限: 语法(? extends className),即只能为 className 或 className 的子类

    ①、下限: 语法(? super className),即只能为 className 或 className 的父类

    4、泛型的注意事项

    4.1、不能用基本类型来定义泛型,如 int、float

    关于这一点很好想明白,因为 集合中只能存放引用类型的数据,即使你存入基本类型的,Java还是会通过自动拆箱和自动装箱机制将其转换为引用类型

    4.2、如果使用 ? 接收泛型对象时,则不能设置被泛型指定的内容

    4.3、泛型方法的定义与其所在的类是否是泛型类是没有任何关系的,所在的类可以是泛型类,也可以不是泛型类

    4.4、泛型类没有继承关系,即String 为 Object 类型的子类,则 List 是 List 的子类这句话是错误的

    原因:假设上面那句话是正确的,那么由于泛型的产生机制就是放什么类型的数据进去,取出来的就是什么类型,而不用进行类型转换,这里把 String 类型的数据放入Object 类型的泛型集合中,那么取出来的应该就是 String      类型的数据,而实际上取出来的是 Object 类型的数据,这与泛型的产生机制相违背,故不成立!

    更多相关内容
  • 主要介绍了java泛型常用通配符实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了不同Java泛型构造函数的详解,因为对象是应用类型,对象赋值是指向同一个对象,所以如果需要保存对象某个时刻的状态,就需要构造函数来new一个新的对象。下面我们来详细了解一下吧
  • 主要介绍了Java泛型的继承和实现操作,结合实例形式分析了java泛型类的继承以及泛型接口的实现相关操作技巧,需要的朋友可以参考下
  • 深入理解java泛型详解

    2020-08-30 20:32:09
    主要介绍了Java中的泛型详解,什么是泛型,作用以及基础实例等,喜欢的朋友可以参考
  • 主要介绍了Java泛型<T> T与T的使用方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java泛型的用法及T.class的获取过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 下面小编就为大家带来一篇详谈Java泛型中T和问号(通配符)的区别。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java泛型单元试题.html

    2020-03-17 21:15:36
    精选java关于泛型的原理,应用和面试题,包含所有泛型考点。例如,泛型的概念,类型,实例化,容易混淆的用法。每一道题附上答案,方便理解考试要点。
  • 泛型从字面上理解,是指一个类、接口或方法支持多种类型,使之广泛化、一般化和更加通用。通配符只有在修饰一个变量时会用到,使用它可方便地引用包含了多种类型的泛型;下面我们来深入了解一下吧
  • 主要介绍了Java泛型之上界下界通配符详解,学习使用泛型编程时,更令人困惑的一个方面是确定何时使用上限有界通配符以及何时使用下限有界通配符。本文提供一些设计代码时要遵循的一些准则。,需要的朋友可以参考下
  • 主要介绍了Java泛型和Class类用法,结合实例形式分析了java使用泛型限制class类避免强制类型转换相关操作技巧,需要的朋友可以参考下
  • 主要为大家详细介绍了java泛型类定义与使用的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 下面小编就为大家带来一篇浅谈Java泛型让声明方法返回子类型的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • JAVA泛型简单排序实例

    2018-04-22 10:21:40
    JAVA泛型源代码实现以下功能:返回数组元素的最大值/最小值下标;判断数组元素是否按升序排列;T对象数组排序;二分法查找key元素;
  • Java泛型实例

    2016-06-06 09:10:40
    Java泛型,泛型接口、泛型方法实例
  • 主要介绍了JAVA泛型的继承和实现、擦除原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java泛型数组

    2017-03-17 15:42:48
    泛型数组的创建
  • 本文主要介绍了Java泛型的使用以及类型擦除相关的问题。具有很好的参考价值。下面跟着小编一起来看下吧
  • Java泛型(一)

    2020-12-20 19:53:11
    今天学习Java泛型技术,这个在平时里用的也很多但在我在工作中用到深处的可能并不是很多,定义泛型类也很少用到的基本就是用到集合中写泛型。但是作为学习还是要多学一些基本理论性的东西,对比较深的东西理解起来...
  • Java泛型和集合

    2016-04-22 16:13:15
    Java Generics and Collections 英文版,详细描述java 泛型技术
  • Java泛型

    2022-01-28 14:18:46
    文章目录前言一、为什么要有泛型二、泛型的使用三、如何自定义泛型结构:泛型类、泛型接口;泛型方法。四、泛型类和泛型方法的使用情景五、泛型在继承上的体现六、通配符的使用总结 前言 提示:以下是本篇文章...
    我主要是写此文章是为了给自己做一个笔记,也方便大家阅读。


    前言


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、为什么要有泛型

    在这里插入图片描述
    在这里插入图片描述

    二、泛型的使用

    1.jdk 5.0新增的特性

    2.在集合中使用泛型: 总结:
    ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
    ② 在实例化集合类时,可以指明具体的泛型类型
    ③指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器、属性等)使用到类的泛型的位置,都指定为实例化的泛型类型。 比如:add(E e) —>实例化以后:add(Integer e)
    ④注意点:泛型的类型必须是类,不能是基本数据类型。需要用到基本数据类型的位置,拿包装类替换
    ⑤如果实例化时,没有指明泛型的类型。默认类型为java.lang.Object类型。

    3.如何自定义泛型结构:泛型类、泛型接口;泛型方法。见 GenericTest1.java

    public class GenericTest {
    
    
        //在集合中使用泛型之前的情况:
        @Test
        public void test1(){
            ArrayList list = new ArrayList();
            //需求:存放学生的成绩
            list.add(78);
            list.add(76);
            list.add(89);
            list.add(88);
            //问题一:类型不安全
    //        list.add("Tom");
    
            for(Object score : list){
                //问题二:强转时,可能出现ClassCastException
                int stuScore = (Integer) score;
    
                System.out.println(stuScore);
    
            }
    
        }
    
        //在集合中使用泛型的情况:以ArrayList为例
        @Test
        public void test2(){
           ArrayList<Integer> list =  new ArrayList<Integer>();
    
            list.add(78);
            list.add(87);
            list.add(99);
            list.add(65);
            //编译时,就会进行类型检查,保证数据的安全
    //        list.add("Tom");
    
            //方式一:
    //        for(Integer score : list){
    //            //避免了强转操作
    //            int stuScore = score;
    //
    //            System.out.println(stuScore);
    //
    //        }
            //方式二:
            Iterator<Integer> iterator = list.iterator();
            while(iterator.hasNext()){
                int stuScore = iterator.next();
                System.out.println(stuScore);
            }
    
        }
    
        //在集合中使用泛型的情况:以HashMap为例
        @Test
        public void test3(){
    //        Map<String,Integer> map = new HashMap<String,Integer>();
            //jdk7新特性:类型推断
            Map<String,Integer> map = new HashMap<>();
    
            map.put("Tom",87);
            map.put("Jerry",87);
            map.put("Jack",67);
    
    //        map.put(123,"ABC");
            //泛型的嵌套
            Set<Map.Entry<String,Integer>> entry = map.entrySet();
            Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
    
            while(iterator.hasNext()){
                Map.Entry<String, Integer> e = iterator.next();
                String key = e.getKey();
                Integer value = e.getValue();
                System.out.println(key + "----" + value);
            }
    
        }
    
    
    }
    

    三、如何自定义泛型结构:泛型类、泛型接口;泛型方法。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    //异常类不能声明为泛型类
    //public class MyException<T> extends Exception{
    //}
    
    public class Person {
    }
    
    public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类
    
    
        public static <E> List<E> copyFromArrayToList(E[] arr){
    
            ArrayList<E> list = new ArrayList<>();
    
            for(E e : arr){
                list.add(e);
            }
            return list;
    
        }
    
    
    }
    
    public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类
    }
    
    /**
     * 自定义泛型类
     
     */
    public class Order<T> {
    
        String orderName;
        int orderId;
    
        //类的内部结构就可以使用类的泛型
    
        T orderT;
    
        public Order(){
            //编译不通过
    //        T[] arr = new T[10];
            //编译通过
            T[] arr = (T[]) new Object[10];
        }
    
        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 +
                    '}';
        }
        //静态方法中不能使用类的泛型。
    //    public static void show(T orderT){
    //        System.out.println(orderT);
    //    }
    
        public void show(){
            //编译不通过
    //        try{
    //
    //
    //        }catch(T t){
    //
    //        }
    
        }
    
        //泛型方法:在方法中出现了泛型的结构,泛型参数与类的泛型参数没有任何关系。
        //换句话说,泛型方法所属的类是不是泛型类都没有关系。
        //泛型方法,可以声明为静态的。原因:泛型参数是在调用方法时确定的。并非在实例化类时确定。
        public static <E>  List<E> copyFromArrayToList(E[] arr){
    
            ArrayList<E> list = new ArrayList<>();
    
            for(E e : arr){
                list.add(e);
            }
            return list;
    
        }
    }
    
    public class GenericTest1 {
    @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");
    
        }
            @Test
        public void test2(){
            SubOrder sub1 = new SubOrder();
            //由于子类在继承带泛型的父类时,指明了泛型类型。则实例化子类对象时,不再需要指明泛型。
            sub1.setOrderT(1122);
    
            SubOrder1<String> sub2 = new SubOrder1<>();
            sub2.setOrderT("order2...");
        }
        @Test
        public void test3(){
    
            ArrayList<String> list1 = null;
            ArrayList<Integer> list2 = new ArrayList<Integer>();
            //泛型不同的引用不能相互赋值。
    //        list1 = list2;
    
            Person p1 = null;
            Person p2 = null;
            p1 = p2;
    
    
        }
         //测试泛型方法
        @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);
        }
      }
    

    四、泛型类和泛型方法的使用情景

    public class DAO<T> {//表的共性操作的DAO
    
        //添加一条记录
        public void add(T t){
    
        }
    
        //删除一条记录
        public boolean remove(int index){
    
            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;
        }
    
    }
    
    public class Student {
    }
    
    public class StudentDAO extends DAO<Student> {//只能操作某一个表的DAO
    }
    

    五、泛型在继承上的体现

    在这里插入图片描述

    public class Person {
    }
    
    public class Student extends Person {
    }
    
    public class GenericTest {
    
        /*
        1. 泛型在继承方面的体现
    
          虽然类A是类B的父类,但是G<A> 和G<B>二者不具备子父类关系,二者是并列关系。
    
           补充:类A是类B的父类,A<G> 是 B<G> 的父类
    
         */
        @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 show1(List<String> list){
    
        }
    
        public void show(List<Object> list){
    
        }
    
        @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<>();
    
        }
       }
    

    六、通配符的使用

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    public class GenericTest {
     @Test
        public void test3(){
            List<Object> list1 = null;
            List<String> list2 = null;
    
            List<?> list = null;
    
            list = list1;
            list = list2;
            //编译通过
    //        print(list1);
    //        print(list2);
    
    
            //
            List<String> list3 = new ArrayList<>();
            list3.add("AA");
            list3.add("BB");
            list3.add("CC");
            list = list3;
            //添加(写入):对于List<?>就不能向其内部添加数据。
            //除了添加null之外。
    //        list.add("DD");
    //        list.add('?');
    
            list.add(null);
    
            //获取(读取):允许读取数据,读取的数据类型为Object。
            Object o = list.get(0);
            System.out.println(o);
    
    
        }
    
        public void print(List<?> list){
            Iterator<?> iterator = list.iterator();
            while(iterator.hasNext()){
                Object obj = iterator.next();
                System.out.println(obj);
            }
        }
    
        /*
        3.有限制条件的通配符的使用。
            ? extends A:
                    G<? extends A> 可以作为G<A>和G<B>的父类,其中B是A的子类
    
            ? super A:
                    G<? super A> 可以作为G<A>和G<B>的父类,其中B是A的父类
    
         */
        @Test
        public void test4(){
    
            List<? extends Person> list1 = null;
            List<? super Person> list2 = null;
    
            List<Student> list3 = new ArrayList<Student>();
            List<Person> list4 = new ArrayList<Person>();
            List<Object> list5 = new ArrayList<Object>();
    
            list1 = list3;
            list1 = list4;
    //        list1 = list5;
    
    //        list2 = list3;
            list2 = list4;
            list2 = list5;
    
            //读取数据:
            list1 = list3;
            Person p = list1.get(0);
            //编译不通过
            //Student s = list1.get(0);
    
            list2 = list4;
            Object obj = list2.get(0);
            编译不通过
    //        Person obj = list2.get(0);
    
            //写入数据:
            //编译不通过
    //        list1.add(new Student());
    
            //编译通过
            list2.add(new Person());
            list2.add(new Student());
    
        }
      }
    

    总结

    我主要是写此文章是为了给自己做一个笔记,也方便大家阅读。

    展开全文
  • 你真的懂Java泛型吗?

    2020-12-22 23:48:39
    但其实Java泛型还是有挺多tricky的东西的,编译器在背后为我们做了很多事。下面我们来看看有关Java泛型容易忽视的点。  泛型不支持协变  什么是协变?举个例子。  class Fruit{}  class Apple extends Fruit...
  • 主要介绍了Java泛型定义与用法,结合实例形式较为详细的分析了Java中泛型的概念、原理、定义、使用方法及相关操作注意事项,需要的朋友可以参考下
  • Java泛型的简单实例

    2020-09-04 23:28:19
    介绍了Java泛型的简单实例,有需要的朋友可以参考一下
  • Java泛型x详细知识点思维导图.xmind
  • Java 泛型详解

    2018-09-18 17:03:22
    Java泛型详解,Java泛型详解,Java泛型详解,Java泛型详解
  • 主要介绍了Java泛型extends关键字设置边界的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 288,464
精华内容 115,385
关键字:

java 泛型

java 订阅
友情链接: 5.rar