有谁也在看head first Java吗？问一道数据结构习题！！

RehsuR 发表于 2013-2-22 20:10
哦。。9 那个反过来行吗？like this:
ArrayList dogs = new ArrayList();

不行啊，尖括号里面的必须一致，除非在method里用了wildcard <? extends Animal> 吧？

这个语句貌似怎么都不能前后尖括号里面内容不一致吧？1和2就毁在这里？

我觉得答案错了。。。。。。。4没理由不能compile？？？？

小K 发表于 2013-2-23 09:31
我觉得答案错了。。。。。。。4没理由不能compile？？？？

恩，4肯定也能compile

小K 发表于 2013-2-22 19:27
不行啊，尖括号里面的必须一致，除非在method里用了wildcard

不是啊，9那个我以为所有object都是extends Objects，所以不一样也可以。但是前面人家说“普通的变量可以用superclass的引用指向subclass的对象，但泛型就不行。” 应该是说Objects是generic的所以才不行吧。普通的就可以？求大牛详解一下。。。

作为好事者，写出尝试结果
4是可以的
以前从来没意识到泛型（看起来很像Template…）还有这些门道在里面…
还有问号的用法…
不过通常写程序的时候直接尝试怎么对就怎么着，然后就不管了，除非需要优化之类的情形下会关心一下

1. 
   
2. import java.util.List;
   
3. import java.util.ArrayList;
   
4. public class exercise1 {
   
5.         public class Animal {}
   
6.         public class Dog extends Animal {}
   
7. 
   
8.         void foo() {
   
9.                 /* 1 (不可) */        // ArrayList<Dog> dogs1 = new ArrayList<Animal>();
   
10.                 // Correction:
    
11.                 ArrayList<? extends Animal> extended_animal = new ArrayList<Animal>();
    
12.        
    
13.                 /* 2 (不可) */        // ArrayList<Animal> animals1 = new ArrayList<Dog>();
    
14.                 // Correction:
    
15.                 ArrayList<? extends Animal> extended_animals1 = new ArrayList<Dog>();
    
16.                
    
17.                 /* 3 */        List<Animal> list = new ArrayList<Animal>();
    
18.                
    
19.                 /* 4 */ ArrayList<Dog> dogs = new ArrayList<Dog>();
    
20.                
    
21.                 /* 5 (不可)*/        // ArrayList<Animal> animals = dogs;
    
22.                 // Correction:
    
23.                 ArrayList<?> animals1 = dogs;
    
24.                
    
25.                 /* 6 */ List<Dog> dogList = dogs;
    
26.                
    
27.                 /* 7 */        ArrayList<Object> objects = new ArrayList<Object>();
    
28.                
    
29.                 /* 8 */        List<Object> objList = objects;
    
30.                
    
31.                 /* 9 (不可) */        // ArrayList<Object> objs = new ArrayList<Dog>();
    
32.                 // Correction:
    
33.                 ArrayList<? extends Object> objs = new ArrayList<Dog>();
    
34.                
    
35.                 // List manipulation
    
36.                 dogs.add(null);
    
37.                 dogs.add(new Dog());
    
38.                 // dogs.add(new Integer(1)); // doesn't compile
    
39.                 // dogs.add(new Animal()); // doesn't compile
    
40.                 objects.add(null);
    
41.                 objects.add(new Integer(1));
    
42.                 objects.add(objects);
    
43.                 objects.add(dogs);
    
44.                
    
45.                 // Object references...
    
46.                 Dog dog1 = new Dog();  // OK
    
47.                 // Dog dog2 = new Animal(); // doesn't compile
    
48.                 Animal animal1 = new Animal(); // OK
    
49.                 Animal animal2 = new Dog(); // OK
    
50.                 Object obj1 = new Animal();
    
51.                 Object obj2 = new Object();
    
52.                
    
53.                 animal1 = dog1;
    
54.                 // dog1 = animal1; // doesn't compile
    
55.                
    
56.         }
    
57. }
    

复制代码

cs900601 发表于 2013-2-22 23:58
作为好事者，写出尝试结果
4是可以的
以前从来没意识到泛型（看起来很像Template…）还有这些门道在里面… ...

感谢正确答案！
还是不太明白为什么这个可以， Object obj1 = new Animal();
/* 9 (不可) */        // ArrayList<Object> objs = new ArrayList<Dog>(); 这个就不可以？为啥放到ArrayList里面就不可以了？

RehsuR 发表于 2013-2-23 00:15
感谢正确答案！
还是不太明白为什么这个可以， Object obj1 = new Animal();
/* 9 (不可) */        / ...

此楼内容是错的，请见楼下lyl的正解

对这个特定的例子我觉得可以这么理解，如果Dog继承了Animal，Animal又继承了Object，那么Dog里面的成员应该等于或多于Animal里面的成员（继承的时候，Dog只会扩充Animal的成员，不能删掉已有的成员吧），所以一个Dog占的空间就会大或一样多，也就是sizeof(Dog) >= sizeof(Animal)

在新建一个ArrayList的时候，系统不光会为这个新的ArrayList分配一些空间，应该还会同时新建迭代器之类的其它结构（或是Hash list或是二叉树之类的），这些都和< > 内的数据内容有关系。（如果出现了 “？” 的话可能会有所不同，下述）而像一开始分配多少空间之类这个在编译时就需要知道的，所以Dog与Animal就不能互换。

至于“？”的出现我猜由于类型会在运行时才知道，所以编译时的类型检查的时候就宽松一些了吧

RehsuR 发表于 2013-2-23 14:15
感谢正确答案！
还是不太明白为什么这个可以， Object obj1 = new Animal();
/* 9 (不可) */        / ...

1.因为Animal extends Object，所以Animal *is-an* Object。从概念上来说，任何可以用Object的instance的地方，换成Animal的instance也一样是语法正确的。
2.因为这里涉及到范型，Java的Type System is not clever enough. 所以这类情况目前一律不允许。

cs900601 发表于 2013-2-23 14:27
对这个特定的例子我觉得可以这么理解，如果Dog继承了Animal，Animal又继承了Object，那么Dog里面的成员应 ...

1.你这完全是C struct的思维，套到Java上我认为是不恰当的。应该完全从Object oriented的方式考虑这个问题。况且Animal class完全可以包含很多不被Dog继承的private fields，你这个空间的例子不成立。
2.不对。如果我没记错，内部实现的时候所有ArrayList的element都是Object。这个Type Parameter只是给编译时type checker用的，和runtime没关系。
3.同上

lyl 发表于 2013-2-23 01:16
1.你这完全是C struct的思维，套到Java上我认为是不恰当的。应该完全从Object oriented的方式考虑这个问题 ...

哦…
感谢大神猛拍
确实没有想到私有成员的问题…
那个Object实现的方法记得意思是每次加入新元素或取出元素都会自动进行boxing/unboxing转成Object或从Object转回来（好像是在Java 1.5之后才增加的功能），所以实质上大家都相当于没有类型参数，都是存放Object的容器，而Type Parameter的允许编译/不允许编译是语言规范所规定的？

我记得在上学期做编译器作业的时候，用的Polyglot生成的编译器只能编译Java 1.4的代码。Java 1.4还不支持Generics，所以得写成如下这样：
ArrayList list = new ArrayList();
list.add(new Dog());Dog dog1 = (Dog)(list.get(0));

……以后大家不能像我这样不求甚解，不懂装懂。