几道面试题求解 大家说完答案后说说为什么阿
面试例题1：以下创建了几个对象______。
String A,B,C
A = "a";
B = "b";
A = A + B;
StringBuffer D = new StringBuffer("abc");
D = D.append("567"); A 4 B 3 C 5 D 6
2以下程序错误的是______
A. short s=1;s=s+1;
B. short s=1;s+=1;3哪个方法不改变线程的状态______
A start() B run() C isAlive() D sleep()4如何实现java的序列化______(这道题没看懂)
A .page B request C session D application5在Java程序的异常处理中，总是表示执行的语句是______
A final B finally C finalize D都不是6List.Map.Set等接口中，不能包含重复元素的接口是______
A List B Map C Set D都不是7 以下______断代马不会被执行
try{
code1......
Return;
code2......
}catch(Exception e)
{
code3
}
finally
{
code4
}
A code1 B code2 C code3 D code4
面试例题1：以下创建了几个对象______。
String A,B,C
A = "a";
B = "b";
A = A + B;
StringBuffer D = new StringBuffer("abc");
D = D.append("567"); A 4 B 3 C 5 D 6
2以下程序错误的是______
A. short s=1;s=s+1;
B. short s=1;s+=1;3哪个方法不改变线程的状态______
A start() B run() C isAlive() D sleep()4如何实现java的序列化______(这道题没看懂)
A .page B request C session D application5在Java程序的异常处理中，总是表示执行的语句是______
A final B finally C finalize D都不是6List.Map.Set等接口中，不能包含重复元素的接口是______
A List B Map C Set D都不是7 以下______断代马不会被执行
try{
code1......
Return;
code2......
}catch(Exception e)
{
code3
}
finally
{
code4
}
A code1 B code2 C code3 D code4
但是 第4题 不明白
String A,B,C
A = "a"; //这里创建了两个对象
B = "b"; //这里创建了两个对象
A = A + B; //A+B重创建了一个对象
StringBuffer D = new StringBuffer("abc"); //D为新创建的一个对象
D = D.append("567");
A 4 B 3 C 5 D 6
2以下程序错误的是__A____
A. short s=1;s=s+1; //s+1为int,不能直接赋值给short
B. short s=1;s+=1;3哪个方法不改变线程的状态_ C____
A start() B run() C isAlive() D sleep()4如何实现java的序列化______(这道题没看懂) //什么意思？
A .page B request C session D application5在Java程序的异常处理中，总是表示执行的语句是__B__
A final B finally C finalize D都不是
6List.Map.Set等接口中，不能包含重复元素的接口是_C____
A List B Map C Set D都不是
7 以下__B___断代马不会被执行
try{
code1......
Return;
code2......
}catch(Exception e)
{
code3
}
finally
{
code4
}
A code1 B code2 C code3 D code4
第4题不明白，其他意见与gadyic(linz) 相同
A. short s=1;s=s+1;
B. short s=1;s+=1;
C当中都对吧？
第二题中s=s+1是错误的，因为1是int型，在计算s+1的时候会把s转型为int，然后把int赋给short型的s时就会出错
第4题不明白，java的序列化应该是实现Serializable接口，不明白题目是什么意思
String A,B,C
A = "a";
B = "b";
A = A + B;
StringBuffer D = new StringBuffer("abc");
D = D.append("567");
A 4 B 3 C 5 D 6
2以下程序错误的是__A____
A. short s=1;s=s+1; //s+1为int,不能直接赋值给short
B. short s=1;s+=1;3哪个方法不改变线程的状态_ C____
A start() B run() C isAlive() D sleep()4如何实现java的序列化______(这道题没看懂) 不懂？
A .page B request C session D application5在Java程序的异常处理中，总是表示执行的语句是__B__
A final B finally C finalize D都不是
6List.Map.Set等接口中，不能包含重复元素的接口是_C____ //
A List B Map C Set D都不是
7 以下__B___断代马不会被执行
try{
code1......
Return; //已经返回了，故怎么也不可能执行code2语句了
code2......
}catch(Exception e)
{
code3
}
finally
{
code4
}
A code1 B code2 C code3 D code4
DAC(NO)BCB
2,a
3,c
4,不懂
5,b
6,不會
7,b
创建的对象分别为： 'a', 'b', 'ab', 'abc', '567', new StringBuffer();所以为 6 个。
http://community.csdn.net/Expert/topic/5120/5120787.xml?temp=.6160547String s = new String("abc");创建了几个String Object?
引用变量与对象的区别；
字符串文字"abc"是一个String对象；
文字池(pool of literal strings)和堆(heap)中的字符串对象。 一、引用变量与对象：除了一些早期的Java书籍和现在的垃圾书籍，人们都可以从中比较清楚地学习到两者的区别。
A aa;
这个语句声明一个类A的引用变量aa[我们常常称之为句柄]，而对象一般通过new创建。所以题目中s仅仅是一个引用变量，它不是对象。 二、Java中所有的字符串文字[字符串常量]都是一个String的对象。有人[特别是C程序员]在一些场合喜欢把字符串"当作/看成"字符数组，
这也没有办法，因为字符串与字符数组存在一些内在的联系。事实上，它与字符数组是两种完全不同的对象。 System.out.println("Hello".length());
char[] cc={'H','i'};
System.out.println(cc.length); 三、字符串对象的创建:
由于字符串对象的大量使用(它是一个对象，一般而言对象总是在heap分配内存)，Java中为了节省内存空间和运行时间
(如比较字符串时，==比equals()快)，在编译阶段就把所有的字符串文字放到一个文字池(pool of literal strings0中，
而运行时文字池成为常量池的一部分。文字池的好处，就是该池中所有相同的字符串常量被合并，只占用一个空间。
我们知道，对两个引用变量，使用==判断它们的值(引用)是否相等，即指向同一个对象： String s1 = "abc" ;
String s2 = "abc" ;
if( s1 == s2 ) System.out.println("s1,s2 refer to the same object");
else System.out.println("trouble");
这里的输出显示，两个字符串文字保存为一个对象。就是说，上面的代码只在pool中创建了一个String对象。 现在看String s = new String("abc");语句，这里"abc"本身就是pool中的一个对象，而在运行时执行new String()时，
将pool中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s持有。ok，这条语句就创建了2个String对象。
String s1 = new String("abc") ;
String s2 = new String("abc") ;
if( s1 == s2 ){ //不会执行的语句}
这时用==判断就可知，虽然两个对象的"内容"相同(equals()判断)，但两个引用变量所持有的引用不同， BTW：上面的代码创建了几个String Object? (三个，pool中一个，heap中2个。)
(Java2 认证考试学习指南 (第4版)( 英文版)p197-199有图解。)
第一题争议很大
应该创建的是'a','b','ab','abc',stringbuffer对象,'567'所以一共是6个
对象的序列化
Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte，这样日后要用这个对象时候，你就能把这些byte数据恢复出来，并据此重新构建那个对象了。这一点甚至在跨网络的环境下也是如此，这就意味着序列化机制能自动补偿操作系统方面的差异。也就是说，你可以在Windows机器上创键一个对象，序列化之后，再通过网络传到Unix机器上，然后在那里进行重建。你不用担心在不同的平台上数据是怎样表示的，byte顺序怎样，或者别的什么细节。对象序列化本身就非常有趣，因为它能让你实现"轻量级的persistence(lightweight persistence)"。所谓persistence是指，对象的生命周期不是由程序是否运行决定的；在程序的两次调用之间对象仍然还活着。通过"将做过序列化处理的对象写入磁盘，等到程序再次运行的时候再把它读出来"，你可以达到persistence的效果。之所以说"轻量级"，是因为你不能用像"persistent"这样的关键词来直接定义一个对象，然后让系统去处理所有细节(虽然将来有可能会这样)。相反，你必须明确地进行序列化(serialize)和解序列化(deserialize)。如果你需要更为正式的persistence功能，可以考虑Java Data Object( 简称是JDO)或Hibernate之类的工具(http://hibernate.sourceforge.net)。至于具体的内容，请到www.BruceEckel.com 去下载Thinking in Enterprise Java。之所以要在语言里加入对象序列化是因为要用它来实现两个重要的功能。Java的远程方法调用(Remote Method Invocation简称RMI)能让你像调用自己机器上的对象那样去调用其它机器上的对象。当你向远程对象传递消息的时候，就需通过对象序列化来传送参数和返回值了。RMI会在Thinking in Enterprise Java作讨论。我们会在第14章讲到JavaBean。对JavaBean来说，对象序列化也是必不可少的。Bean的状态信息通常是在设计时配置的。这些状态信息必须保存起来，供程序启动的时候用；对象序列化就负责这个工作。序列化一个对象还是比较简单的，只要让它实现Serializable接口就行了(这是一个"标记接口(tagging interface)"，没有任何方法)。但是，当语言引入序列化概念之后，它的很多标准类库的类，包括primitive的wrapper类，所有的容器类，以及别的很多类，都会相应地发生改变。甚至连Class对象都会被序列化。要想序列化对象，你必须先创建一个OutputStream，然后把它嵌进ObjectOutputStream。这时，你就能用writeObject( )方法把对象写入OutputStream了。读的时候，你得把InputStream嵌到ObjectInputStream里面，然后再调用readObject( )方法。不过这样读出来的，只是一个Object的reference，因此在用之前，还得先下传。对象序列化最聪明的一点是，它不仅能保存对象的副本，而且还会跟着对象里面的reference，把它所引用的对象也保存起来，然后再继续跟踪那些对象的reference，以此类推。这种情形常被称为"单个对象所联结的'对象网'"。这个机制所涵盖的范围不仅包括对象的成员数据，而且还包含数组里面的reference。如果你要自己实现对象序列化的话，那么编写跟踪这些链接的程序将会是一件非常痛苦的任务。但是，Java的对象序列化就能精确无误地做到这一点，毫无疑问，它的遍历算法是做过优化的。下面这段程序用"蠕虫(Worm)"，测试了对象序列化机制。Worm除了保存Data数组之外，还有一个指向下一个Worm的reference：//: c12:Worm.java
// Demonstrates object serialization.
// {Clean: worm.out}
import java.io.*;
import java.util.*;
class Data implements Serializable {
private int n;
public Data(int n) { this.n = n; }
public String toString() { return Integer.toString(n); }
}
public class Worm implements Serializable {
private static Random rand = new Random();
private Data[] d = {
new Data(rand.nextInt(10)),
new Data(rand.nextInt(10)),
new Data(rand.nextInt(10))
};
private Worm next;
private char c;
// Value of i == number of segments
public Worm(int i, char x) {
System.out.println("Worm constructor: " + i);
c = x;
if(--i > 0)
next = new Worm(i, (char)(x + 1));
}
public Worm() {
System.out.println("Default constructor");
}
public String toString() {
String s = ":" + c + "(";
for(int i = 0; i < d.length; i++)
s += d[i];
s += ")";
if(next != null)
s += next;
return s;
}
// Throw exceptions to console:
public static void main(String[] args)
throws ClassNotFoundException, IOException {
Worm w = new Worm(6, 'a');
System.out.println("w = " + w);
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream("worm.out"));
out.writeObject("Worm storage\n");
out.writeObject(w);
out.close(); // Also flushes output
ObjectInputStream in = new ObjectInputStream(
new FileInputStream("worm.out"));
String s = (String)in.readObject();
Worm w2 = (Worm)in.readObject();
System.out.println(s + "w2 = " + w2);
ByteArrayOutputStream bout =
new ByteArrayOutputStream();
ObjectOutputStream out2 = new ObjectOutputStream(bout);
out2.writeObject("Worm storage\n");
out2.writeObject(w);
out2.flush();
ObjectInputStream in2 = new ObjectInputStream(
new ByteArrayInputStream(bout.toByteArray()));
s = (String)in2.readObject();
Worm w3 = (Worm)in2.readObject();
System.out.println(s + "w3 = " + w3);
}
} ///:~
为了让事情变得更有趣一点，我们用随机数来初始化Worm的Data数组的对象。(这样你就不用怀疑编译器会保存什么元信息了(meta-information)。)Worm的每一段都有一个char标记，这是递归生成Worm链表时自动产生的。创建Worm时，你得告诉它有多长。然后它会用这个长度减一去调用构造函数，并且把生成的Worm对象传给next。最后一个next的reference是null，表示Worm结束了。之所以要这么做，就是想让事情变得稍微复杂一点，不要那么容易就被序列化了。但是真正做序列化的时候还是挺简单的。先创建一个ObjectOutputStream，然后用writeObject( )进行序列化。注意一下，对String对象我们也用了writeObject( )。此外，你还可以像使用DataOutputStream一样，用同样的方法把primitive数据写进去(接口是相同的)。这里有两段看起来很相似的代码。第一段读写的是文件，第二段读写的是ByteArray变量。有了序列化，你就能将对象读写入任何DataInputStream和DataOutputStream了，看过Thinking in Enterprise Java之后，你甚至还能把对象写到网络里去。下面是程序某次运行的输出：Worm constructor: 6
Worm constructor: 5
Worm constructor: 4
Worm constructor: 3
Worm constructor: 2
Worm constructor: 1
w = :a(414):b(276):c(773):d(870):e(210):f(279)
Worm storage
w2 = :a(414):b(276):c(773):d(870):e(210):f(279)
Worm storage
w3 = :a(414):b(276):c(773):d(870):e(210):f(279)你会发现，对象恢复出来之后，原来的链接还在。注意，在Serializable对象的恢复过程中，我们没调用过任何一个构造函数，包括默认的构造函数。整个对象完全是用InputStream里面的数据恢复出来的。对象序列化是面向byte的，因而要用InputStream和OutputStream。查找class
可能你已经在问了，把对象从序列化状态中恢复出来的必要条件是什么。比方说，把序列化的对象以文件或网络传输的方式送到了另一台机器。那台机器是否可以仅凭文件的内容就重建这个对象？要想回答这个问题，最好的办法(和平常一样)还是做实验。下面这段程序放在子目录下：//: c12:Alien.java
// A serializable class.
import java.io.*;
public class Alien implements Serializable {} ///:~
创建并序列化Alien对象的程序也在放在这个子目录里面(译者注：Alien是外星人的意思)：//: c12:FreezeAlien.java
// Create a serialized output file.
// {Clean: X.file}
import java.io.*;
public class FreezeAlien {
// Throw exceptions to console:
public static void main(String[] args) throws Exception {
ObjectOutput out = new ObjectOutputStream(
new FileOutputStream("X.file"));
Alien zorcon = new Alien();
out.writeObject(zorcon);
}
} ///:~
我们没有去捕捉和处理异常，相反用了一种粗糙但是却比较实用的"直接从main( )往外面抛异常"的做法，因此错误会送到控制台上。 等我们编译完程序开始运行，它就会在c12目录里生成一个X.file文件。下面是xfiles子目录下的程序：//: c12:xfiles:ThawAlien.java
// Try to recover a serialized file without the
// class of object that's stored in that file.
// {ThrowsException}
import java.io.*;
public class ThawAlien {
public static void main(String[] args) throws Exception {
ObjectInputStream in = new ObjectInputStream(
new FileInputStream(new File("..", "X.file")));
Object mystery = in.readObject();
System.out.println(mystery.getClass());
}
} ///:~
String A,B,C
A = "a"; // 这个"a"算一个
B = "b"; // 这个"b"也算一个
A = A + B; // A+B也生成一个新的对象
StringBuffer D = new StringBuffer("abc"); // "abc"算一个，然后产生的new StringBuffer也算一个
D = D.append("567"); // 这个"567"算一个
呵呵，这题是有争议，不过我发现我的意见还是符合大多数人的意见的^_^2. 这题原没看出来，现在学到了^_^3. C.isAlive()，检查状态而已，不会……吧^_^4. 这题意看不懂，如何序列化？就是转成byte序列嘛，不明它到底是什么意思，选C.session吧^_^，因为session里的东西的东西通常是在Cookie里的，要在服务器与客户端之间传来传去，当然是经过序列化了的吧？^_^5. B.finnally，这题简单吧^_^6. C.Set，集合嘛，当然没有重复啦，概念性问题^_^或说是常识性问题。7. B.code2，因为code1必然会被执行，执行code1后如果没有异常则被return了，如果有Exception异常则跳到code3，否则，如果有Error或其它实现了Throwable接口的东东抛出则执行code4，至于killme2008说的Unreachable code的error问题，其实强硬编译一下还是行的^_^，就算是有语法错误都能编译出class来啊，呵呵
A = "a";
B = "b";
A = A + B;
明显创建了3个对象
String与StringBuffer
Java 开发人员熟悉在一个循环中使用StringBuffer 来代替串联 String 对象能获得最佳性能。然而，多数开发人员从来没有比较两种方法产生的字节代码的区别。在 Java 开发工具包（JDK）中有一个叫做 javap 的工具可以告诉你为什么这样做可以获得最佳性能。Javap 将一个类和它的方法的一些转储信息输出到标准输出。该工具不把代码反编译为 java 源代码，但是它会把字节代码反汇编成为由 Java 虚拟机规范定义的字节代码指令。在你需要查看编译器为你或者给你做了什么的时候，或者你想要看一处代码的改动对编译后的类文件有什么影响的时候，javap 相当有用。现在以我们前面提到的 StringBuffer 和 String 作为一个例子。下面是一个专门为例子设计的类，它有两个方法，都返回一个由0到 n 的数字组成的 String，其中 n 由调用者提供。两个方法唯一的区别在于一个使用 String 构建结果，另外一个使用 StringBuffer 构建结果。public class JavapTip {
public static void main(String []args) {
}
private static String withStrings(int count) {
String s = "";
for (int i = 0; i < count; i++) {
s += i;
}
return s;
}
private static String withStringBuffer(int count) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < count; i++) {
sb.append(i);
}
return sb.toString();
}
} 现在让我们看看对这个类使用?Cc 选项运行 javap 的输出。-c 选项告诉 javap 反汇编在类中遇到的字节代码。运行方式如下：>javap -c JavapTip 此命令的输出为：Method java.lang.String withStrings(int)
0 ldc #2
2 astore_1
3 iconst_0
4 istore_2
5 goto 30
8 new #3
11 dup
12 invokespecial #4
15 aload_1
16 invokevirtual #5
19 iload_2
20 invokevirtual #6
23 invokevirtual #7
26 astore_1
27 iinc 2 1
30 iload_2
31 iload_0
32 if_icmplt 8
35 aload_1
36 areturn
Method java.lang.String withStringBuffer(int)
0 new #3
3 dup
4 invokespecial #4
7 astore_1
8 iconst_0
9 istore_2
10 goto 22
13 aload_1
14 iload_2
15 invokevirtual #6
18 pop
19 iinc 2 1
22 iload_2
23 iload_0
24 if_icmplt 13
27 aload_1
28 invokevirtual #7
31 areturn 如果你以前没有看过 Java 汇编器，那么这个输出对你来说就会比较难懂，但是你应该可以看到 withString 方法在每次循环的时候都新创建了一个 StringBuffer 实例。然后它将已有的 String 的当前值追加到 StringBuffer 上，然后追加循环的当前值。最后，它对 buffer 调用 toString 并将结果赋给现有的 String 引用。withStringBuffer 方法与这个方法正好相反，在每次循环的时候 withStringBuffer 只调用现有 StringBuffer 的 append 方法，没有创建新的对象，也没有新的 String 引用。在这种情况下，我们已经知道了使用 StringBuffer 代替 String 是一种好的做法，但是如果我们不知道呢？那么 javap 可以帮助我们找到答案。在这里你可以看到更详细的关于String,StringBuffer 的解释你并不会经常需要一个 Java 反汇编器，但是当你需要的时候，知道你自己的机器已经有一个并且用法相当简单的反汇编器当然是一件好事。如果你感兴趣，看书看看 javap 的其它选项——或许你会发现在你的环境中需要的特性。
所以我认为创建了4个对象
A="a"创建了两个对象，一个是对象"a",令一个是对"a"的引用A.
第二题中s=s+1是错误的，因为1是int型，在计算s+1的时候会把s转型为int，然后把int赋给short型的s时就会出错
第4题不明白，java的序列化应该是实现Serializable接口，不明白题目是什么意思不要在这误导别人
你们家对象的引用句柄叫对象呀，对象在内存哪，对象的引用在内存哪,去看看书。
希望新手不要看这些所谓的面试题。有几个人的答案是正确的？不小心还被误导。
String A,B,C
A = "a";
B = "b";
A = A + B;
StringBuffer D = new StringBuffer("abc");
D = D.append("567");A 4 B 3 C 5 D 6
2以下程序错误的是___A___
A. short s=1;s=s+1;
B. short s=1;s+=1;3哪个方法不改变线程的状态__C____
A start() B run() C isAlive() D sleep()4如何实现java的序列化___D___(这道题没看懂)
A .page B request C session D application5在Java程序的异常处理中，总是表示执行的语句是___B___
A final B finally C finalize D都不是6List.Map.Set等接口中，不能包含重复元素的接口是__C____
A List B Map C Set D都不是7 以下___B___断代马不会被执行
try{
code1......
Return;
code2......
}catch(Exception e)
{
code3
}
finally
{
code4
}
A code1 B code2 C code3 D code4
面试例题1：以下创建了几个对象___c___。
String A,B,C
A = "a";//1
B = "b";//1
A = A + B;//1
StringBuffer D = new StringBuffer("abc");//1
D = D.append("567");//1A 4 B 3 C 5 D 6
2以下程序错误的是_a_____//还真有点糊涂，呵呵1是int的
A. short s=1;s=s+1;
B. short s=1;s+=1;3哪个方法不改变线程的状态___c___
A start() B run() C isAlive() D sleep()4如何实现java的序列化______(这道题没看懂)
A .page B request C session D application5在Java程序的异常处理中，总是表示执行的语句是___b___
A final B finally C finalize D都不是6List.Map.Set等接口中，不能包含重复元素的接口是___c___
A List B Map C Set D都不是7 以下____b__断代马不会被执行
try{
code1......
Return;
code2......
}catch(Exception e)
{
code3
}
finally///在return之前执行，一般总是执行，除了System.exit（0）
{
code4
}
A code1 B code2 C code3 D code4
6个对象和合
StringBuffer D = new StringBuffer("abc");//中是两个呵呵
String s;
But here you’ve created only the reference, not an object.所以我必须指出，A="a"; 只创建了一个对象 而不是两个。
哪个方法不改变线程的状态______
A start() B run() C isAlive() D sleep()答案B难道改变了线程的状态吗？
你的分析很有道理
可是append 中的"567"就不是对象吗？
B = "b" 一个 同上A = A + B 这里也只是1个StringBuffer D = new StringBuffer("abc"); 一个对象
D = D.append("567"); // 这句不产生新的对象所以是四个对象。
愚见。
D = D.append("567");
对于这两句的补充，有人认为StringBuffer D = new StringBuffer("abc");这里有两个对象下面是StringBuffer对于String类型参数的构造器代码
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
这里用的是append方法，
所以我认为这里只有一个对象
一、 JAVA基础培训
1． 孙鑫Java无难事（共108集）
本套光盘由孙鑫老师亲自授课录制。内容涵盖面广，从入门到精通，授课通俗易懂，分析问题独到精辟，学员通过本套光盘的学习，能够快速掌握Java编程语言，成为Java高手。
2． 张孝祥Java就业培训（共56集）
本套教学光盘深入浅出的理论分析、精练生动的案例讲解、亲切直观的操作界面、恍然大悟的学习收获。张孝祥老师的课程，就不用多说了。
3． 翁凯Java语言视频培训（共30集）
本视频教学是由浙江大学著名年轻计算机专家翁恺教授主讲，一共30集，讲得很好，从JAVA的基础讲起，由浅入深，绝对是精品。看本视频讲座最好是有一点c++的底子
二、 JAVA进阶培训
1． 赛迪网校J2EE软件工程师培训（J2EE基础13集 高级17集 案例7集）
本课程包括J2EE的各个主要方面，以及开发环境，设计模式，和经典案例分析等实用内容。通过本课程的学习，学员将具有J2EE开发的扎实理论基础和实际设计经验，可胜任企业级应用的设计和开发等实际工作。本课程共计约40课时。授课教师均是来自主流J2EE厂商并具有J2EE 5年以上开发和咨询经验的技术专家。
2． J2EE Web程序开发（共38集）
国内最知名的J2EE讲师刘晓涛讲师执教，课程生动形象并结合典型企业案例深入的分析。从零开始：该课程以零基础为起点，强调基础理论结合实际；以基础理论课程为第一阶段，到常用工具使用及工作应用为提高部分。专业性强：多平台软件开发(Windows/Linux) ；紧跟先进的技术（极限编程/测试驱动开发)；规范化（学习印度软件经验)；不仅仅是编程，在教学过程当中渗透设计思想；编程思想的熏陶，打通任督二脉，对编程语言一通百通；软件工程思想的灌输（分析，设计，实现，测试一条龙）。
三、 JAVA实战项目培训录像
该培训录像是北京尚学堂科技第一个项目（聊天系统）和 第二个项目（坦克大战）的课堂实录，马士兵老师以手把手一行一行代码的形式教大家如何开发一个示例性Chat和一个相当完备的TankWar游戏，详尽透彻的解释了j2se的常用知识，只要按照教程中的操作一步一步完成，你就足以掌握j2se/eclipse到能够进一步学习的水平了，项目实战，不容错过！
四、 Oracle 9i 大型视频培训录像（共64集，13.4G）
＊1Z0-007 Introduction to Oracle9i SQL
＊1Z0-031 Oracle9i DBA Fundamentals I
＊1Z0-032 Oracle9i DBA Fundamentals II
＊1Z0-033 Oracle9i Performance Tuning
另附全套PPT培训讲稿。联系方式：
QQ：421130479
MSN：[email protected]
Tel：13512510369（短信佳）
E-mail：[email protected]
1、StringBuffer D = new StringBuffer("abc"); 产生了两个对象，“abc”本身于经过NEW出来的不是一个对象，可以用 ==来检验；
2、对本题：
String A,B,C
A = "a";//引用不是对象，此处创建了一个对象以及一个引用A；
B = "b";//同上；
A = A + B;//同上，此处创建了一个对象，并有引用A来引用，那么原来A所指向的对象就成为垃圾对象，被回收；
StringBuffer D = new StringBuffer("abc");//StringBuffer的特点是改变对象本身而不是创建新的对象，因此此处以及D = D.append("567");都是同一个对象进行处理。而字符串对象也是一个对象，故就有两个对象；结论：
1、若讨论整个过程全部都产生过多少个对象，我认为是5个；
2、若问整个程序有多少个对象，我认为是4个，而这个应该是考官的意思。本题在 JAVA指南第三版 中字符一章的习题有同类题，可借鉴；
-------------------------------------------------------------------------------------
这里有漏洞，您看看StringBuffer's method.the parameter is String type,so why not three but two object?
那么简单的竟然叫做面试题？？郁闷
这里的A+B会创建对象吗？？各位讨论一下
StringBuffer D=new StringBuffer("abc"); 现在产生1个引用1个对象
----------------------------------------------------------------------------------
3 4
这个我的理解，有人能指正吗
String a="abc";
String b="abc";
两个"abc"是一个对象，和大家分享下。
哪个方法不改变线程的状态______
A start() B run() C isAlive() D sleep()答案B难道改变了线程的状态吗？
哪个方法不改变线程的状态___C___
A start() B run() C isAlive() D sleep()run()当然可以改变线程的状态，比如设置了优先级，线程可能转换为等待状态。
请看清楚题目是哪个方法不改变线程的状态
我想请问执行run()这个方法线程的状态会改变吗？
如果有个线程Thread thread = new Thread()那么
thread.start()是启动新线程
thread.sleep()是将当前线程休眠（主意sleep是静态方法）
那么
thread.run()方法是做什么的呢？只是在当前线程中去执行thread对象中定义的run方法，而对于thread这个线程根本就没做任何事情。
Class MyThread extends Thread {
public void run() {
System.out.println("run");
}
}
MyThread mythread = new MyThread();
myThread.start();
那么上面执行上面myThread.run()会改变线程状态吗？当然不会咯，只是打印一套语句，run方法中根本没有任何与线程有关的操作。
呵呵，我说的是在多线程的情况下！
我说的也是在多线程的情况下。我上面已经说的很清楚了，我们可以覆盖掉run方法，那么run方法还如何改变线程状态？
你就是一个sb难怪信誉96