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

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

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

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

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

1、 Integer a = new Integer(100);     Integer b = 100;     Integer c =100;     int d = 100;a、b、c、d这四个数通过“==”和equals方法，进行比较，都哪些结果是true，哪些是false

第一、用equals比较的都是true，因为equals比较的是值，都为100，所以都相等

第二、用“==”比较的是地址，只有a和b，a和c不相等，其余为true。Java中，如果用“==”比较两个对象结果为true，说明这两个对象实际上是同一个对象，false说明是两个对象。a==d,b==d,c==d都是true，因为d是一个原始数据类型， Integer对int进行了封装，拿Integer对象和int基本数据类型==相比，就会发生一个自动拆箱操作，把Integer进行拆箱了再和int进行比较，所以都是true.

如何使用这两个比较方式：

当使用"=="来判断两个变量是否相等时，如果两个变量是基本数据类型的变量，且都是数值型（不一定要求数据类型严格相同），则只要两个变量的值相等，则使用"=="判断将返回true。但对于两个引用类型的变量，必须它们指向同一个对象时，"=="判断才会返回true;

使用equals判断：当程序需要判断两个引用变量是否相等时，并不要求两个引用变量指向同一个对象。比如两个字符串变量进行比较。只要求它们引用变量字符串里包含的字符序列相同即可，则用equals判断。其实equals的底层是用的==的比较方式，所以一般自定义的类，都需要复写这个equals的方法。

补充：

int 是基本类型，直接存数值；integer是对象，用一个引用指向这个对象。

1.Java 中的数据类型分为基本数据类型和复杂数据类型，int 是前者，Integer 是后者（也就是一个类）

2.初始化时，int d =100; Integer a= new Integer(100);(要把Integer当做一个类看)

　　int 是基本数据类型（面向过程留下的痕迹，不过是对java的有益补充）

　　Integer 是一个类，是int的扩展，定义了很多的转换方法

　　类似的还有：float Float;doubleDouble;string String等

Java中int和Integer关系是比较微妙的。关系如下：

　　1.int是基本的数据类型；

　　2.Integer是int的封装类；

　　3.int和Integer都可以表示某一个数值；

　　4.int和Integer不能够互用，因为他们两种不同的数据类型；

Integer类的内部, 有一个常量静态数组, 在Integer类被加载的时候, 预先创建了-128 ~ 127的Integer对象, 所以当声明的Integer类型变量的值在-128 ~ 127的范围内时, 不会新创建对象, 直接引用数组中创建好的。而int是一个基本数据类型，不存在integer那样的创建对象的过程，只要数值不超过-2……31~2^31-1（对于32位的编译器来说），编译器就不会报错。

2、BS与CS的联系与区别

定义：

C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型 机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。

B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如 Netscape Navigator或Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Ｗeb Server 同数据库进行数据交互。

C/S 与 B/S 区别：

（１）硬件环境不同:

C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务.

B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行

（２）对安全要求不同

C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息.

B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。

（３）对程序架构不同

C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑.

B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上.比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk2000 Exchange 2000等, 全面支持网络的构件搭建的系统.SUN 和IBM推的JavaBean 构件技术等,使 B/S更加成熟.

（４）软件重用不同

C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好.

B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子

（５）系统维护不同

C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统

B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实现升级.

（６）处理问题不同

C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统

B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小.

（７）用户接口不同

C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高

B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本.

（８）信息流不同

C/S 程序一般是典型的中央集权的机械式处理, 交互性相对低

B/S 信息流向可变化, B-B B-C B-G等信息、流向的变化, 更像交易中心。

3、内部类可以引用他包含类的成员吗？有没有什么限制？

一个内部类对象可以访问创建它的外部类对象的内容。

第一、内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式外部类名.this

第二、当内部类在成员位置上，就可以被成员修饰符所修饰。当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

第三、内部类定义在局部时，(1)不可以被成员修饰符修饰。(2)可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

4、小程序设计：通过键盘录入数据，分别录入三次，每次存入一个.txt文件中，并将三个文件合并为一个.java文件。（可直接下载附件）

1. import java.io.*;
   
2. import java.util.*;
   
3. 
   
4. 
   
5. class Text4
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 //录入数据,写入文件
   
10.                 inputFile();
    
11.                
    
12.                 //合并文件
    
13.                 sequenceFile();
    
14.         }
    
15. 
    
16.         //录入数据,写入文件
    
17.         public static void inputFile()
    
18.         {
    
19.                 //创建字符输入流
    
20.                 BufferedReader in = null;        
    
21.                 //创建字符输出流
    
22.                 BufferedWriter out = null;        
    
23.                 try
    
24.                 {
    
25.                         //录入三次
    
26.                         for(int i=1;i<=3;i++)
    
27.                         {
    
28.                                 System.out.println("请将数据录入第"+i+"个txt文件中，输入over结束:");
    
29.                                 //创建文件对象
    
30.                                 File file = new File(i+".txt");        
    
31.                                 if(!file.exists())
    
32.                                         file.createNewFile();
    
33.                                 //键盘录入,读入数据                        
    
34.                                 in = new BufferedReader(new InputStreamReader(System.in));
    
35.                                 //将数据写到文件
    
36.                                 out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file)));
    
37.                                 String line = null;
    
38.                                 //读取每一行数据到缓冲区
    
39.                                 while((line = in.readLine())!= null)
    
40.                                 {
    
41.                                         //输入over结束本次录入
    
42.                                         if("over".equals(line))
    
43.                                                 break;
    
44.                                         //写入数据到流
    
45.                                         out.write(line);
    
46.                                         out.newLine();
    
47.                                         out.flush();
    
48.                                 }
    
49.                         }
    
50.                 }
    
51.                 catch (IOException e)
    
52.                 {
    
53.                         throw new RuntimeException("键盘录入失败");
    
54.                 }
    
55.                 //关闭资源
    
56.                 finally
    
57.                 {
    
58.                         try{
    
59.                                 if(in!= null)
    
60.                                         in.close();
    
61.                         }catch(IOException e){
    
62.                                 throw new RuntimeException("读取流关闭失败");
    
63.                         }
    
64.                         try{
    
65.                                 if(out!= null)
    
66.                                         out.close();
    
67.                         }
    
68.                         catch(IOException e){
    
69.                                 throw new RuntimeException("写入流关闭失败");
    
70.                         }
    
71.                 }
    
72.         }
    
73.         //合并文件
    
74.         public static void sequenceFile()
    
75.         {
    
76.                 FileOutputStream fos = null;
    
77.                 SequenceInputStream sis = null;
    
78.                 try
    
79.                 {
    
80.                         //创建集合，存储多个文件
    
81.                         ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
    
82.                         for(int i=1;i<=3;i++)
    
83.                         {
    
84.                                 al.add(new FileInputStream(i+".txt"));
    
85.                         }
    
86.                         //匿名内部类访问局部变量要final
    
87.                         final Iterator<FileInputStream> it = al.iterator();
    
88.                         //创建Enumeration匿名对象
    
89.                         Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
    
90.                         {
    
91.                                 public boolean hasMoreElements()
    
92.                                 {
    
93.                                         return it.hasNext();
    
94.                                 }
    
95.                                 public FileInputStream nextElement()
    
96.                                 {
    
97.                                         return it.next();
    
98.                                 }
    
99.                         };
    
100.                         //合并流对象，将集合元素加入。
     
101.                         sis = new SequenceInputStream(en);
     
102.                         //创建写入流对象，FileOutputStream
     
103.                         fos = new FileOutputStream("all.txt");
     
104.                         byte[] b = new byte[1024*1024];
     
105.                         int len = 0;
     
106.                         //循环，将数据写入流资源
     
107.                         while((len=sis.read(b))!=-1)
     
108.                         {
     
109.                                 fos.write(b,0,len);
     
110.                         }
     
111. 
     
112.                 }
     
113.                 catch (IOException e)
     
114.                 {
     
115.                         throw new RuntimeException("文件操作失败");
     
116.                 }
     
117.                 //关闭流资源
     
118.                 finally
     
119.                 {
     
120.                         try
     
121.                         {
     
122.                                 if(fos!=null)
     
123.                                         fos.close();
     
124.                         }
     
125.                         catch (IOException e)
     
126.                         {
     
127.                                 throw new RuntimeException("关闭流资源操作失败");
     
128.                         }
     
129.                         try
     
130.                         {
     
131.                                 if(sis!=null)
     
132.                                         sis.close();
     
133.                         }
     
134.                         catch (IOException e)
     
135.                         {
     
136.                                 throw new RuntimeException("关闭流资源操作失败");
     
137.                         }
     
138.                 }               
     
139.         }
     
140. }
     

复制代码

5、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？

第一、JAVA语言如何进行异常处理：

Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一 个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来 实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出 （throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。

第二、关键字含义：

用try来指定一块 预防所有“异常”的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型。

throw语句用来明确地抛出一个 “异常”。

throws用来标明一个成员函数可能抛出的各种“异常”。

Finally为确保一段代码不管发生什么“异常”都被执行一段代 码。

第三、在try块中可以抛出异常吗：

可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，“异常”的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理，堆栈就会展开，直到遇到有处理这种“异常”的try 语句。

try{

       需要被检测的代码；

}

catch(异常类变量){

       处理异常的代码;(处理方式)

}

finally{

       一定会执行的语句；

}

并有三种结合方式：

结合方式一：

try{}catch{}

结合方式二：

try{}catch{}finally{}

结合方式三：

try{}finally{}

6、是否可以从一个static方法内部发出对非 static方法的调用？

不可以,如果其中包含对象的method()；不能保证对象初始化.

static修饰的成员是在类加载的时候初始化的，而非static的成员是在创建对象的时候，即new操作的时候才初始化的。先后顺序是：先加载，才能初始化，那么加载的时候初始化static的成员，此时非static的成员还没有被加载必然不能使用，而非static的成员是在类加载之后，通过new操作符创建对象的时候初始化，此时static 已经分配内存空间，所以非静态成员可以访问静态成员！

      简单点说：静态成员属于类,不需要生成对象就存在了.而非静态需要生成对象才产生.，所以静态成员不能直接访问.  

7、是否可以继承String类?

String类是final类故不可以继承。

final在java语言中的理解为“最终的”或者是“最终无法改变的”的意义。它可以对非抽象类的成员方法和变量进行修饰，final对非抽象类的成员方法和变量进行修饰后表示此抽象类不能再被继承和扩展，表示就是最终的。如果final修饰常量时表示此常量只能赋值一次，以后不能再进行修改。

8、char型变量中能不能存贮一个中文汉字?为什么?

能够定义成为一个中文的，因为java中以unicode编码，一个char占2个字节，16个二进制位；一个汉字也是两个字节，所以放一个中文是没问题的

9、java中的锁synchronized和Lock的异同

主要相同点：Lock能完成synchronized所实现的所有功能，

主要不同点：

synchronized：一般是在线程同步上会涉及到。它可以放在函数上修饰函数，也可以放在某些代码块上修饰语句，放在函数上叫同步函数，放在语句上叫同步代码块。它再用的时候要获取一个锁，这个锁是一个对象。任何对象都可以，但是必须是一致的才能保证同步，一般可以用Object对象。如果是非静态函数，那么这个对象用的是this；如果是在静态函数上，则这个对象就是该方法所在类的字节码文件，即类名.class。

Lock：lock 是JDK1.5出现的，是对sychornized的改进。sychornized能实现的功能lock基本都能实现，但是Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

10、Collection和Collections的区别

Collection是集合类的上级接口，继承与他的接口主要有Set 和List。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式

Collections是针对集合类的一个工具类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

11、一个类中的静态方法可以用这个类的一个对象调用吗？为什么？

可以，因为静态是在类加载时就存在了，是属于整个类的，可以被类名直接调用，也可以被本类对象调用。

12、对于Person p = new Person("张三","25");这句话的加载示意图（画图，保存为图片的相关格式）

13、为什么this和super不能同时出现在构造函数中的第一行？

构造函数中，this和super语句都必须在第一语句出现，因为两者都是用来初始化的，既然是初始化，就要首先存在，就只能进行一次，因此不能同时作为第一条语句出现。

14、假设A是一个接口，A中有两个方法，类B实现了这个接口，那么B一定要覆写A中全部的方法吗？A可以创建一个A对象吗？A a =new B();的写法正取吗？

第一、B如果要创建对象,必须覆写A中全部的方法,因为如果只覆写一部分,B会继承A中的抽象方法,抽象方法必须存在于抽象类中,如果这样B就不可以创建对象了

第二、A不可以创建对象，因为A是一个接口，全为抽象方法，不能实例化对象

第三、这种写法是正确的，A虽然不能实例化对象，但是可以创建一个引用，指向类B这个对象。这里用到了多态。

15、什么是单例设计模式？什么是模板方法？什么是装饰类？

单例设计模式：解决一个类在内存中只存在一个对象的问题（比如说一个软件中的配置文件）

1、饿汉式：先初始化对象，类一进内存就加载

1. class Single   
   
2. {  
   
3.     private Single(){}  
   
4.     private static Single s = new Single();  
   
5.     public static  Single getSingle()  
   
6.     {  
   
7.         return s;  
   
8.     }  
   
9. }  
   
10.   
    
11. class SingleText  
    
12. {  
    
13.     public static void main(String [] args)  
    
14.     {  
    
15.         Single s1 = Single.getSingle();  
    
16.         Single s2 = Single.getSingle();  
    
17.         if (s1==s2)  
    
18.             System.out.println(true);  
    
19.         else  
    
20.             System.out.println(false);        
    
21. }
    
22. }  
    

复制代码

2、懒汉式：类进内存，对象还没有存在，只有调用了getSingle方法时，才建立对象

1. class Single  
   
2. {  
   
3.     private static Single s = null;  
   
4.     private Single(){}  
   
5.     public static Single getInstance()  
   
6.     {  
   
7.         if (s == null)  
   
8.         {  
   
9.             synchronized(Single.class)  
   
10.             {  
    
11.                 if (s == null)  
    
12.                     s = new Single();  
    
13.             }  
    
14.         }  
    
15.         return s;  
    
16.     }  
    
17. }
    

复制代码

模板方法：在定义功能时，功能的一部分是确定的，但有一部分是不确定的，而确定的部分在使用不确定的部分，那次是讲不确定的部分（抽象）暴露出去，由子类完成具体内部（复写），如下面的例子，study的具体方法需要子类去实现

1. class Person{}
   
2. abstract class PersonFunction{
   
3.         private Person p;
   
4.         PersonFunction(Person p){
   
5.                 this.p = p;
   
6.         }
   
7.         private void breath()
   
8.         {
   
9.                 System.out.println("我在呼吸");
   
10.         }
    
11.         public abstract void study();
    
12. }
    

复制代码

装饰类：

装饰类是对已有对象进行功能的增强，将已有对象作为参数传入，基于已有的功能，并提供加强的功能。装饰类是一种组合结构，和被装饰的类同属一个体系。装饰模式比继承更灵活，避免了继承体系的臃肿，且降低了类与类之间的关系

1. class MyBufferReader extends MyReader
   
2. {
   
3.         private MyReader r;
   
4.         MyBufferReader(MyReader r)
   
5.         {}
   
6. }
   

复制代码

16、装饰类和继承的区别和联系？

区别：

装饰类是对已有对象进行功能的增强，将已有对象作为参数传入，基于已有的功能，并提供加强的功能。装饰类是一种组合结构，和被装饰的类同属一个体系。装饰模式比继承更灵活，避免了继承体系的臃肿，且降低了类与类之间的关系

继承是当两个事物之间存在一定的所属关系时，可以使用继承，继承的类可以使用被继承类中的功能和属性，提高代码的复用性。让类与类之间产生了关系。但不能为了使用一个类的方法，就任意继承。

联系：

可以说装饰类和被装饰类同继承一个类，是被继承类体系下的子类。

17、Outer.Inner in = new Outer().new Inner()，请对这句话解释一下

这个是在外部其他类中直接建立内部类对象的格式，即

外部类名.内部类名  变量名 = 外部类对象.内部类对象

18、在多线程中，为什么要覆盖run方法？

覆盖run方法的原因：

1）Thread类用于描述线程。该类定义了一个功能：用于存储线程要运行的代码，该存储功能即为run方法。也就是说，Thread类中的run方法用于存储线程要运行的代码，就如同main方法存放的代码一样。

2）复写run的目的：将自定义代码存储在run方法中，让线程运行要执行的代码。直接调用run，就是对象在调用方法。调用start()，开启线程并执行该线程的run方法。如果直接调用run方法，只是将线程创建了，但未运行。

19、String s = newString("ABC")创建了几个对象？

创建了两个对象，一个对象存在于常量池中，一个对象存在于堆内存中，原理是，当创建“ABC”时，先检查常量池中是否存在这个字符串，如果没有，则创建一个新的“ABC”字符串对象；之后再在堆内存中new一个对象，并将地址值赋给s。