看看我们公司的笔试题目，达人帮助解答下！多谢！

2. 下面代码的输出是什么？一共在内存中生成了几个String对象？为什么？
String s1 = “aaa”;
String s2 = “aaa”;
String s3 = new String(“aaa”);
String s4 = new String(“AAA”);
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s1.equals(s3));3. 下列程序在1处是否会有异常，如果没有，输出是什么？是否会运行到2处，如果会，输出是什么？为什么会有这样的结果？
public class TestClass {
public void test1() {
List list = new ArrayList();
test2(list);
System.out.println(list.size()); // 1处
test3(list);
System.out.println(list.size()); // 2处
}public void test2(List list) {
list = null;
}public void test3(List list) {
list.add(“aaaa”);
}
}

4. 请选出下面哪些描述是正确的。
public class ClassA {
public synchronized void a(){
}
public synchronized void b(){
}
}
2 instances of ClassA had been instantiated obj1 and obj2.
Which statements about thread are true?
1) One thread is calling obj1.a(), another thread can call obj1.b().  .
2) One thread is calling obj1.a(), another thread cannot call obj1.b().  
3) One thread is calling obj1.a(), another thread can call obj2.b().  .
4) One thread is calling obj1.a(), another thread cannot call obj2.b().  
5. 下面的程序输出是什么？为什么？
public class Parent {
public void test(ArrayList list) {
System.out.println("invoke parent's test method");
} public static void main(String[] args) {
Child a = new Child();
ArrayList list = new ArrayList();
a.test(list);
}
}class Child extends Parent {
public void test(List list) {
System.out.println("invoke child's test method");
}
}6. 下面的程序输出是什么？为什么？
public class Parent {
public void test(List list) {
System.out.println("invoke parent's test method");
} public static void main(String[] args) {
Child a = new Child();
ArrayList list = new ArrayList();
a.test(list);
}
}class Child extends Parent {
public void test(List list) {
System.out.println("invoke child's test method");
}
}7. 仔细分析下面的程序，写出程序的输出结果。
public class Parent {
{
System.out.println("parent instance block");
} public void test() {
System.out.println("parent test method");
} static {
System.out.println("parent static block");
} public Parent() {
System.out.println("parent constructor");
test();
} public static void main(String[] args) {
new Child();
}
}class Child extends Parent { private static int staticValue = 20;
private int instanceValue = 20; {
System.out.println("child instance block");
} public void test() {
System.out.println("child test method");
System.out.println("static value is: " + staticValue);
System.out.println("instance value is: " + instanceValue);
} static {
System.out.println("child static block");
} public Child() {
System.out.println("child constructor");
}
}8. 下面程序的输出是什么？
public class TestException {
public void test1() {
int result = test2();
System.out.println(result);
} public int test2() {
try{
String s = null;
s.substring(0, 1);
return 1;
} catch(Exception e) {
return 2;
} finally {
return 3;
}
} public static void main(String[] args) {
(new TestException()).test1();
}
}9. 请写出数据库查询操作的伪代码，程序不需要通过编译，只要思路正确，关键步骤不丢失就可以了。注意异常的捕获，IO流的关闭。可能用到的类或接口有（Connection，DriverManager, Statement, PreparedStatement, ResultSet, SQLException）。

解决方案 »

  1.   

    1。true false true 3个 
    2.没有结果输出，因为类没有被初始化
    3。1 3
    4。invoke parent's test method
    5。invoke child's test method
    6。看的晕
    7。2 不知道finaly的用法，所以选2
    8。不会
      

  2.   

    6.输出应该是不能识别ArrayList.
    没有import java.util.ArrayList;;我是这么想的，要不然也没必要用ArrayList作参数吧。
      

  3.   

    7的输出是
    parent static block
    child static block
    parent instance block
    parent constructor
    child test method
    static value is: 20
    instance value is: 0
    child instance block
    child constructor
      

  4.   

    根据这个结果来看，子类构建时是先初始化静态成员，然后调用父类的非静态初始化和缺省构造方法，构造中的test()方法实现了多态（JAVA编程思想里好像不提倡这么做，容易出问题）,接下来是子类的非静态初始化和构造方法。
      

  5.   

    最后一个输出是3，finally中的肯定会执行的
      

  6.   

    8.下面程序的输出是什么？
    public class TestException {
    public void test1() {
    int result = test2();
    System.out.println(result);
    }public int test2() {
    try{
    String s = null;
    s.substring(0, 1);
    return 1;
    } catch(Exception e) {
    return 2;
    } finally {
    return 3;
    }
    }
    答案是3
      

  7.   

    5.下面的程序输出是什么？为什么？
    public class Parent {
    public void test(ArrayList list) {
    System.out.println("invoke parent's test method");
    }public static void main(String[] args) {
    Child a = new Child();
    ArrayList list = new ArrayList();
    a.test(list);
    }
    }class Child extends Parent {
    public void test(List list) {
    System.out.println("invoke child's test method");
    }
    }
    答案是Reference to test is ambiguous
      

  8.   

    2.   true
         false
         true3    0,14    不懂5    invoke child's test method6    没有看出来和第5题有什么不一样的地方。7    parent static block
         child static block
         parent instance block
         parent constructor
         child test method
         static value is: 20
         instance value is: 0
         child instance block
         child constructor8    3
      

  9.   

    2:
    true
    false
    true
    3:
    1处会抛异常
    4:
    3)
    5:
    invoke child's test method
    国为arraylist是list的子类，arraylist也是list所以根椐多态的话，会调用public void test(List list) 
    6:
    invoke child's test method
    国为arraylist是list的子类，arraylist也是list所以根椐多态的话，会调用public void test(List list) 
      

  10.   

    2.
    true
    false
    true
    4个3.
    0,14.//请高手指点。
    2，45.
    invoke parent's test method6.
    invoke child's test method7.
    parent static block
    child static block
    parent instance block
    parent constructor
    child test method
    static value is: 20
    instance value is: 0
    child instance block
    child constructor8.
    39.
      

  11.   

    .下列程序在1处是否会有异常，如果没有，输出是什么？是否会运行到2处，如果会，输出是什么？为什么会有这样的结果？
    public class TestClass {
    public void test1() {
    List list = new ArrayList();
    test2(list);
    System.out.println(list.size()); // 1处
    test3(list);
    System.out.println(list.size()); // 2处
    }public void test2(List list) {
    list = null;
    }public void test3(List list) {
    list.add(“aaaa”);
    }
    }
    有异常，因为test2()把它的地址设为了NULL，对NULL的变量进进size()会报空指针异常
      

  12.   

    1.true false true
    2.没有初始化
    3.nchronized是当A占用线程时B必须等待,直到A用完该方法后才能允许其他线程用,1,3
    4.invoke parent's test method
    5.invoke child's test method
    先做到这,明天继续
      

  13.   

    2、
    true
    false
    true 
    4个对象
    3、1处不会有异常，输出是0，2处输出1
    4、1 3
    5、invoke parent's test method
    6、
    invoke child's test method
    7、
    parent static block
    child static block
    parent instance block
    parent constructor
    child test method
    static value is: 20
    instance value is: 0
    child instance block
    child constructor8、3
      

  14.   

    第一题中
    String s1 = “aaa”;
    String s2 = “aaa”;
    这2句不是建立2个引用s1和s2，分别指向2个字符串对象吗
    我看到书上说java中所有的对象都是建立在堆区的，分别建立这2个对象在内存中的地址不是就不一样了吗
    而s1＝＝s2不是比较他们的引用吗，这不是和c＋＋中的比较地址差不多吗，怎么结果会为true呢因为刚刚学java，很多原理还不明白，望高人指点一下啊、
      

  15.   

    2.下面代码的输出是什么？一共在内存中生成了几个String对象？为什么？
    String s1 = “aaa”;
    String s2 = “aaa”;
    String s3 = new String(“aaa”);
    String s4 = new String(“AAA”);
    System.out.println(s1 == s2);
    System.out.println(s1 == s3);
    System.out.println(s1.equals(s3));答案：会生成3个对象。true,false,true. 
    String s1 = “aaa”;
    String s2 = “aaa”;
    因为在编译期,编译器会检查出s1和s2的值是相同的字符串，所以在创建java字节码的时候s1和s2都指向"aaa"。
    3.下列程序在1处是否会有异常，如果没有，输出是什么？是否会运行到2处，如果会，输出是什么？为什么会有这样的结果？
    public class TestClass {
    public void test1() {
    List list = new ArrayList();
    test2(list);
    System.out.println(list.size()); // 1处
    test3(list);
    System.out.println(list.size()); // 2处
    }public void test2(List list) {
    list = null;
    }public void test3(List list) {
    list.add(“aaaa”);
    }
    }答案：没有异常。输出0,1.  
    因为在jvm的运行是基于stack。所有的参数传递都是值传递。包括对象传递也是传递的是对象引用(java heap中对象的地址)的一个copy，对这个copy的修改并不会影响调用函数变量的值。4.请选出下面哪些描述是正确的。
    public class ClassA {
    public synchronized void a(){
    }
    public synchronized void b(){
    }
    }
    2 instances of ClassA had been instantiated obj1 and obj2.
    Which statements about thread are true?
    1)One thread is calling obj1.a(), another thread can call obj1.b().  .
    2)One thread is calling obj1.a(), another thread cannot call obj1.b().  
    3)One thread is calling obj1.a(), another thread can call obj2.b().  .
    4)One thread is calling obj1.a(), another thread cannot call obj2.b().  应该是2，3。每个对象都有一个令牌去控制临界资源的访问,当前只能有一个线程拥有这个令牌。令牌通过synchronized获得。当线程访问obj1.a()的时候,线程A获得了obj1对象的令牌，所以其他线程B就不能再获得obj1对象的令牌，所以线程B会被阻塞。但是
    对于obj2没有被其他线程调用，就是说obj2的令牌没有被占有，所以线程B是可以访问obj2.b()的.
    5.下面的程序输出是什么？为什么？
    public class Parent {
    public void test(ArrayList list) {
    System.out.println("invoke parent's test method");
    }public static void main(String[] args) {
    Child a = new Child();
    ArrayList list = new ArrayList();
    a.test(list);
    }
    }class Child extends Parent {
    public void test(List list) {
    System.out.println("invoke child's test method");
    }
    }
    答案：是"invoke parent's test method". 因为这是在编译期间，编译器根据参数的类型就确定好了调用的函数是test(ArrayList list)，而不会去看对象实例的类型。
      

  16.   

    6.下面的程序输出是什么？为什么？
    public class Parent {
    public void test(List list) {
    System.out.println("invoke parent's test method");
    }public static void main(String[] args) {
    Child a = new Child();
    ArrayList list = new ArrayList();
    a.test(list);
    }
    }class Child extends Parent {
    public void test(List list) {
    System.out.println("invoke child's test method");
    }
    }答案：是"invoke child's test method". 因为这是用到了重载的概念。jvm会在运行期间根据具体对象的实例去调用对应的方法。在这里由于对象的实例是Child,所以调用的应该是child的test函数。
      

  17.   

    哇，这些题陷阱很多啊，学习ing...