几道小小的题目一起和大家更进一步的了解 Java ：）

Question

做题规则：不允许进行上机操作。1. 请问以下程序会输出什么？　　public class Test {
　　　　public static void main(String[] args) {
　　　　　　Parent parent = new Parent();
　　　　　　Parent child = new Child();
　　　　　　System.out.println(parent.getName());
　　　　　　System.out.println(child.getName());
　　　　}
　　}　　class Parent {
　　　　public static String getName() {
　　　　　　return "Parent";
　　　　}
　　}　　class Child extends Parent {
　　　　public static String getName() {
　　　　　　return "Child";
　　　　}
　　}======= 我 == 是 == 题 == 目 == 间 == 的 == 小 == 分 == 隔 == 符 =======2. 请问以下程序会输出什么？　　public class Test {
　　　　public static void main(String[] args) {
　　　　　　for(int i = 0; i <= 10; i++)
　　　　　　　　Integer k = new Integer(i);
　　　　　　System.out.println("Java Puzzlers");
　　　　}
　　}======= 我 == 是 == 题 == 目 == 间 == 的 == 小 == 分 == 隔 == 符 =======3. 请补全 i 的声明（要求：i 不允许为 float、double、Float 和 Double 类型）让其能输出“Hello World”。　　public class Test {
　　　　public static void main(String[] args) {
　　　　　　________________; // 补全 i 的声明
　　　　　　if( i != i + 0) {
　　　　　　　　System.out.println("Hello World");
　　　　　　}
　　　　}
　　}======= 我 == 是 == 题 == 目 == 间 == 的 == 小 == 分 == 隔 == 符 =======4. 请问以下程序的输出结果是什么？　　import java.math.BigInteger;　　public class Test {
　　　　public static void main(String[] args) {
　　　　　　BigInteger one = new BigInteger("1");
　　　　　　BigInteger two = new BigInteger("2");
　　　　　　BigInteger three = new BigInteger("3");
　　　　　　BigInteger sum = new BigInteger("0");
　　　　　　sum.add(one);
　　　　　　sum.add(two);
　　　　　　sum.add(three);
　　　　　　System.out.println(sum.toString());
　　　　}
　　}======= 我 == 是 == 题 == 目 == 间 == 的 == 小 == 分 == 隔 == 符 =======5. 请将下面程序中的空格补全（要求见程序中）　　// 忽略 import 语句
　　public class Test {
　　　　
　　　　public static void main(String[] args) {　　　　
　　　　　　List<String> list = new ArrayList<String>();
　　　　　　list.add("d");
　　　　　　list.add("c");
　　　　　　list.add("c");
　　　　　　list.add("a");
　　　　　　list.add("a");
　　　　　　list.add("b");
　　　　　　list.add("b");　　　　
　　　　　　list = removeDuplicate(list);
　　　　　　// 输出的结果应是“d c a b ”
　　　　　　for(String str : list) {
　　　　　　　　System.out.print(str + " ");
　　　　　　}
　　　　}
　　　　
　　　　/**
　　　　 * 方法功能：移除 List 中重复的元素，并保持原有的顺序
　　　　 */
　　　　public static <T> List<T> removeDuplicate(List<T> list) {
　　　　　　// 把空格处完善
　　　　　　return ____________________________________;
　　　　}
　　}以上的题目，你能答对多少呢？不管你能做对多，能从中学习到些什么，就是对我贴这些题目最大的安慰了。帖子是有分的哦（请不要出现 JF、接分之类的回复，谢谢）= = = 以 = 下 = 的 = 内 = 容 = 请 = 把 = 题 = 目 = 做 = 完 = 再 = 看 = 好 = 吗 = = =其他说明：以上题目均改自《Java 解惑》一书，十分推荐各位看一下，CSDN 上有下载 http://download.csdn.net/source/172506 ，资源上传者要收取下载者 1 分，不过下完后回复一下评论就不会扣分了。ps: 绝对不是做广告，我只是想给大家推荐一本好书，希望各位能理解我的用意。

Answer 1

1,ParentChild
2,Java Puzzlers
3,Integer i=new Integer();
4,6

Answer 2

补充一下，做完题后可以自行上机验证一下。粘贴代码后请将两个全身空格替换成一个 Tab 或者直接替换掉（CSDN 没有代码缩进，为了方便大家阅读代码，只能这样进行处理）

Answer 3

谢谢 maquan 的鼓励。普通空格不行，我试过的，打再多的空格，也只出来一个的，达不到缩进的要求。

Answer 4

1,ParentParent
2,重复定义错误
是这样吗？

Answer 5

1,Parent Parent
2,Java Puzzlers
3,String i="";
4,0
5,new ArrayList<T>(new HashSet<T>(list))应该正确吧！！！！

Answer 6

哎 看来我基础知识还是不行啊。
谁说说第一个题为什么是两个parent啊

Answer 7

to: rpend你答对了三题，正好及格（60分）。

Answer 8

1.程序重载有错，编译不通过。
2。Java Puzzlers
3。String i = ""或者任何字符串;
4. 6
5。new ArrayList<T>(new HashSet<T>(list))靠这几个答案接点分了，谢谢。

Answer 9

to: bit1010你答对了一题，不及格。

Answer 10

bao110908(长牙了，好痛)
我答对了一题？不可能的吧？

Answer 11

to: bit1010呵呵，不好意思，你只有 3 是正确答案，其他回答都是错的。

Answer 12

to: bit1010你没仔细看题，第 5 题的要求是不允许改变原来的顺序，使用 HashSet 原来的顺序会变掉的。

Answer 13

1,Parent Parent
2,Java Puzzlers
3,不懂
4,6？不懂
5,不懂
觉得自己好菜。。

Answer 14

to: cchaha没关系的啦，帖子的题目用意就在“大家一起学习”，像这种古怪刁钻的题目很少人能全部做得对的啦。在这些题中涉及了众多的 Java 语言规范和编程技巧，以及 JDK 中方法命名存在的问题等等。如果能从中学到些什么、感受到些什么的话，我就可以在屏幕前笑笑了 o(∩_∩)o

Answer 15

第二题编译不能通过。。
第一题可以的 Parent Parent第四题 0

Answer 16

关于第一题，我有话要说:
之前，我的答案说是编译不能通过，是基于这样的考虑，一方面是静态方法在Java中不能重写(override),这样就引发了一个问题：Java中，同名的子类方法和父类方法，除了重写(override)和重载（overload），题目中的父子同名的getName既不是重写也不是重载，那他们是什么关系？而，子类明显的继承了父类的getName方法，在子类中有两个同名的方法，难道不会引起命名冲突？

Answer 17

呵，刚上级验证了一下，才对了2题。
SIGH～
基础十分不过关，呵！
支持楼主。

Answer 18

以前在图书馆也经常看到这本《java解惑》，但都没把它放在心上。
呵，马上要找工作了，看来要好好加把劲才行了！

Answer 19

to: bit1010当然不会出错了，因为都是静态方法。所以子类方法的 getName() 就不是方法的重写，其貌似重写的作用根本没有产生，根据对象的声明，第二句只会输出的是 Parent.getName() 方法。

Answer 20

to: Sammy_chan哈哈，有书就更好了，作为掌握一些鲜为人知的秘密又何尝不好呢，《Java解惑》书中的东西要比下载来的好多了，里面除了有迷题之外，还有好多的视觉迷惑图，感觉挺配套的。不过那本书挺贵的，薄薄的一本要近 40 元。

Answer 21

to bao当然不会出错了，因为都是静态方法。所以子类方法的 getName() 就不是方法的重写，其貌似重写的作用根本没有产生，根据对象的声明，第二句只会输出的是 Parent.getName() 方法。不是方法的重写，但是又继承了父类的同原型的方法，难道在子类中不引起冲突？不要绕过本质的问题看程序的结果，就是子类中现在有一个父类的getName方法，又有一个子类的getName方法，这样不会引起冲突吗？

Answer 22

to: bit1010当然不会引起冲突了，前面你也说到了静态方法不能被重写的。因为这两个方法由于是静态方法，所以在内存中的地址空间是固定，根本不存在冲突的问题。也就是说这两个方法在内存中占用了不同的空间，而具体执行哪一个，那就要看是由哪个类来调用的了。

Answer 23

1.parent parent 因为是静态方法，而且两个引用都是parent的，所以只会调用parent的方法。
2.编译不过，把循环体加个大括号就能通过，不过我不知道这是为啥（lz能不能解释下)
3.String都可以，+0操作变成字符串拼接了。
4.0.sum返回一个biginteger的值并不改变原来的变量，所以sum = sum.add(1)这样就是6了。
5.return new ArrayList<T>(new LinkedHashSet<T>(list)); treeset是排序和hashset散列顺序（这个我不确定，好像是），LinkedHashSet维持插入次序。

Answer 24

第二题,这样比较好理解些.
for(int i=0;i<=10;i++);
int i=0;
Integer k = new Integer(i);原来的循环没有循环体.变量声明跟执行体不一样吧,就象类的外边写执行语句的时候要加大括号括起来一样.不知道说的对不对.说错了请指正.

Answer 25

与这道题目相识：
public class TestPuzzle { /**
 * @param args
 */
public static void main(String[] args) {
Parent parent = new Parent();
Parent child = new Child();
System.out.println(parent.name);
System.out.println(child.name);
}
}class Parent {
public static String name="Parent";
}class Child extends Parent {

public static String name="Child";}
原来朋友问过我，我也没有解释清楚。

Answer 26

1,Parent Parent
2,Java Puzzlers
3,String i="";
4,0
5,new ArrayList<T>(new HashSet<T>(list))
这是我的答案，不知道对不对

Answer 27

1. Parent Parent
因为多态不支持静态方法，所以声明的是Parent，不管赋的是不是自类，都调用Parent的静态方法。
2. 编译不通过
因为循环体要加大括号，或者把k的声明放到循环外。
3. String i="";
没什么好解释的。。
4. 0
BigInteger的add方法返回值为两个数的和（BigInteger类型），而本身值不变，查看API
5. 最后一题想不出来，没法保证顺序不变。。郁闷！

Answer 28

1、Parent Parent
2、Java Puzzlers  我没试能不能编译通过，不过我认为这样写没有问题，循环体里声明变量没问题呀，每次进循环都应该把原变量弹栈再压栈吧？
3、String i="";
4、0
5、不会

Answer 29

1 Parent Parent
3 任何的String因为是初学者所以只能回答这样的结果～谢谢LZ支持

Answer 30

我的答案，编译前，除2题没解出来之外其它都做出来了：
1,Parent Parent
3,String i="";
4,02题没想到居然编译错误，后来想了一下，大概是因为没有{}包起来的时候，循环N次就成了在一个区域内重复申明N次k对象，所以会出错5题没想到一句话的解法，到是想到了一个比较麻烦的解法，就是匿名类：
        return new Object() {
            public List<T> remove(List<T> list) {
                Set<T> set = new HashSet<T>();
                List<T> l = new ArrayList<T>();
                for (int i = 0; i < list.size(); i++) {
                    T t = list.get(i);
                    if (!set.contains(t)) {
                        l.add(t);
                        set.add(t);
                    }
                }
                return l;
            }
        }.remove(list);如果不考虑缩进的话，这些代码完全可以写在一行，return之后，不知道算不算正解呢。

Answer 31

1 Parent Parent
2 编译错
3 String i="wrong"
4 0
5 hashset?
感觉是这样

Answer 32

以下分析仅是个人理解，如有不妥之处，肯请指正。第 2 题
说得有点道理，根据《Java解惑》提供的线索我去查看了一下《Java Language Specification》，在其中 14.4.2 节中明确指出，局部变量的声明的作用范围是在一个块内，也可以理解为在“{ }”内。for 循环可以不使用“{ }”的，但仅限于执行语句（其中并不包括变量声明语句），由于这段代码中的 Integer k 的作用范围是在整个 main 方法之中，这样就造成了变量重复定义，在编译时会报出缺“;”的错误（实际上是缺 for 后面的一个分号）。实际上这段代码（可能是代码的缩进给大家造成了误解，呵呵～～）1. public class Test {
2. 　　public static void main(String[] args) {
3. 　　　　for(int i = 0; i <= 10; i++)
4. 　　　　　　Integer k = new Integer(i);
5. 　　　　System.out.println("Java Puzzlers");
6. 　　}
7. }由于变量声明的作用范围的关系，编译器的理解，转变成我们看得懂的代码（注意第4行代码）：1. public class Test {
2. 　　public static void main(String[] args) {
3. 　　　　for(int i = 0; i <= 10; i++)
4. 　　　　Integer k = new Integer(i);
5. 　　　　System.out.println("Java Puzzlers");
6. 　　}
7. }这样我们就可以清晰地看到 for 语句后少了个分号，所以在编译时会出错。改正的话，只要加上一对花括号，让变量声明在块内就可以了。所以根据这样的一个特点，在编写代码时尽量使用标准的语句，哪怕循环体内只有一行，也应用花括号包起来，以免产生歧义。说说第 3 题，回答的朋友都答对了，只要声明任意内容的 String 变量就可以了，因为除了不允许使用的浮点数外，在剩下的类型中能使用“+”运算符操作的只剩下，byte, short, char, int, long 和 String 了，前面五个由于是数值类型 +0 的话，必然使 i != i + 0 为 true。而 String 的“+”运算并不是进行数值计算，而是进行字符串的连接。至于为什么要排序两个浮点类型呢？原因在于浮点数中的两个特殊的值 NaN，这个值是非数值值，若声明 float i = Float.NaN; 的话，也可以使那个条件为 true，不仅是那个条件，就是 i != i 时它也为 true，实际上 NaN 的值是（0.0/0.0）这个非数值的值。这是两个浮点数中重要的特性，在 Java 中要使 i != i 为 true 的话，除了使用那两个浮点数的 NaN 值是，就没有其他办法了。至于第 5 题，主要让我们能常握集合的 API 熟练程度和一些集合类的具体应用。从 JDK Collections 的 API 里可以看出，几乎所有的集合类在构造方法中都有添加另外一个集合的方法，并且第 5 题的空格只有一行，也就是说使用一行语句解决，这样 jamesfancy 的答案就不是正解了，所谓的一行语句是指语义上的一行，并不是指代码格式上的一行。上面的朋友都很不错，都想到使用 Set（不允许重复元素的集合），但是具体使用哪一个 Set 有很多的朋友都使用了 HashSet，因为题目的要求是在去除重复的基础上不允许改变原有的顺序，从 HashSet 的 API 有清楚的说明：不保证集合的迭代顺序。特别是它不保证该顺序恒久不变，使用这个类的话就讨厌了，你并不能确定你当前放进去的数据，在这个集合中的什么地方，那 TreeSet 更是不能用了。在经常使用的 Set 中还有一个通过链表实现的 LinkedHashSet，一般使用链表实现的类在插入与迭代的顺序是一致。同样的 LinkedHashMap 也是这种效果。所以，第 5 题的结果应是：new ArrayList<T>(new LinkedHashSet<T>(list))

Answer 33

CSDN 结帖真麻烦，我弄了好多次，总算凑到了，嘿嘿～～，同时谢谢 bit1010“小虾虾”的讨论。

Answer 34

呵呵，啥都想到了就是没想到LinkedXXXX

Answer 35

1,Parent 
  Child
2,Java Puzzlers
3,String i=" ";
4,一串地址
5，不知道

Answer 36

真是谢谢大家了，结帖之后还有那么多的回复～～，感动ing

Answer 37

1.Parent
2.Child
3.String i ="anyone"//////这条答错了
4.0

Answer 38

<a href="www.csdn.net">呵呵，有点意思</a>

Answer 39

好贴,顶一个.我上机调试后的答案是:
(1)
Parent
Parent
(2)Java Puzzlers 不过我改过程序.加了一对大括号才编译通过的.否则回报错.
public class test2{
public static void main(String[]args){
for(int i=0;i<=10;i++){
Integer k=new Integer(i);
}
System.out.println("Java Puzzlers");
}
}(3)
String i="";
(4) 
0
(5)恩,等楼下的给答案吧.

Answer 40

再次谢谢大家的支持～～答案及分析的话可以参看第 1 题　bit1010 在 2007-8-28 16:44:03 的回复及以后和我的讨论
第 2,3,5 题　我(bao110908)在 2007-8-29 10:13:19 的回复
第 4 题　feihua317 在 2007-8-28 21:36:27 的回复

Answer 41

来晚了还是有点好处的，看到答案咯 ！  可可 ！
@～@
不错，学了java这么久，第一次这么........
希望lz在以后能让我学到更多。

Answer 42

其实tij上都有,javapuzzle也看过,不过觉得trick多过suggestion,不如effective java好

Answer 43

Parent   parent   =   new   Parent(); 
Parent   child   =   new   Child(); 结果：parent parent
Parent   parent   =   new   Parent(); 
Child   child   =   new   Child(); 结果：parent child

Answer 44

请问下 既然是new   ArrayList <T> (new   LinkedHashSet <T> (list))
为什么要new ArrayList
为什么不能直接是new   LinkedHashSet <T> (list)呢
前面的ArrayList的意义何在。。
本人才开始学集合，希望得到各位达人的指点。感谢

Answer 45

看书了
1.ParentParent
2.Integer   k   =   new   Integer(i);  编译不过，不能为表达式
3.String i = "";
4.0 
5.new ArrayList<T>(new LinkedHashSet<T>(list));