各位版主已经把大家的答案都仔细的评分了，首先在此谢谢各位版主，也谢谢滔哥对本次活动的支持。
说明：分数会在2月14号和15号给大家加上的，答案也会一同公布的，只不过答案是参考答案，不一定是非常准确的，只是作为大家的参考。对于评分如果有异议的，请一定要私信给我，否则无效。
我在此说一下几个问题：
我理解大家的心情，也明白大家想提高自己的技术，通过回答问题和提出问题获得技术分。论坛里不止一次再强调这个技术分的问题，但是今天我还是有必要再说明一下。我在评分过程中，看到了很多同学做的真的很认真，回答得很详细，代码、注释一应俱全，没的说，太标准了，比我之前写的答案还要好，我自愧不如。但是我也看到了一些同学的侥幸心理，为了技术分而回答问题，我在这不是想批评谁，因为我没那个权利，我是版主，但是我更多的是为大家服务的义务，我义务没尽到，就是我的问题了，是我服务的不好。我只想说的是，不管是不是存在侥幸心理，捞取点技术分，可能你百度了答案，找了点资料，复制粘贴，答题成功了，你蒙蔽过了版主们的眼睛，但是人要慎独，就是自己要为自己的良心负责，学习是为了自己，进入黑马也不是说你多厉害，不是说你技术多高，而是你肯努力了，你踏踏实实学java了，只要你对得起自己，就足够了。我真心劝解那些心存侥幸的同学，学习是为的自己，你可以在背后说我怎么怎么样，没关系的，但是我今天就做一回愤青，我看不惯那些敷衍了事的人，如果你为自己学，你是好样的，如果你就想浑水摸鱼，那你就是在掩耳盗铃，将来毁了的是自己，害了的是自己。实实在在的，踏踏实实地学习，都是为的自己，你看别人那么多分，那是别人辛苦做出来的，我佩服那些能一道题一道题认真做的人，我不及他们，我还需要向他们学习。技术高不高没关系，但是做人如果没原则就很差劲了，人不能突破善良的底线。

说这么多了，其实就是简单一句话：人，为自己而活，要对得起自己的良心。做一个诚实的人，比做一个能力强的人，更重要。

其实，对于技术分，只要你踏踏实实学知识，看视频，回答问题，提出问题，我保证你半个月到一个月，拿够25分没问题。不要以25分为目标，这样你会没动力的，你需要将黑马入学作为你的中级目标，成为架构师为终极目标，那么你的人生都会因此而辉煌，而充满激情的。每一次的善良，都是幸福的积累。加油吧！！！

注意：
1、答案会显示在以下楼层中，大家可以讨论我给出的答案。
2、此贴禁止占楼，抢楼，严重者扣除相应的技术分。本帖只能回复与题目有关的，如果对哪道题有疑问或问题，可点击相应题目下的”回复“进行回帖。（当然，可以加写金币{:soso_e113:}）
3、如果觉得哪道题有疑问，或觉得答案有问题，可以回复或私信给我。对于不合格的回复（或刷楼或占楼之类的楼层，一经发现将立即删楼，不作通知，请谅解）
4、如果觉得对自己的分数不满意，请不要点评说明，直接私信给我，否则分数不作处理，点评将被删除。
回复图解（如果我说的不太明白，或为照顾对回帖操作不明白的，可以看图解）
1、找对应的楼层，如第11层，那么直接点击这层对应的回复即可，如下图。（点击即可放大）

2、对哪层有疑问就回复那层。

李道福 发表于 2013-3-19 23:47
public class A{
public static void main(String[] args){
  A a=new A();

首先来说，你这个print方法是个静态的，可以以直接调用，而不需要用A.print，虽然这样调用也没错。你的意思是：print里调用了非静态方法show，问这算不算在静态方法内发出对非静态方法的调用 ？其实这里你是用a.show()，是对象在调用这个show方法，这个不是静态调用非静态，因为已经有对象调用非静态方法show了，你要是直接调用show()，那么就是静态调用非静态了。

技术贴，马克！

楼主幸苦了  学习了好多

给力啊！

嘿嘿,顶一个

黄玉昆 发表于 2013-3-14 15:42
6、是否可以从一个static方法内部发出对非 static方法的调用？不可以,如果其中包含对象的method()；不能保 ...

public class A{
public static void main(String[] args){
  A a=new A();
  A.print(a); //这个算不算在静态方法内发出对非静态方法的调用 ？
}
void show(){
  System.out.println("hello");
}
static void print(A a){
  a.show();
}
}

楼主辛苦了{:soso_e113:}

顶顶顶 支持了

张豪杰 发表于 2013-3-15 10:44
楼主，第二十五题我有疑惑：
25、集合中的两种取出方式？
问题是问集合中的取出方式，但是你给的答案仅仅只 ...

你这么说也有道理，说的很准确；我觉得大家应该都理解我说的意思，因为在看视频都知道毕老师讲的这两种方式是说的Map集合，理解就好了。谢谢你

楼主，第二十五题我有疑惑：
25、集合中的两种取出方式？
问题是问集合中的取出方式，但是你给的答案仅仅只是写出Map的两种取出方式
像List集合中的用迭代器取出，还有高级for取出元素，这应该也是吧？
难道List和Set都不属于集合体系？还是我对问题理解有误？
或者这道题的题目应该指明是“Map集合的两种取出方式”？

不错......

很好，这样提高会很快的

黄玉昆 发表于 2013-3-14 15:43
17、Outer.Inner in = new Outer(new Inner())，请对这句话解释一下这个是在外部其他类中直接建立内部类对 ...

不是应该这样写吗？Outer.Inner in=new Outer().new Inner();
题目上的那句话，我怎么看着都像是new外部类对象，初始化时传入了内部了对象

java多线程是不是很麻烦啊

预留楼层

预留楼层

27、请将你知道的最简单的几种死循环形式写出来

第一种：for(;;)

第二种：while(){}

第三种：do {}while(1);

第四种：public void show(){show();}

26、FileWriter和File创建文件的区别和联系？

File创建文件是先查看文件是否存在，如果存在则返回true，不存在则创建一个新文件

FileWriter创建对象时，不论文件存不存在，都会覆盖，创建新的文件

25、集合中的两种取出方式？

keySet()和entrySet()方法

1、keySet()方法获取元素

原理：将Map集合中的所有键存入到Set集合中，因为Set集合具备迭代器，所以可以用迭代方式取出所有的键，再根据get方法获取每一个键对应的值。简单说就是：Map集合---->Set集合 ---->迭代器取出

1. import java.util.*;  
   
2. class KeySetDemo   
   
3. {  
   
4.     public static void main(String[] args)   
   
5.     {  
   
6.         //创建Map集合，并添加元素  
   
7.         Map<Integer,String> map = new HashMap<Integer,String>();  
   
8.         map.put(2,"zhangsan");  
   
9.         map.put(6,"lisi");  
   
10.         map.put(3,"wangwu");  
    
11.         map.put(4,"heihei");  
    
12.         map.put(5,"xixi");  
    
13.         //获取map集合中的所有键的Set集合  
    
14.         Set<Integer> keySet = map.keySet();  
    
15.         //有了Set集合就可以获取其迭代器，取值  
    
16.         Iterator<Integer> it = keySet.iterator();  
    
17.         while (it.hasNext())  
    
18.         {  
    
19.             Integer i = it.next();  
    
20.             String s = map.get(i);  
    
21.             System.out.println(i + " = " + s);  
    
22.         }  
    
23.     }  
    
24. }  

复制代码

2、entrySet()方法获取元素：

原理：将Map集合中的映射关系存入到了Set集合中，而这个映射关系的数据类型是Map.Entry，在通过迭代器将映射关系存入到Map.Entry集合中，并通过其中的getKey()和getValue()放取出键值。

1. import java.util.*;  
   
2. class EntrySetDemo  
   
3. {  
   
4.     public static void main(String[] args)   
   
5.     {  
   
6.         //创建集合，存入元素  
   
7.         Map<String,String> map = new HashMap<String,String>();  
   
8.         map.put("01","lisi1");  
   
9.         map.put("02","lisi2");  
   
10.         map.put("03","lisi3");  
    
11.         map.put("04","lisi4");  
    
12.         //获取map集合中的所有键，存入到Set集合中，  
    
13.         Set<Map.Entry<String,String>> entry = map.entrySet();  
    
14.         //通过迭代器取出map中的键值关系，迭代器接收的泛型参数应和Set接收的一致  
    
15.         Iterator<Map.Entry<String,String>> it = entry.iterator();  
    
16.         while (it.hasNext())  
    
17.         {  
    
18.             //将键值关系取出存入Map.Entry这个映射关系集合接口中  
    
19.             Map.Entry<String,String>  me = it.next();  
    
20.             //使用Map.Entry中的方法获取键和值  
    
21.             String key = me.getKey();  
    
22.             String value = me.getValue();  
    
23.             System.out.println(key + " : " + value);  
    
24.         }  
    
25.     }  
    
26. }  

复制代码

24、集合中的两种排序方式？

排序有两个要素：元素和集合

1）第一种排序方式：自然排序：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法，这种方式也称为元素的自然排序或默认排序方式。

1. /*
   
2. 第一种排序方式：自然排序，实现Comparable接口，重写compareTo方法
   
3. 需求：
   
4. 向TreeSet集合中存储自定义对象学生
   
5. 按照学生的年龄进行排序
   
6. */  
   
7. import java.util.*;  
   
8. //此接口强制让Student实现比较性  
   
9. class Student implements Comparable   
   
10. {  
    
11.     //定义Student私有属性  
    
12.     private String name;  
    
13.     private int age;  
    
14.     //构造Student函数，初始化  
    
15.     Student(String name,int age)
    
16.     {  
    
17.         this.name = name;  
    
18.         this.age = age;  
    
19.     }  
    
20.     //公共访问方法，访问私有属性  
    
21.     public String getName()  
    
22.     {  
    
23.         return name;      
    
24.     }  
    
25.     public int getAge()  
    
26.     {  
    
27.         return age;  
    
28.     }  
    
29.     //复写Comparator中的compare方法，自定义比较器  
    
30.     public int compareTo(Object obj)  
    
31.     {  
    
32.         //判断是否属于Student类型，否则抛异常  
    
33.         if (!(obj instanceof Student))  
    
34.             throw new RuntimeException("NotSuchTypeException");  
    
35.         //将Object类对象强转为Student类  
    
36.         Student s = (Student)obj;  
    
37.          
    
38.         //System.out.println(this.age + "--compare-" + s.age);//测试用，查看比较情况  
    
39.   
    
40.         //按年龄大小比较，相同则比较姓名大小，不同返回两年龄之差  
    
41.         if (this.age == s.age)  
    
42.         {  
    
43.             return this.name.compareTo(s.name);  
    
44.         }  
    
45.         else if (this.age <s.age)  
    
46.             return this.age-s.age;  
    
47.         return this.age-s.age;  
    
48.     }  
    
49.     /*
    
50.     //如果按照存入顺序输出
    
51.     public int compareTo()
    
52.     {
    
53.         return 1;//改为-1则按倒叙输出
    
54.     }
    
55.     */  
    
56. }  
    
57. //测试  
    
58. class TreeSetTest  
    
59. {  
    
60.     public static void main(String[] args)   
    
61.     {  
    
62.         //创建集合，并添加元素  
    
63.         TreeSet ts = new TreeSet();  
    
64.         ts.add(new Student("li01",25));  
    
65.         ts.add(new Student("li02",20));  
    
66.         ts.add(new Student("li01",22));  
    
67.         ts.add(new Student("li05",24));  
    
68.         ts.add(new Student("li08",40));  
    
69.         //打印集合中元素  
    
70.         printE(ts);  
    
71.          
    
72.         System.out.println("Hello World!");  
    
73.     }  
    
74.   
    
75.     //定义打印集合中元素的功能  
    
76.     public static void printE(TreeSet ts)  
    
77.     {  
    
78.         //迭代器方法获取  
    
79.         Iterator it = ts.iterator();  
    
80.       
    
81.         while (it.hasNext())  
    
82.         {  
    
83.             //将返回的元素（Object类）强转为Student类  
    
84.             Student s = (Student)it.next();  
    
85.             System.out.println(s.getName() + "---" + s.getAge());  
    
86.         }  
    
87.     }  
    
88. }  

复制代码

2）第二种排序方式：比较器

      当元素自身不具备比较性是，或者具备比较性，却不是所需要的，这时就需要让集合自身具备比较性。在集合初始化时就有了比较方式（即参阅构造函数）。

当两种排序方式都存在时，以比较器为主。

      如何构造比较器：定义一个类，实现Comparator接口，覆盖compare方法。

1. import java.util.*;  
   
2. //此接口强制让Student实现比较性  
   
3. class Student implements Comparable  
   
4. {  
   
5.     //定义Student私有属性  
   
6.     private String name;  
   
7.     private int age;  
   
8.     //构造Student函数，初始化  
   
9.     Student(String name,int age)  
   
10.     {  
    
11.         this.name = name;  
    
12.         this.age = age;  
    
13.     }  
    
14.     //公共访问方法，访问私有属性  
    
15.     public String getName()  
    
16.     {  
    
17.         return name;  
    
18.     }  
    
19.     public int getAge()  
    
20.     {  
    
21.         return age;  
    
22.     }  
    
23.   
    
24.     //复写Comparator中的compare方法，自定义比较器  
    
25.     public int compareTo(Object obj)  
    
26.     {  
    
27.         //判断是否属于Student类型，否则抛异常  
    
28.         if (!(obj instanceof Student))  
    
29.             throw new RuntimeException("NotSuchTypeException");  
    
30.         //按年龄大小比较，相同则比较姓名大小，不同返回两年龄之差  
    
31.         Student s = (Student)obj;  
    
32.         if (this.age > s.age)  
    
33.             return this.age-s.age;  
    
34.         else if (this.age == s.age)  
    
35.         {  
    
36.             return this.name.compareTo(s.name);  
    
37.         }  
    
38.         return this.age-s.age;  
    
39.     }  
    
40.          
    
41. }  
    
42.   
    
43. //定义比较器，实现Comparator接口  
    
44. class MyCompare implements Comparator  
    
45. {  
    
46.     //重写Comparator中的compare方法，按姓名顺序排序  
    
47.     public int compare(Object o1,Object o2)  
    
48.     {  
    
49.         //判断给定对象是否为Student类，否则抛异常  
    
50.         if (!((o1 instanceof Student) && (o2 instanceof Student)))  
    
51.             throw new RuntimeException("NotSuchTypeException");  
    
52.         //将给定对象强转为Student类  
    
53.         Student s1 = (Student)o1;  
    
54.         Student s2 = (Student)o2;  
    
55.         //比较名字，返回数值，相同则比较年龄  
    
56.         int n = s1.getName().compareTo(s2.getName());  
    
57.         if (n == 0)  
    
58.             return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
    
59.         return n;  
    
60.     }  
    
61. }  
    
62. //测试  
    
63. class TreeSetComDemo   
    
64. {  
    
65.     public static void main(String[] args)   
    
66.     {  
    
67.         //TreeSet ts = new TreeSet();  
    
68.   
    
69.         //创建集合，加入接口类参数，并添加元素  
    
70.         TreeSet ts = new TreeSet(new MyCompare());  
    
71.         ts.add(new Student("li01",25));  
    
72.         ts.add(new Student("li02",20));  
    
73.         ts.add(new Student("li01",22));  
    
74.         ts.add(new Student("li05",24));  
    
75.         ts.add(new Student("li08",40));  
    
76.   
    
77.         //打印集合中元素  
    
78.         printE(ts);  
    
79.     }  
    
80.       
    
81.     //定义打印集合中元素的功能  
    
82.     public static void printE(TreeSet ts)  
    
83.     {  
    
84.         //迭代器方法获取  
    
85.         Iterator it = ts.iterator();  
    
86.       
    
87.         while (it.hasNext())  
    
88.         {  
    
89.             //将返回的元素（Object类）强转为Student类  
    
90.             Student s = (Student)it.next();  
    
91.             System.out.println(s.getName() + "---" + s.getAge());  
    
92.         }  
    
93.     }  
    
94. }

复制代码