zoukankan      html  css  js  c++  java
  • Java 中的泛型

    泛型的概念

    泛型:
      泛型是一种末知的数据类型,当我们不知道使用什么数据类型的时候,可以使用泛型
      泛型也可以看成是一个变量用来接收数据类型
      E e:Element元素
      T t:Type类型

    是否使用泛型的对比

    不使用泛型

    /**
     * 创建集合对象,不使用泛型
     *          好处:
     *               集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据。
     *          弊端:
     *               不安全,会引发异常
     */

    好处(举例):

    public class Demo01Generic {
        public static void main(String[] args) {
            // 集合不使用泛型
            ArrayList arrayList = new ArrayList();
    
            // 向集合中添加数据,用于测试,这里添加了String类型的数据,和int类型的数据
            arrayList.add("ABC");
            arrayList.add(123);
    
            // 使用迭代器遍历集合
            // 第一步:获取送代器的实现类对象,并使用Iterator接口接收
            Iterator ite = arrayList.iterator();
            // 第二步:使用hasNext方法和next方法遍历集合,取出的元素的类型默认是Object类型
            while (ite.hasNext()) {
                System.out.println(
                        ite.next()
                );
            }
        }
    }
    输出结果:
    ABC
    123

    弊端(举例):

    public class Demo02Generic {
        public static void main(String[] args) {
    
            ArrayList arrayList = new ArrayList();
    
            arrayList.add("ABC");
            arrayList.add(123);
    
            Iterator ite = arrayList.iterator();
            while (ite.hasNext()) {
                // 取出的数据,默认是Object类型
                Object object = ite.next();
    
                // 假如想使用String特有的length方法来获取字符串的长度,是不可以的
                // 需要将Object类型向下转型为String类型才能使用它的特有方法
                // 但是集合里面还有数据类型是Integer的数据,所以不能进行向下转型为String类型,
                // 如果强行转换,那么在运行是会抛出ClassCastException异常
                String string = (String)object;
                System.out.println(string.length());
            }
        }
    }
    抛出错误:
    Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
        at XXXXXX.main(Demo02Generic.java:36)

    使用泛型

    /**
     * 创建集合对象,使用泛型
     *          好处:
     *               1、避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型
     *               2、把运行期昇常,提升到了编译期
     *          弊端:
     *               泛型是什么类型,只能存储什么类型的数据
     */

    好处及弊端(举例):

    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class Demo03Generic {
        public static void main(String[] args) {
    
            ArrayList<String> arrayList = new ArrayList<>();
    
            arrayList.add("ABC");
            // 假如添加的数据的类型不是String类型,
            // 那么会抛出错误:方法 java,util.Collection.add(java.lang.String)不适用
            // arrayList.add(123);
    
            Iterator<String> ite = arrayList.iterator();
            while (ite.hasNext()) {
    
                String string = ite.next();
    
                System.out.println(
                        string.length()
                );
            }
        }
    }
    输出结果:
    3

    定义和使用含有泛型的类

    说明

    /**
     * 泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
     *
     * 定义和使用含有泛型的类:
     * 定义格式:
     * 修饰符 class 类名称<代表泛型的变量> { . . . }
     */

    举例

    创建一个含有泛型的类

    public class GenericClass<E> {
        private E name;
    
        public E getName() {
            return name;
        }
    
        public void setName(E name) {
            this.name = name;
        }
    }

    使用这个类

    public class DemoGenericClass {
        public static void main(String[] args) {
            // 使用泛型
            GenericClass<String> name1 = new GenericClass<>();
            name1.setName("使用泛型:这里只能添加指定类型的数据");
            String string = name1.getName();
            System.out.println(string);
    
            // 不使用泛型,默认是Object类型
            GenericClass name2 = new GenericClass();
            name2.setName("不使用泛型:这里能添加不同类型的数据");
            Object object = name2.getName();
            System.out.println(object);
        }
    }
    输出结果:
    使用泛型:这里只能添加指定类型的数据
    不使用泛型:这里能添加不同类型的数据

    定义和使用含有泛型的方法

    说明

    /**
     * 定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间
     * 格式:
     * 修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
     *     方法体
     * };
     *
     * 含有泛型的方法,在调用方法的时候确定泛型的数据类型
     * 传递什么类型的参数,泛型就是什么类型
     */

    举例

    定义含有泛型的方法

    public class GenericMethod {
        /**
         * 定义一个含有泛型的方法
         */
        public <W> String method1(W w) {
            return  "一个含有泛型的方法:" + w;
        }
    
        /**
         * 定义一个含有泛型的静态方法
         */
        public static <Z> String method2(Z z) {
            return  "一个含有泛型的静态方法:" + z;
        }
    }

    使用这两个方法

    public class DemoGenericMethod {
        public static void main(String[] args) {
            // 创建类对象
            GenericMethod gm = new GenericMethod();
    
            // 调用含有泛型的普通方法
            System.out.println(
                    gm.method1(666)
            );
            System.out.println(
                    gm.method1("ABC")
            );
            System.out.println(
                    gm.method1(0.999)
            );
    
            // 调用含有泛型的静态方法
            // 可以使用gm.method2()来调用静态方法
            // 不推荐使用创建对象来调用静态方法,推荐直接用类名称来调用
            System.out.println(
                    GenericMethod.method2(666)
            );
            System.out.println(
                    GenericMethod.method2("ABC")
            );
            System.out.println(
                    GenericMethod.method2(0.999)
            );
        }
    }
    输出结果:
    一个含有泛型的普通方法:666
    一个含有泛型的普通方法:ABC
    一个含有泛型的普通方法:0.999
    一个含有泛型的静态方法:666
    一个含有泛型的静态方法:ABC
    一个含有泛型的静态方法:0.999

    定义和使用含有泛型的接口

    说明

    /**
     * 1、含有泛型的接口,第一种使用方式是:通过定义接口的实现类,实现接口,指定接口的泛型
     * 
     * 2、含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
     *    就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型
     */

    举例1

    定义一个含有泛型的接口

    public interface GenericInterface<I> {
        /**
         * 接口的抽象方法
         * @param i 泛型参数
         */
        public abstract void method(I i);
    
    }

    创建接口实现类

    public class GenericInterfaceImplement implements GenericInterface<String>{
    
        @Override
        public void method(String s) {
            System.out.println(
                    "含有泛型的接口,第一种使用方式是:通过定义接口的实现类,实现接口,指定接口的泛型
    " 
                            + "这个方法传入指定类型参数是:" + s
            );
        }
    }

    测试含有泛型的接口

    public class DemoGenericInterfaceImplement {
        public static void main(String[] args) {
            GenericInterfaceImplement gii = new GenericInterfaceImplement();
    
            gii.method("666999");
        }
    }
    输出结果:
    含有泛型的接口,第一种使用方式是:通过定义接口的实现类,实现接口,指定接口的泛型
    这个方法传入指定类型参数是:666999

    举例2

    创建一个含有泛型的接口

    public interface GenericInterface<I> {
        /**
         * 接口的抽象方法
         * @param i 泛型参数
         */
        public abstract void method(I i);
    
    }

    创建接口的实现类

    public class GenericInterfaceImplement<I> implements GenericInterface<I>{
    
        @Override
        public void method(I i) {
            System.out.println(
                    "含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
    "
                            + "创建对象的时候传入指定类型参数是:" + i
            );
        }
    }

    测试含有泛型的接口

    public class DemoGenericInterfaceImplement {
        public static void main(String[] args) {
            GenericInterfaceImplement01<Integer> gii = new GenericInterfaceImplement01<>();
    
            gii.method(2020);
        }
    }

    泛型通配符

    说明

    /**
     * 通配符基本使用泛型的通配:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符,即:表示任意的数据类型。
     * 使用方式:
     *         不能创建对象使用,只能作为方法的参数使用。
     * 注意:
     *      一但使用泛型的通配符,那么,只能使用Object类中的共性方法,集合中元素的自身方法无法使用。
     *
     */

    举例

    创建一个遍历集合的方法

    public class IteratorArrayList {
        // 由于不知道接收的ArrayList的数据是什么类型,所以使用泛型通配符?
        public static void printArrayList(ArrayList<?> arrayList) {
            // 使用迭代器遍历集合
            Iterator<?> ite = arrayList.iterator();
            while (ite.hasNext()) {
                // next()方法取出的元素是Object,可以接收任意的数据类型
                Object object = ite.next();
                System.out.println(object);
            }
        }
    }

    测试这个方法

    public class DemoIteratorArrayList {
        public static void main(String[] args) {
            // Integer类型数据
            ArrayList<Integer> arrayList1 =  new ArrayList<>();
            arrayList1.add(1);
            arrayList1.add(2);
            arrayList1.add(3);
            arrayList1.add(4);
            arrayList1.add(5);
            // 遍历Integer数据类型的集合
            IteratorArrayList.printArrayList(arrayList1);
    
            System.out.println("==========================================");
    
            // String数据类型
            ArrayList<String> arrayList2 =  new ArrayList<>();
            arrayList2.add("一号元素");
            arrayList2.add("二号元素");
            arrayList2.add("三号元素");
            arrayList2.add("四号元素");
            arrayList2.add("五号元素");
            // 遍历String数据类型的集合
            IteratorArrayList.printArrayList(arrayList2);
        }
    }
    输出结果:
    1
    2
    3
    4
    5
    ==========================================
    一号元素
    二号元素
    三号元素
    四号元素
    五号元素
  • 相关阅读:
    WebGL编程指南案例解析之绘制一个点
    在pixi中使用你的自定义着色器
    一个关于运维人员做事的很好的case,拿出来和大家共勉
    2015小目标
    在工作中修行
    ROW模式的SQL无法正常同步的问题总结
    从周末教儿子学溜冰联想到带人
    group_concat函数导致的主从同步异常
    招聘运维工程师
    一个锁的奇怪问题分析总结
  • 原文地址:https://www.cnblogs.com/liyihua/p/12185433.html
Copyright © 2011-2022 走看看