奇怪的Java泛型.

    我必须承认我不是一个Java程序员，日常开发主要是C++和Delphi，使用Java完全是为了开发Android应用。今天在看Java的泛型，有些方面感到很奇怪，先来看下面的代码：

    class Shape {
        public void Draw() {
            System.out.println("Draw Shape");
        }
    }

    class Rect extends Shape {    
        @Override
        public void Draw() {
            System.out.println("Draw  Rect");
        }
    }

    class Line extends Shape {
        @Override
        public void Draw() {
            System.out.println("Draw Line");
        }
    }

    class Drawer<T> {
        public void DrawShape(T shape) {
            shape.Draw();
        }
    }

 

    Drawer是一个泛型类，DrawShape方法绘制一个图形，从使用C++模板的经验来看，这绝对是正确的，但Java居然出现编译错误了：shape.Draw这样调用不被允许。

    我再把代码修改了一下：

    class Drawer<T> {
        public void DrawShape(T shape) {
            shape.toString();
        }
    }

 

    这样就编译通过了，看来Java是把 T 解释成 Object 了，有没有办法让它解释成Shape呢，又看了一下文档，才知道要这样写：

    class Drawer<T extends Shape> {
        public void DrawShape(T shape) {
            shape.Draw();
        }
    }

 

    原来类型参数也可以指定继承的，如果是这样，那和不用泛型的代码有什么区别呢：

    class Drawer {
        public void DrawShape(Shape shape) {
            shape.Draw();
        }
    }

 

    看来Java的泛型和C++的模板有很大的区别，Java的泛型更多的是用于容器，并且在我看来，它的最大作用是省去类型转换的操作，并且在编译期检查一下类型是否正确，传统容器类可能要这样写：

    List intList = new ArrayList(); 
     intList.add(new Integer(10));
     Integer i = (Integer)intList.get(0);

 

　　有了泛型以后可以改成这样写：

     List<Integer> intList = new ArrayList<Integer>(); 
     intList.add(new Integer(10));
     Integer i = intList.get(0);

 

    我还注意到泛型参数不能是基本类型，只能是对象，这跟C++的模板差距又进一步拉大了。感觉Java泛型的作用并不是很大，但又搞得很复杂，比如通配符这种东西，先看下面的代码：

    private static void PrintList(List<Object> list) {
        for (Object o: list) {
            System.out.println(o.toString());
        }
    }
    
    public static void DoTest() {
         List<Rect> intList = new ArrayList<Rect>(); 
         intList.add(new Rect());
         intList.add(new Rect());
         intList.add(new Rect());
         PrintList(intList);
    }

 

 

    PrintList这一句编译不过，因为List<Rect>与List<Object>不兼容，怎么改呢，用通配符：

    private static void PrintList(List<?> list) {
        for (Object o: list) {
            System.out.println(o.toString());
        }
    }

 

    List<?> 的意思是列表的元素类型未知，但变成Object总是没有问题的，所以可以编译通过，现在如果我想它是Shape，该怎么办呢，用通配符再加Extends的办法：

    class Shape {
        public String getName() {
            return "Shape";
        }
    }

    class Rect extends Shape {    
        @Override
        public String getName() {
            return "Rect";
        }
    }

    public class TestGenerics {
        
        private static void PrintList(List<? extends Shape> list) {
            for (Shape s: list) {
                System.out.println(s.getName());
            }
        }
        
        public static void DoTest() {
             List<Rect> intList = new ArrayList<Rect>(); 
             intList.add(new Rect());
             intList.add(new Rect());
             intList.add(new Rect());
             PrintList(intList);
        }
    }

 

    看看List<? extends Shape> list，我已经快被搞晕了，它的意思是List的项必须是Shape或继承自Shape，搞了一圈又回到使用多态就可以解决问题了。

    但这个用法又带来了一些限制，就是List<? extends Shape> list中的list是不能增加删除元素的，比如: 

    private static void PrintList(List<? extends Shape> list) {
        for (Shape s: list) {
            System.out.println(s.getName());
        }
        list.add(new Rect());
    }

 

    list.add(new Line())这句编不过，因为带有通配符的集合类，根本不能确定它的元素是什么类型。

    个人觉得Java还是不要泛型的好，它只可以帮你自动转换和检查一下类型，但它所带来的语法复杂性，其实是得不偿失的。