美文网首页
Java 泛型

Java 泛型

作者: Franck_ | 来源:发表于2017-09-27 09:24 被阅读10次

    本文只是做为泛型的入门和基础的泛型的了解。

    什么是泛型?
    泛型(generices)是JDK5引入的新特性,这个特性主要是为了创建容器类,这也是泛型出现的重要原因之一。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。声明的类型参数在使用时用具体的类型来替换。

    1 泛型类

    例如我们有一个容器类Container,我们希望,这个容器可以装一个String类型的变量。代码如下:

    public class Container {
    
        private String obj;
    
        public String getObj() {
            return obj;
        }
    
        public void setObj(String obj) {
            this.obj = obj;
        }
    }
    

    那么我们可以这么使用这个容器类,例如:

            Container container = new Container();
            container.setObj("container str.");
            //会输出"container str."
            System.out.println(container.getObj());
    

    那,如果我们想在Container里面装入int类型的话。这个类是不适用的,因为它只有1个String类型的变量obj。那就需要另外声明一个Container类,然后里面包含一个int类型的变量。机智的你应该可以想到可以将Container的obj对象改成Object类型。这样就可以存入任何的对象了, 因为Object是所有对象的基类。代码如下:

    public class ContainerObj {
    
        private Object obj;
    
        public Object getObj() {
            return obj;
        }
    
        public void setObj(Object obj) {
            this.obj = obj;
        }
    }
    

    这时候,我们就可以使用ContainerObj来存入任何类型了,只是取出来使用的时候需要进行一下转换。例如:

            ContainerObj containerObj = new ContainerObj();
            containerObj.setObj("contailObj str");
            //会输出"contailObj str"
            System.out.println(containerObj.getObj());
    
           containerObj.setObj(1);
            //会输出1
            int i = (Integer) containerObj.getObj();
            System.out.println(i);
    

    这样子做回有一些缺点,例如,要记住存进去的是什么类型,不然取出来的时候,转换的类型不对的话就会发生异常。

    这时候,我们使用泛型就可以达到既可以不限定类型,又可以取的时候不用转换。例如下面这个类:

    public class ContainerGeneric<T> {
    
    
        private T obj;
    
        public T getObj() {
            return obj;
        }
    
        public void setObj(T obj) {
            this.obj = obj;
        }
    }
    
    
    //调用 
    
            //=======使用泛型的类
            ContainerGeneric<Integer> containerInt = new ContainerGeneric<>();
            containerInt.setObj(10);
            //会输出 10
            System.out.println(containerInt.getObj());
    
            ContainerGeneric<String> containerStr = new ContainerGeneric<>();
            containerStr.setObj("container str");
            //会输出"container str"
            System.out.println(containerStr.getObj());
    
    
    2 泛型接口

    泛型接口和泛型类的使用方式差不多,下面看个简单的例子:

    public interface IContainer<T> {
        T getObj();
    }
    
    
    //需要在实现这个接口的时候,指定类型为String
    public class ContainerImpl implements IContainer<String> {
    
        //所以重写getObj方法的时候,需要返回的是String类型
        @Override
        public String getObj() {
            return "invoke getObj ..";
        }
    }
    
            //=======使用泛型接口
            IContainer iContainer = new ContainerImpl();
            //会输出"invoke getObj .."
            System.out.println(iContainer.getObj());
    
    3 泛型方法

    泛型方法,是在调用方法的时候指明泛型的具体类型。允许将在一个方法使用泛型,而不必整个类使用泛型。在方法返回值之前放上泛型标识<T>就可以了。可以在普通的方法使用泛型,也可以在静态方法使用泛型,还可以在泛型方法里面使用泛型参数。如下例子:

    public class GenericMethod {
    
        //泛型方法
        public <T> void outTest(){
            System.out.println("outTest is invoke..");
        }
    
        //泛型参数
        public <T> void outTest(T t, Integer i){
            System.out.println("t = ,"+t+"i="+i);
        }
    
        //静态泛型方法
        public static  <T> void staticOutTest(){
            System.out.println("staticOutTest is invoke..");
        }
    
        public static void main(String[] args) {
            GenericMethod genericMethod = new GenericMethod();
            genericMethod.outTest();//输出"outTest is invoke.."
            genericMethod.outTest("str",1);//输出"t = ,stri=1"
            staticOutTest();//输出"staticOutTest is invoke.."
        }
    
    }
    
    4 边界符

    使用泛型方法的过程中,往往会需要限定方法的参数的类型,而不至于可以传入任意类型而造成混乱。
    例如,我们需要写一个方法,判断一个对象是否正数。泛型方法可以这么写。

        //判断一个数是否正数
        public static  <T> boolean isPositive (T t){
    
            System.out.println(t);
    
            if(t instanceof Integer)
                return  Integer.parseInt(t.toString()) > 0;
            else if(t instanceof Double)
                return  Double.parseDouble(t.toString()) > 0;
    
            //还需要判断 Float , Byte , Short , Long 类型
            else
                return false;
    
        }
    
    
    //调用:
    
    System.out.println(isPositive(1));// 输出 1 true
    System.out.println(isPositive(0.1d));// 输出 0.1 true
    System.out.println(isPositive("aa"));// 输出 aa false
    

    因为isPositive方法的参数T是泛型,所以调用的时候可以传入任意类型。所以在写方法的时候需要进行所有数字类型的判断。如果可以限定参数T是数字类型的话,就可以减少很多麻烦和避免程序混乱。这时候可以使用边界符,边界符的作用是,限定泛型参数T的类型。使用如下:

        //使用边界符 判断一个数是否正数
        public static  <T extends Number> boolean isPositiveBunder (T t){
            System.out.println(t);
            return t.floatValue()>0;
    
        }
    
    //调用:
            System.out.println(isPositiveBunder(1));//输出 1 true
            System.out.println(isPositiveBunder(0.1d));// 输出 0.1 true
    //      System.out.println(isPositiveBunder("aa")); 编译失败,已经限定了T只能是实现Number抽象类的类
    

    因为使用了边界符限定了方法isPositiveBunder的参数T必须是实现了抽象类Number的类型,所以调用的时候,只能传入实现了Number类的类型。String没有继承或者实现Number类型,所以不能通过编译。由于知道参数 t 一定是实现了Number类,所以可以直接使用 Number类的 floatValue 方法来取值进行判断。

    5 通配符

    我们知道,通过继承,可以实现实例化一个子类赋值给父类或接口。例如:

    Number num = new Integer(1);
    

    Integer 类实现了继承了Number这个抽象类。public final class Integer extends Number 。
    但是,使用泛型的时候指定的泛型类并没有这个继承的关系,例如

    //        List<Number> numberList  = new ArrayList<Integer>();编译不通过
    

    泛型类ContainerGeneric的参数是Number ,而实例化的时候,指定的参数是 Integer类型。这是不能通过编译的。使用泛型的时候,默认是没有父类子类这样的继承关系的。但是可以使用通配符,来将子类和父类关联起来。例如:

              //使用通配符,将泛型参数中的继承关系关联起来
            List<? extends Number> numbers = new ArrayList<Integer>();
    

    <? extends Number>表明可以接受的泛型参数可以是继承Number类的子类。Integer继承了Number类。所以可以这么写,并且在泛型中将继承关系关联起来了。

    6 PECS原则

    如果我们想往numbers添加元素会怎么样?

            //编译不通过,不能往numbers集合里面添加元素,只能读取元素
    //        numbers.add(1);
    //        numbers.add(2);
    
    

    为什么不能编译通过呢?我们可以分析一下
    使用通配符的时候我们可以将numbers理解为:

            List<? extends Number> numbers  = new ArrayList<Integer>();
            List<? extends Number> numbers  = new ArrayList<Double>();
            List<? extends Number> numbers  = new ArrayList<Float>();
            List<? extends Number> numbers  = new ArrayList<Long>();
            List<? extends Number> numbers  = new ArrayList<Short>();
            List<? extends Number> numbers  = new ArrayList<Byte>();
    

    numbers并不能确定它实际上的类型是什么类型,如果你往numbers添加一个int 元素. 但是可能numbers实际上可能装载的是Double元素。所以不能往实现了<? extends T>的类里面添加元素,只能读取元素。

    如果我们确实需要添加元素怎么办呢?可以使用<? super T >。表明,参数类一定是T的父类,T一定是参数类的子类。如下例子:

        List<? super Integer> numberIntList= new ArrayList<Number>();
    //  List<? super Number> numberList = new ArrayList<Integer>();编译不通过,Number不是Integer的子类
        numberIntList.add(10);//可以通过编译
    
    

    可以往实现了<? super T >的类添加元素,但是不能获取元素。为什么呢?我们一样可以分析一下。同样的,使用了spuer关键字的通配符,我们可以理解为,"?" 一定匹配的是Integer类的父类或者自己本类型。

            List<? super Integer> numberIntList= new ArrayList<Integer>();
            List<? super Integer> numberIntList= new ArrayList<Number>();
            List<? super Integer> numberIntList= new ArrayList<Object>();
    

    如果我们添加元素的话,可以添加Integer类型,或者Number类型,或者Object类型。但是取的时候,编译器并不能判断取出来的是什么类型。有可能是Integer,有可能是Number,有可能是Object类型。所以我们无法取出元素。

    根据上面的例子,我们可以总结出一条规律源钻,”Producer Extends, Consumer Super”(PECS):
    “Producer Extends” - 如果你需要一个只读List,用它来produce T,那么使用? extends T。
    “Consumer Super” - 如果你需要一个只写List,用它来consume T,那么使用? super T。
    如果需要同时读取以及写入,那么我们就不能使用通配符了。

    7 类型擦除

    相关文章

      网友评论

          本文标题:Java 泛型

          本文链接:https://www.haomeiwen.com/subject/wxkksxtx.html