又是面试题，供大家探讨研究

Question

1.
public class TT {
public static void main(String[] args)  {
String a = "A";
StringBuffer b = new StringBuffer("B");
StringBuffer c = new StringBuffer("C");
change(a,b,c);
System.out.println(a+","+b+","+c);
}
static void change(String s,StringBuffer s1,StringBuffer s2){
s= s+"1";
s1.append("1");
s2 = new StringBuffer("c1");
}
A:  A,B1,C
B:  A1,B1,C1
C:  A,B,C2.
class Tree{
void say(){}
}
class Point extends Tree{
void say(){
System.out.println("point");
}
}
class What extends Tree{
void say(){
System.out.println("what");
}
}
class Test{
static void aa(Tree t){
t.say();
}
public static void main(String[] args) {
Tree point = new Point();
Tree what = new What();
aa(point);
aa(what);
}
}
A:point
B:what
C:什么都不输出
D:编译不能通过3：写出该程序运行后控制台的输出
public class TestString{
public static void callA(int a,StringBuffer sb){
a = 10;
sb.append(" luck");
print(a,sb);
}
public static void callB(int a,StringBuffer sb){
a = 33;
sb = new StringBuffer("haha");
print(a,sb);
}
public static void print(int a,StringBuffer sb){
System.out.println(a);
System.out.println(sb.toString());
}
public static void main(String[] args) {
int a = 100;
StringBuffer sb = new StringBuffer("GOOD");
TestString.callA(a,sb);
TestString.callB(a,sb);
print(a,sb);
}

}
4：写出该程序运行后控制台的输出
class Parent{
Parent(){
System.out.println("Parent构造方法");
}
static{
System.out.println("Parent static");
}
}
class Child extends Parent{
Child(){
System.out.println("Child构造方法");
}
static{
System.out.println("Child static");
}
}
public class TestCons {
public static void main(String[] args) {
Parent chi = new Child();
}
}

Answer 1

1.A(值传递和作用域的问题)
2.C(没有向下转型，所以全部调用父类的方法)
3.(还是值传递和作用域的问题)
10
GOOD luck
33
haha
100
GOOD luck
4.(成员变量优先于构造函数，父类的默认的构造函数优先于子类的构造函数)
Child static
Parent static
Parent构造方法
Child构造方法

Answer 2

应该是先调用的parent static

Answer 3

2.C(没有向下转型，所以全部调用父类的方法) 
Tree point = new Point(); 
Tree what = new What(); 
aa(point); 
aa(what); 传的是子类实例，为什么调用父类方法

Answer 4

1.A（传值，传引用，作用域）
2.A ，B （类类型转换）
3.(传值，传引用，作用域) 
10 
GOOD luck 
33 
haha 
100 
GOOD luck 
4.(成员变量优先于构造函数，在new对象的时候，会首先检查是否有父类，如果有就先进行初始化
   父类的默认的构造函数优先于子类的构造函数) 
Parent static 
Child static 
Parent构造方法 
Child构造方法 

Answer 5

Tree point = new Point(); 
Tree what = new What(); 
aa(point); 
aa(what); 输出应该是point和what
很典型的多态。

Answer 6

1.A(值传递和作用域的问题) 
2.A,B
3.10
  GOODluck
  33
  haha
  100
  GOODluck
4.Parent static
  Child static
  Parent构造方法
  Child构造方法
  

Answer 7

1.A(值传递和作用域的问题)
2.A,B（自己运行测试的结果是这个）
3.(还是值传递和作用域的问题)
10
GOOD luck
33
haha
100
GOOD luck
4.(成员变量优先于构造函数，父类的默认的构造函数优先于子类的构造函数)
Parent static
Child static
Parent构造方法
Child构造方法 

Answer 8

第四题
Parent static
Child static
parent构造方法
Child构造方法

Answer 9

public class TT { 
    public static void main(String[] args)  { 
      String a = "A"; 
      StringBuffer b = new StringBuffer("B"); 
      StringBuffer c = new StringBuffer("C"); 
      change(a,b,c); 
    System.out.println(a+","+b+","+c); 
} 
    static void change(String s,StringBuffer s1,StringBuffer s2){ 
      s= s+"1"; 
      s1.append("1"); 
      s2 = new StringBuffer("c1"); 
} 
为什么输出结果是：A,B1,C呢，能不能详细解释一下，作用域的问题，能不能详细说一下？比较的困恼~这个问题·

Answer 10

我是这样认为的，chage之内a传递后，是a1，但是并没有传递出，所以，在change方法内a 是a1，但是出去之后还是a。

Answer 11

关于第二题，我测试的结果是C。
这里面的确涉及到了多态的知识，但是请注意，在aa方法中传进来的是Tree的类型，而在所有面向对象的语言中，
Tree t = new Tree();
里面控制对象类型的是前面的那个Tree，在aa中即使传进来是子类型的对象，由于参数被定义成了Tree类型，子类也会被向上转型为Tree类型，所以t.say(); 调用的自然而然也就是Tree里面的say()方法。如果想要调用子类的方法，必须在aa里面使用向下转型，这也是反射常用的技俩儿。

Answer 12

第二个很明显是D啊，没public class...

Answer 13

至于局部变量作用域的问题，如果是值类型的化，它的作用域只限于自己的大括号内。
String a="A"; 
这种写法相当于值类型。s1.append("1"); 
这种写法操作了内存中对象，内存中的值变成了B1s2=newStringBuffer("c1"); 
这种写法虽然也是对象，但是c1这个对象的作用域仅局限于change这个方法，没有被带回到main方法里面关于局部变量作用域，引用和对象在内存中怎么分配的概念很重要

Answer 14

1.A
2.D:编译不能通过(main方法在test类中，而test类是非public的，编译出错)。
3.
10
GOOD luck
33
haha
100
GOOD luck
4.
Parent static（加载Parent时） 
Child static （加载Child时）
Parent构造方法 （子类构造器先调用父类构造器）
Child构造方法 

Answer 15

谁说一个类不是public的就编译出错

Answer 16

main是一个静态方法 必须在public类中,第二个明显不是，编译怎么能通过？

Answer 17

public class TT {    public static void main(String[] args) {
        String a = "A";
        StringBuffer b = new StringBuffer("B");
        StringBuffer c = new StringBuffer("C");
        change(a, b, c);
        System.out.println(a + "," + b + "," + c);
    }    static void change(String s, StringBuffer s1, StringBuffer s2) {
        s = s + "1"; //s引用,指向了新的串s+"1",原来的值并未改变
        s1.append("1"); //s1引用，修改了引用本身的所指的值，所以原来引用值也变了
        s2 = new StringBuffer("c1"); //s2引用，引向了一个新的对象，原值未变
    }}

Answer 18

非public的有关系么？main方法调用的是它所在的类， 即使是private的都可以调用吧？

Answer 19

第一个里面都是引用传递，传递的是对象在内存中的地址，change方法里s,s2是将变量指向了新的地址，而原来的地址的内容没有改变，所以方法结束后原地址的值没有变。应该是这样理解的

Answer 20

你这句话是根据什么说的？静态发那个发必须在public类中？内部类？
我是真不知道有这种说法， 我还特意在eclipse下验证了一下， 结果是仍然输出A和B

Answer 21

一个类里面没有public class的话能编译通过么
我是初学者，不太懂

Answer 22

第一个选A没错
但是考查的不仅仅是值传递和作用域吧？还有 String和StringBuffer的区别
new 运算符
对象的==与equals

Answer 23

我确实验证了，但是第一次我用的不是Java，用的是C#。我一直以为Java和C#语法上略有不同，思想上应该是一样的，但是关于第二题，我下载了Java重新测试后结果确实和C#是不一样。C#里面走的是父类的方法，Java里面走的却是子类的方法，我很想知道这是为什么？

Answer 24

java中都是值传递， main方法中那个a传到方法里的时候在这个方法的时候a和方法里的s都指向"A", 执行了这句话后s->s1(s+"1"相当与new了一个新的string对象)。b和s1->对内存的那个"B"（b和s1的值都是同一个内存地址）,所以s1改变了后，b也改变。。s2由于使用了new所以s2指向了另外一个对象。

Answer 25

1.A
2.A,B
3.10 GOOD luck
  33,haha
  100,GOOD luck
4.Parent static
  Child static
  Parent构造方法
  Child构造方法

Answer 26

一个类使用了public修饰的话，他的java源文件名应该跟类名一样
比如说
public class Test{
}
这样写的话只能保存为Test.java,而不能使用别的名字为这个java源文件命名了

Answer 27

1. A B1 C
2. A B
3. 10 
   GOOD luck 
   33 
   haha 
   100 
   GOOD luck 
4. Parent static
   Child static 
   Parent构造方法
   Child构造方法 

Answer 28

一楼错了两个
第二题，为什么没向下转型？？？
第四题，parent static 比child static先输出。

Answer 29

看来是在你脑子里测试的吧，Tree point = new Point(); 这句话是父类引用指向子类对象。典型的多态体现。所以实际上new出来的是什么对象point.say()就调那个对象的say方法。实际new出来是一个Point对象，所以会调Point的say方法。（多态存在的条件：1.继承或实现接口。2.子类对父类的方法进行了重写。3父类引用指向子类对象）

Answer 30

1考察参数传递：传值引用 传引用（传地址）
2考察：基本语法 每一个Java文件中若有多个类，要有而且仅有一个public类
3考察局部变量和参数传递：方法内部的局部变量
4每一个static变量都在构造函数初始化之前初始化，基类构造函数在导出类构造之前初始化

Answer 31

我用的是C#测的，C#抄袭了Java很多，原本以为原理上的东西很多都是一样的

Answer 32

我也是初学者，对于第二题我原先也认为一个类中没public class 不行，但刚才用eclipse做了测试，还真的答案是A、B

Answer 33

真想不通为什么这么多人在回答问题前都不亲身测试一下呢，我测试的结果————每题都是亲自测试的结果：第一题：
A,B1,C第二题：
point
what第三题：
10
GOOD luck
33
haha
100
GOOD luck第四题：
Parent static
Child static
Parent构造方法
Child构造方法

Answer 34

1、答案为Ａ(因为当执行change(a,b,c)方法后，a所指的对象仍然为原来的对象，虽然s=s+"1"导致产生了一个新的对象，但是只是s指向了这个新产生的对象；而b指向的是一个StringBuffer对象，调用change方法后，字符'1'直接追加到原来的对象上；调用change方法后产生了一个新的值为'c1'的StringBuffer对象，而c仍然指向原来的值为'c'的StringBuffer对象)
2、答案为A、B(对变量的类型起决定作用的是后面的构造函数)
3、答案如下所示：
10
GOOD luck
33
haha
100
GOOD luck
注：主要难点是最后的那个print(a,sb),记得sb所指的那个对象仍然是原来创建的那个值为"GOOD"的StringBuffer对象
4、答案为：
Parent static
Child static
Parent构造方法
Child构造方法
注：标识为static的部分是在类被载入的时候执行的，而构造函数内的代码是在利用此构造函数创造该类的一个实例时被执行的。声明：我这些解答都是在Eclipse里面调试过的，希望我的回答对你的学习有点帮助！

Answer 35

是说当中有main方法，当然不能通过

Answer 36

第二题是D...   那个main方法中调用aa方法。根本没有Test.aa 哪能编译通过？

Answer 37

aa是个static静态方法，so可以直接调用也可以用类名.方法名调用。

Answer 38

第二题明显选AB，这个是个多态的问题，ok

Answer 39

第四题：初始化顺序：
父类的静态成员，静态块(按照顺序),子类的静态成员静态块，父类的非静态成员，非静态块
，父类的构造函数，子类的非静态成员，非静态块，子类的构造函数。
所以第四项的答案是
Parent static
Child static
Parent构造方法
Child构造方法

Answer 40

1:--->A
2:--->A、B
3:--->10,GOODluck     33,haha      100,GOODluck
4:--->
Parent static
Child static
Parent构造方法
Child构造方法1:关于值传递的问题，有不明白的可以去我博客看下，O(∩_∩)O哈哈~
http://blog.csdn.net/niuniu20008/archive/2008/09/19/2953785.aspx
大家记住当入参是一个对象的引用时：在方法内操作该对象时才能改变该对象，而操作引用时源对象是没有改变的。
而StringBuffer对象的append方法就是操作对象内容，此时的改变会在源对象内体现；而像sb=new StringBuffer(一个新的字符串);时则是操作引用，此时的改变不会在源对象内体现。
2：这个是考察：父引用(装子对象).方法， ---->分：父引用(装子对象).member方法和父引用(装子对象).static方法
（1）父引用(装子对象).子方法     //如果此时父中没有此方法，此时部分member和static,则在编译时就报错
（2）父引用(装子对象).父member方法     //如果此时子中没有此方法，走父的方法
（3）父引用(装子对象).父member方法/此时子重写了此方法         //就是说，子中也有此方法，则子压制父，走子方法(4)父引用(装子对象).父static方法  //走父方法（即使子重写了此方法，也走父方法，当调static方法时，按类名走）
4：考察的是在继承中static方法块和构造的执行顺序，下面我列出他们的顺序，
(1)父static方法块(2)子static方法块(3)父member方方块(4)父构造(5)子member方法块(6)子构造