java学习之路的自我回顾6（泛型1）

布满荆棘的人生 2022-08-03 08:24 143阅读 0赞

泛型1

当使用集合时，可能会出现类型不统一的问题，从而导致程序报错。大多数的情况如下

public static void main(String args[])
    {
        List lList=new ArrayList();
        lList.add("hello java");
        lList.add("hello python");
        lList.add("hello world");
        lList.add(5);//a
        for(int i=0;i<lList.size();i++)
        {
            System.out.println((String)lList.get(i));//b
        }
    }

这时在a处，不小心放入集合的是一个Integer类型，而在b处程序想要将一个Integer类型的数强制变为String类型的进行输出，因此程序会抛出ClassCastException异常  
（程序试图把一个Integer转化为String类型）。

这时如果我们想要创建一个List集合，让ta只能存储String类型的对象的话，我们可以手动的实现类型控制  
如下

class myList
    {
    private List lList=new ArrayList();
    public boolean add(String s)
    {   
        return lList.add(s);
    }
    public String get(int x)
    {
        return (String)lList.get(x);
    }
    public int size()
    {
        return lList.size();
    }
    }
    public static void main(String args[])
    {
        myList lList=new myList();
        lList.add("hello java");
        lList.add("hello python");
        lList.add("hello world");
        lList.add(5);//a
        for(int i=0;i<lList.size();i++)
        {
            System.out.println((String)lList.get(i));//b
        }
    }

这时候，如果不小心输入了一个Integer类型的数进入集合，就像a处一样，那么程序就会报错，这样就达到了控制集合类型的目的了，但是手动的方式必然会消耗  
编程人员的大量时间和精力，并且由于每次都要定义一个List类，使得程序变得复杂，不简洁。

在这之后（JDK1.5以后），java加入了“参数化类型”的概念，允许我们在创建集合时规定集合的类型，java的“参数化类型”被称为泛型  
进行这一修改后，集合的操作变得更加简洁，方便了  
如下

public static void main(String args[])
    {
        List<String> lList=new ArrayList(String);
        lList.add("hello java");
        lList.add("hello python");
        lList.add("hello world");
        lList.add(5);//a
        for(int i=0;i<lList.size();i++)
        {
            System.out.println((String)lList.get(i));//b
        }
    }

在a处，将会直接引起程序的编译异常。因为集合中只能加入String对象，而现在想要加入集合的是一个Integer对象

泛型  
泛型就是允许在定义类，接口时指定类型形参，这个类型形参将会在声明变量，创建对象时确定（即传入实际的类型参数）

JDK1.5以后，改写后的List接口，Iterator接口的部分片段如下

public interface List<E>
    {
        void add(E x);
        Iterator<E> iterator(); 
    } 
    
    public interface Interator<E>
    {
        E next();
        boolean hasNext();
    }

可以明显的看出，在创建List集合或者其他的变量，类时，可以通过传入不同的形参来创建不同的对象，类  
简单来说，包含泛型声明的类型可以在定义变量，创建对象时传入一个类型实参，从而动态生成无数多个逻辑上的子类  
但这种子类在物理上并不存在

那么我们是否也能类似使用泛型，给一个类增加泛型声明呢，答案是肯定的  
如下

public class A <T>
    {
    private T x;
    public A(){};
    public A(T z)
    {
    this.x=z;
    }
    public T getX()
    {
    return x;
    }
    public static void main(String args[])
    {
        A<String> a=new A<String>("hello world");
        System.out.println(a.getX());
    }
    }

输出 hello world  
虽然看上去并没有声明实际意义，泛型主要的应用场合还是在集合，但是能够通过上面的例子来加深对泛型的理解，通过泛型声明，就可以通过传入不同类型的参数来产生无数个  
子类。

继承

这里有一点需要注意，当父类已经泛型声明了，那么继承ta的子类不能够再泛型声明，

即 public class B extends A<T>{ } 是错误的
    
    子类的声明方式有多种
    1.public class B extends A<String>
    2.public class B extends A

这里有一点比较重要，当使用方法时，需要为所有的数据形参传入数据值；而使用类，接口的时候，可以不用为类型形参传入实际类型，所以上面第2中方式是可行的的

当一个子类继承了带泛型声明的父类并且想要重写方法时，需要注意一点  
以声明方式1举例（声明方式2比较特殊，之后再讲2）

public class B extends A<String> { 
        //a.......正确
        public String getX()
        {
            return "子类"+super.getX();
        }
    
        //b......错误
        public Object getX()
        {
            return "子类";
        }
    }

因为在子类创建时就已经将String类型传给了父类，所以父类中的T都应该变为了String

声明方式2  
因为没有传入类型，所以父类中的T类型默认是Object类型的，如下

public class B extends A { 
        public String getX()
        {
            return super.getX().toString();
        }
    }

将值toString一下后才能得到String类型的数据

类型通配符  
假设现在我们需要一个方法，该方法有一个带泛型声明的形参，现在想要调用该方法，该如何做？  
我们传统的想法一定是这样的，虽然传入的实参的类型不定，但是只要形参是实参的父类就可以了吧，如下

public way(A<Object> x)
    {
        .................
    }

然而这样写程序将会报错，因为在程序看来，A<Object> 并不是A<String>,A<int>等等的父类，所以会报错
    即X为Y的父类，但是A<X>不是A<Y>的父类，这和我们的传统思维略有不同
    所以，诞生了类型通配符这一概念，即将类型写为 ？ 即可，如下

public way(A<?> x)
    {
        .................
    }

这时候调用方法，将不会报错

A<String> a=new A<String>;
    way(a);

但是值得注意的是，这种带通配符的List只是各种泛型List的父类，ta实际上并不存在，也不能给其添加元素；

A<?> a=new A<?>;
    a.add("hello");//错误