Picses' sky

[譯者按：]

Bruce Eckel在前不久寫了一片批判Java的泛型的文章，結合他在OO上浸淫多年的功力，一眼就看出了Java的泛型和其他例如C++，Python，Ruby等等這些語言的泛型的差別。

不過平心而論，Bruce Eckel的批評是比較中肯的，因為他也看到了Java和其他這些面向對象的語言之間的差別，他也可以理解Java實現出了這樣的泛型。

另外，如果大家不知道Ruby是什么，可以參考下面的網站：http://www.ruby-lang.org/en/

[補充]添加一段Bruce Eckel自己的評論：

Guess what. I really don't care. You want to call it "generics," fine, implement something that looks like C++ or Ada, that actually produces a latent typing mechanism like they do. But don't implement something whose sole purpose is to solve the casting problem in containers, and then insist that on calling it "Generics." Of course, Java has long precedence in arrogantly mangling well- accepted meanings for things: one that particularly stuck in my craw was the use of "design pattern" to describe getters and setters. In JDK 1.4 we were told some lame way to use assertions which was a backward justification for them being disabled by default. JDK 1.4 also had to invent its own inferior logging system rather than using the openly created, well-tested and well-liked Log4J. And we've also been told many times about how Java has been as fast or faster than C++, or about how one or another feature is great and flawless. I point to the threads implementation which has had major changes quietly made from version to version with not so much as a peep of apology or admission that "hey, we really screwed up here." Or maybe I was just not on that particular announcement list.

昨晚，我作為嘉賓被Silicon Valley的模式組邀請去參加他們的一個研討會，并且讓我來決定討論的主題，為了更好的了解JDK1.5，我選擇了Java的Generics（泛型），最后討論的結果是我們大家都有點震驚。我們討論的主要素材是最新的Sun推出的Java 泛型手冊。我對“參數化類型”的經驗來自于C++，而C++的泛型又是基于ADA的Generics，事實上，Lisp語言是第一個實現了泛型的語言，有人說Simula語言也很早就有泛型了。在這些語言中，當你使用參數化的類型的時候，這個參數是作為一種隱式類型（latent type）的：一種被實現出了如何使用，但是卻沒有顯式的聲明的類型。也就是說，隱式類型是一種通過你調用方法來實現的。例如，你的模板方法是某個類型中的f()和g()，那么接下來你實現了一個類型包含了f()和g()這兩個方法，而事實上這個類型可能從來被定義過。舉個例子，在Python中，你可以這樣做：

def speak(anything):
    anything.talk()

class Dog:
    def talk(self):  print "Arf!"
    def reproduce(self): pass

class Robot:
    def talk(self): print "Click!"
    def oilChange(self): pass

a = Dog()
b = Robot()
speak(a)
speak(b)

class Dog {
public:
  void talk() { }
  void reproduce() { }
};

class Robot {
public:
  void talk() { }
  void oilChange() { }
};

template void speak(T speaker) {
  speaker.talk();
}

int main() {
  Dog d;
  Robot r;
  speak(d);
  speak(r);
}

public class Communicate  {
  public  void speak(T speaker) {
    speaker.talk();
  }
}

public class Communicate  {
  public  void speak(T speaker) {
    speaker.toString(); // Object methods work!
  }
}

interface Speaks { void speak(); }

public class Communicate  {
  public  void speak(T speaker) {
    speaker.speak();
  }
}

interface Speaks { void speak(); }

public class CommunicateSimply  {
  public void speak(Speaks speaker) {
    speaker.speak();
  }
}

interface Speaks { void talk(); }

class Dog implements Speaks {
  public void talk() { }
  public void reproduce() { }
}

class Robot implements Speaks {
  public void talk() { }
  public void oilChange() { }
}

class Communicate {
  public static  void speak(T speaker) {
    speaker.talk();
  }
}

public class DogsAndRobots {
  public static void main(String[] args) {
    Dog d = new Dog();
    Robot r = new Robot();
    Communicate.speak(d);
    Communicate.speak(r);
  }
}

interface Speaks { void talk(); }

class Dog implements Speaks {
  public void talk() { }
  public void reproduce() { }
}

class Robot implements Speaks {
  public void talk() { }
  public void oilChange() { }
}

class Communicate {
  public static void speak(Speaks speaker) {
    speaker.talk();
  }
}

public class SimpleDogsAndRobots {
  public static void main(String[] args) {
    Dog d = new Dog();
    Robot r = new Robot();
    Communicate.speak(d);
    Communicate.speak(r);
  }
}