Java基础-泛型

泛型

这是Java基础的第一篇，泛型。

1. 入门：

泛型的引入是为了让Java能够记住集合中的数据类型，而不是统一用Object来处理。

例如：

public class ListErr 
{ 
    public static void main(String[] args)
    {
        List strList = new ArrayList();
       strList.add(“aaaa);
       strList.add(5);
       for(int i=0; i<strList.size(); i++)
        {
            String str = strList.get(i); // 这里会报错，因为加了一个Int数据
        }
    }
} 

这个时候程序会报ClassCastException异常。

我们可以通过手动实现编译时检查类型。通过组合的方式来复用ArrayList类。

class StrList {
    private List strList = new ArrayList ();
    public boolean add(String ele)
    {
        return strList.add(ele);
    }
    public String get(int index)
    {
        return (String) strList.get(index);
    }
    public int size()
    {
        return strList.size();
    }
}

public class CheckType
{
    public static void main(String[] args) {
        List strList = new ArrayList();
        strList.add("aaa");
        strList.add("bbb");
        strList.add("ccc");
        strList.add(5);  //这行会导致编译失败
        for (int i=0; i<strList.size();i++) {
            String str = (String) strList.get(i);
        }
    }
}

而当我们使用泛型的时候如下：

public class GenericList {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<String>();
        strList.add("aaa");
        strList.add("bbb");
        strList.add("ccc");
        //strList.add(5);  这行会导致编译失败
        for (String str : strList) {
            System.out.println(str);
        }
    }
}

通过一个<>指定参数类型，就不会发生上面那种情况了。

2. 深入泛型

泛型能够在哪些场景下使用呢？

定义类，接口，方法时使用类型形参，这个类型形参将在声明变量，创建对象，调用方法时动态指定。

public interface List<E> 
{ 
    void add(E x);
    Iterator<E> iterator();
} 
// 定义接口时指定一个类型形参，形参名为E 
public interface Iterator<E> 
{ 
    E next();
    boolean hasNext();
} 
// 定义接口时指定了两个类型形参，形参名为K，V 
public interface Map<K,V> 
{ 
    Set<K> keySet()
    V put(K key, V value)
} 

除了在集合类里面使用泛型，我们也可以自定义泛型类,例如

public class Apple<T> 
{ 
    private T info;
    public Apple(){};
} 

上面定义了一个带泛型声明的Apple类，这个T没有实际意义。但是我们可以生成Apple Apple等多个逻辑子类。

注意： 定义构造器不需要加<>。

3. 泛型类派生子类

public class A extends Apple<T>{} // 错误的，不能再包含类型形参 

正确写法：

public class A extends Apple<String> 

这个时候，getInfo() 和 void setInfo(String info)都会由T被替换成为String

当然，也可以不写类型参数

public class A extends Apple 

这样写也是正确的，但是Java编译器可能会发出警告：使用了未经检查或者不安全的操作-这就是泛型检查的警告。

4. 并不存在泛型类

其实ArrayList 类能否当成ArrayList的子类呢？ 可以的。

但是系统并没有生成新的class文件。

List<String> 11 = new ArrayList();

List<Integer> 12 = new ArrayList();

System.out.printLN(11.getClass() == 12.getClass());

结果输出true.说明无论是实际类型参数是什么，他们运行时都是同样的类。

因为泛型在Java中都被当成同一类处理，内存中也只占用一块内存空间，因此静态方法，静态变量等声明不允许使用类型参数。

5. 使用类型通配符

? 是元素类型未知的意思，也是Java里的类型通配符。

public class test(List<?> c){ 
 ... 
} 

设定类型通配符的上限

例如：定义一个类shape，有两个子类circle rectangle

再定义一个Canvas类

public class Canvas 
{ 
    public void drawAll(List<Shape> shapes)
    {
    ...
    }
} 

这个时候，如果调用

List<Circle> circleList = new ArrayList<>(); 

Canvas c = new Canvas();

c.drawAll(circleList);

就会报错，因为List并不是List的子类。我们可以考虑使用List

设定类型形参的上限

public class Apple<T extends Number> 
{ 
    T col;
} 

表明了col的上限是Number类，传入参数时只能是Number或者Number类的子类。

6. 泛型方法

用法格式如下：

修饰符<T, S> 返回值类型 方法名(形参列表) 
{ 
 方法体 
}

例如：

public <T> void fromArrayToCollection (T[] a, Collection<T> c) 
{ 
    for(T o : a) 
    {
        c.add(o);
    }
} 

声明一个泛型方法，带有T类型形参。这个T可以在该方法内当成普通类型使用。并且这个T可以通过系统自动推断类型，不需要显示传入。

7. 泛型方法和类型通配符的区别

通常情况下泛型方法都可以替代类型通配符。例如：

// 类型通配符 
public interface Collection<E> 
{ 
    boolean containsAll(Collection<?> c);
} 

可以采用泛型方法

public interface Collection<E> 
{ 
    <T> boolean containsAll(Collection<T> c);
}