敲响OO时代的丧钟——继承、多态与泛型冲突的一个例子

　　写技术文章，例子其实很难举，特别是找到有杀伤力的，决定性的例子，相当困难。昨天我接着看《对象揭密》，总算被我找到一个，当然，它那上面的解说，实在是比较模糊，因此我决定用自己的话重新叙述一遍，代码示例用Java的泛型语法，但是要表达的意思，确实所有的具有泛型的OO语言都需要面对的。

---

java代码: 

public class X {
        protected int i;
        public void add(int a){
                i=i+a;
        }
}

public class Y1 extends X {
        public void add(int a){
                i=i+a*2;
        }
}


public class Y2 extends X {
        public void add(int a){
                i=i+a*3;
        }
}

---

　　这是三个最简单的类，Y1和Y2都继承了X，并且重写了add函数。当然，这只是举例，实际上这三个add中，有两个是不合理的。

---

java代码: 

ArrayList<X> listx=new ArrayList<X>();
ArrayList<Y1> listy1=new ArrayList<Y1>();
ArrayList<Y2> listy2=new ArrayList<Y2>();
               
listx.add(new X());
listx.add(new Y1());
listx.add(new Y2());

listy1.add(new Y1());
listy2.add(new Y2());

---

　　这几行代码都非常简单，只是为了说明一个道理，在ArrayList<Y1>和ArrayList<Y2>中，能够放的就只有Y1和Y2了，而在以X为泛型的ArrayList中，就可以放X、Y1、Y2了。而当然了，这样的用法，只怕是不合泛型的目标的，本来就是希望能有一个类型的自动检查与转换，都放在ArrayList<X>中，几乎就等于都放在ArrayList<Object>中了。

 

　　现在我们有这样一个需求，对于得到的ArryaList，能够一一调用里面的对象的add(int a)方法，当然了，只要这个ArrayList里的对象都是X或者X的子类就行了。我们可以写出这样的代码：

---

java代码: 

public void addListX(ArrayList<X> listx){
        for(int i=0;i<listx.size();i++){
                X x=listx.get(i);
                x.add(1);
        }
}

---

　　是不是很简单？且慢，这个addListX函数，我们能够把listx传递给它，但是能不能把listy1和listy2

也传递给它呢？如果我们能够把listy1和listy2传递给它，就相当于执行了如下的类型转换代码：

---

java代码: 

ArrayList<Y1> listy1=new ArrayList<Y1>();
ArrayList<X> listx=listy1;

---

　　这样做行不行呢？在Java和C++中，是不行的。也就是说，如果我们要想只写一遍addListX这样的函数，而不用再多写两遍addListY1();addListY2();这样的函数，就需要把所有的X，Y1，Y2这样的类型都放到ArrayList<X>这样的容器里，否则，addListX函数，是不接受ArrayList<Y1>和ArrayList<Y2>类型的。即使Y1和Y2是X的子类型，ArrayList<X>与ArrayList<Y1>也毫不相干。不能相互转换。

 

　　有人也许会说，为什么这么限制严格呢？Eiffel就没有这么这么严格的限制，他允许ArrayList<Y1>自动转型为ArrayList<X>，这样是好事情吗？如果listy能够被转型为ArrayList<X>，那么就可以往里面添加Y2类型的对象了，这又是原来的泛型ArrayList<Y1>不允许的。也就是说：除非addListX能够保证只对listy1做只读操作，否则，类型安全性这个泛型原本要追求的目标就不能实现了。而如果要追求绝对的类型安全性，像C++和Java那样，那么代码要么就得写三遍，要么X、Y1、Y2类型的对象就得都放到ArrayList<X>这样的泛型容器里去。

 

　　注意看这其中的左右为难的状况，继承、多态、泛型，并不是真正正交的、互不干扰的，而是在一个相当普通的目标面前，他们就起了冲突了。

 

(未完待续)

评论

1 楼 xiaomin98 2009-04-18  

在这个例子当中。你说的论据是不成立的。
ArrayList<Y1>和ArrayList<Y2>本来就不是同一个类型，这是一点疑问都没有的。不光是泛型。同样Y1数组和Y2数组也不是一个类型。这里不存在泛型与继承矛盾的问题。
解决方法非常简答，把addListX方法也写成泛型方法addListX<T>(List<T>)就可以了。
C#示例代码：
using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            List<BaseClass> baseList = new List<BaseClass>();
            baseList.Add(new BaseClass());
           
            List<SubClassA> aList = new List<SubClassA>();
            aList.Add(new SubClassA());
            List<SubClassB> bList = new List<SubClassB>();
            CallList<BaseClass>(baseList);
            CallList<SubClassA>(aList);
            Console.Read();
        }
        public static void CallList<T>(List<T> list) where T:BaseClass
        {
            foreach (T var in list)
            {
                var.Show();
            }
        }
    }
  
    public class  BaseClass
    {
        public virtual void Show()
        {
            Console.WriteLine("parent");
        }
    }
    public class SubClassA : BaseClass
    {
        public override void Show()
        {
            Console.WriteLine("child a");
        }
    }
    public class SubClassB : BaseClass
    {
        public override void Show()
        {
            Console.WriteLine("child b");
        }
    }
}