面试例题1：下面程序的结果是什么？[Trend公司面试题] class Tester
{
int var;
Tester(double var)
{
this.var = (int)var;
}
Tester(int var)
{
this("hello");
}
Tester(String s)
{
this();
System.out.println(s);
}
Tester()
{
System.out.println("good-bye");
}
public static void main(String[] args)
{
Tester t = new Tester(5);
}
}
答案：
good-bye
hello
扩展知识（变量的内存分配情况）
在Java中 有两个非常特殊的变量：this和super，这两个变量在使用前都是不需要声明的。this变量使用在一个成员函数的内部，指向当前对象，当前对象指的 是调用当前正在执行方法的那个对象。super变量是直接指向超类的构造函数，用来引用超类中的变量和方法。因此它们都是非常有用的变量。下面介绍一下 this的使用方法。
先看下面的一段代码。
class PersonInformation
{
String name,gender,nationality,address;
int age;
void PersonInformation(String p_name,String p_gender,String
p_nationality,String p_address,int p_age)
{
name=p_name;
gender=p_gender;
nationality=p_nationality;
address=p_address;
age=p_age;
}
}
在PersonInformation()函数中这个对象的方法提示可以直接访问对象的成员变量，而且在同一个范围中，定义两个相同的名字的局部变量是不 允许的。如果确实想使类的成员变量与方法的参数或方法自己定义的局部变量同名的话，就需要想一种方法使成员变量与跟它同名的方法参数或局部变量区分开来， 这就要使用到this变量。下面改写一下上面的代码，使PersonInformation类的构造函数的每个参数都有与对象成员变量相同的名字，而成员 变量的初值由参数给出。
class PersonInformation
{
String name,gender,nationality,address;
int age;
void PersonInformation(String name,String gender,String nationality,String address,int age)
{
this.name=name;
this.gender=gender;
this.nationality=nationality;
this.address=address;
this.age=age;
}
}
从上例中可以看出，该构造函数中必须使用this。this在方法体中用来指向引用当前正在执行方法的那个对象实例。this变量的类型总是为包含前执行 方法的类。在上例中，我们要区别参数name和成员变量name，写成name=name显然是不允许的。在参数或局部变量名与类成员变量名相同的时候， 由于参数或局部变量的优先级高，这样在方法体中参数名或局部变量名将隐藏同名的成员变量，因此，为了指明成员变量，必须使用this显式地指明当前对象。
有时候会遇到这种情况，全面地访问当前对象，而不是访问某一个个别的实例对象，此时也可以使用this，并利用Java中 的toString ()方法（它能够返回一个描述这个对象的字符串）。如果把任何一个对象传递到System.out.println方法中，这个方法调用这个对象的 toString方法，并打印出结果字符串，所以，可以用System.out.println(this)方法来打印出固有参数的当前状态。
this还有一个用法，就是构造函数的第一个语句，它的形式是this(参数表)，这个构造函数就会调用同一个类的另一个相对的构造函数。请看下面的例子。
class UserInfo
{
public UserInfo(String name)
{
this(name,aNewSerialNumber);
}
public Userinfo(String name,int number)
{
userName=name;
userNumber=number;
}
}
如果调用UserInfor newinfotable = new UserInfo("Wayne Zheng")，就会自动调用UserInfo(String name,int number)构造函数。
可见，熟练掌握this在Java程序设计过程中是非常重要的。
面试例题2：以下代码的运行结果是 。[Advantech公司2005年12月面试题]
class Base{
int i;
Base(){
add(1);
System.out.println(i);
}
void add(int v){
i+=v;
System.out.println(i);
}
void print(){
System.out.println(i);
}
}
class MyBase extends Base{
MyBase(){
add(2);
}
void add(int v){
i+=v*2;
System.out.println(i);
}
}
public class TestClu {
public static void main(String[] args) {
go(new MyBase());
//System.out.println();
}
static void go(Base b){
b.add(8);
//b.print();
}
}
A．12 B．11 C．22 D．21
解析：
程序流程是这样的：在主函数中，首先执行new MyBase()，在这个过程中，子类会首先调用父类的构造函数；在父类的构造函数Base()中执行add()方法。这里需要注意，这个add方法由于 是在新建MyBase对象时调用的，将会首先查找MyBase类中是否有此方法。所以，Base()函数中的add(1)实际上是：
//add(1)调用的是Mybase类的方法？？真奇怪
void add(int v)
{
i+=v*2; System.out.println(i);
}
此时i的值即为2。在打印两个2之后，父类构造函数执行完毕，执行子类的构造函数，即MyBase()，这里的add(2)当然也是子类的。i的值就变为了6。
最后执行go函数，i即为22。
答案：C
--------------------------------------------------------super 分割线-----------------------------------------------------------
——此文章摘自《Java程序员面试宝典》定价：46元 特价：38.9元 购买>>
面试例题1：以下代码的输出结果是下列哪个选项？[Sun公司2005年面试题]
class Base{Base(){
System.out.println("Base");
}
}
public class Checket extends Base{
Checket(){
System.out.println("Checket");
super();
}
public static void main(String argv[]){
Checket c = new Checket();
// super();
}
}
A．Compile time error
B．Checket followed by Base
C．Base followed by Checket
D．runtime error
解析：这是一个考查super构造函数的面试例题。子类的构造函数如果要引用super的话，必须把super放在函数的首位，不然会出现这样的报错：
Checket.java:10: call to super must be first statement in constructor
super();
如果一定要引用super构造函数，则必须把super()放在前面，代码如下。
class Base{Base(){
System.out.println("Base");
}}
public class Checket extends Base{ Checket(){
super();
System.out.println("Checket");
} public static void main(String argv[]){
Checket c = new Checket();
// super();
}
}
答案：会出现编译报错，选项A
面试例题2：Java里在类中用super调用父类构造函数时，为什么调用语句必须是子类的第一条语句？[Siemens公司2005年面试题]
答案：如果想用super继承父类构造的方法，但是没有放在第一行的话，那么在super之前的语句，肯定是为了满足自己想要完成某些行为的语句，但是又 用了super继承父类的构造方法。那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。如下面的程序所示。
class Father
{
public Father()
{String name=null;
int age=0;}
}
class Son extends Father
{
public Son()
{String name="学生";
super(); //调用父类的构造函数，此时name又变回null，所以super()必须放第一条语句
}
}
扩展知识（Java中的super类）
在Java中，有时还会遇到子类中的成员变量或方法与超类（有时也称父类）中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高，所以子类中的 同名成员变量或方法就隐藏了超类的成员变量或方法，但是我们如果想要使用超类中的这个成员变量或方法，就需要用到super。请看下面的类。
class Country
{
String name;
void value()
{
name="China";
}
}
在下面的子类中，子类的成员变量和方法隐藏了超类的成员变量name和方法value()。
class City extends Country
String name;
void value()
{
name="Hefei";
super.value();
System.out.println(name);
System.out.println(super.name);
}
为了在子类中引用超类中的成员变量name和方法value()，在代码中使用了super、super.name和super.value()，所以显示的结果为：
Hefei
China
如果想要使用超类的构造函数，则应当使用super(参数列表)的形式
面试例题3：给定下面的代码，哪个选项在替代"//Here"后可以被编译并且改变变量oak的值？
class Base{
static int oak=99;
}
public class Doverdale extends Base{
public static void main(String argv[]){
Doverdale d = new Doverdale();
d.amethod();
}
public void amethod(){
//Here
}
}
A．super.oak=1;
B．oak=33;
C．Base.oak=22;
D．oak=50.1;
解析：因为变量oak被声明是静态的，如果它存在只能有一个本体，则它可以通过本类的名字或者通过定义本类的任何一个实例被改变。
答案：A、B、C
面试例题4：当编译和运行下列代码时会发生下列哪种情况？
class Base{
Base(){
System.out.println("Base");
}
}
public class Checket extends Base{
public static void main(String argv[]){
Checket c = new Checket();
super();
}
Checket(){
System.out.println("Checket");
}
}
A．Compile time error
B．Checket followed by Base
C．Base followed by Checket
D．runtime error
解析：
用Sun的JDK运行会出现下列出错信息。
"Only constructors can invoke constructors"
Checket作为一个构造方法应该在调用时从最老的祖先类开始向下调用，调用super会引起程序在编译和运行时间上的错误。
Java中的关键字super：调用父类的属性，一个类中如果有int x属性，如果其子类中也定义了int x属性的话，在子类中调用父类的x属性时应用super.x＝6，表示该x是引用的父类的属性，而要表示子类中的x属性的话，使用this.x。
this和super：在Java中， this通常指当前对象，super则指父类的对象。若想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，便可以利用this 来实现这个目的。当然，this的另一个用途是调用当前对象的另一个构造函数。如果想引用父类的某种东西，则非super莫属。
Java里在子类中用super调用父类构造函数时，调用函数必须放在子类的第一条语句的位置，如果想用super继承父类构造的方法，但是没有放在第一 行的话，那么在super之前的语句，也许是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法，以前所做的修改就都回到以前 了，也就是说又成了父类的构造方法了。