几道Java笔试题

考点一：

try finally中return的执行顺序

1、

public class Test {
public static boolean decide() {
try {
System.out.println("First");
return true;
} finally {
System.out.println("Second");
return false;
}
}
public static void main(String args[ ]){
if (Test.decide()) {
System.out.println("True");
}else {
System.out.println("False");
}
}
}

输出结果：

First

Second

False

解析：

try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。

2、

public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Test().test());
}
static int test()     {
int x = 1;
try {
return x; }
finally  {
++x;
System.out.println(x);
System.out.println("aaa");
}
}
}

输出结果：

2

aaa

1
3、

public  class Test {
public static void main(String[] args) {
System.out.println(new Test().test());;
}
int test()
{
try
{
return func1();
}
finally
{
return func2();
}
}
int func1()
{
System.out.println("func1");
return 1;
}
int func2()
{
System.out.println("func2");
return 2;
}
}

输出结果：

func1

func2

2

考点二：多态。。。

4、

public class Test {
/**
* @param args
*/
public static void main(String[] args) {
Animal a = new Dog();
a.syaHi();
Animal b = new Bulldog();
b.syaHi();
Dog dog = (Dog)b;
dog.syaHi();
check(dog);
Bulldog bulldog = (Bulldog)b;
check(bulldog);
}
public static void check(Dog dog)
{
System.out.println("check dog"+dog.getName()+".");
}
public static void check(Bulldog bulldog)
{
System.out.println("check bulldog"+bulldog.getName()+".");
}
}
interface Animal
{
void syaHi();
String getName();
}
class Dog implements Animal
{
public String getName()
{
return "Bob";
}
private String bark()
{
return "wang-wang";
}
public void syaHi()
{
System.out.println("I am "+getName()+"."+bark());
}
}
class Bulldog extends Dog
{
@Override
public String getName(){return "Mike";}
private String bark(){return "WOO-WOO";}
}

输出结果：

I am Bob.wang-wang

I am Mike.wang-wang

I am Mike.wang-wang

check dogMike.

check bulldogMike.

考点三：构造函数

5、

public class Test {
public static void main(String[] args) {
BB bb = new BB();
bb = new BB();
}
}
class AA
{
static
{
System.out.println("static_aa");
}
public AA()
{
System.out.println("aa");
}
}
class BB extends AA
{
static
{
System.out.println("static_bb");
}
public BB()
{
System.out.println("bb");
}
}

结果：

static_aa

static_bb

aa

bb

aa

bb

6、

class A {
public String show(D obj){
return ("A and D");
}
public String show(A obj){
return ("A and A");
}
public String show(C obj){
return ("A and C");
}
}
class B extends A{
public String show(B obj){
return ("B and B");
}
public String show(A obj){
return ("B and A");
}
public String show(C obj){
return ("B and C");
}
}
class C extends B{}
class D extends B{}
class Test{
public static void main(String[] args){
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.show(b));     // 1
System.out.println(a1.show(c));     // 2
System.out.println(a1.show(d));    // 3
System.out.println(a2.show(b));    // 4
System.out.println(a2.show(c));     // 5
System.out.println(a2.show(d));    // 6
System.out.println(b.show(b));      // 7
System.out.println(b.show(c));      // 8
System.out.println(b.show(d));      // 9
}
}

输出结果：

1 A and A

2 A and C

3 A and D

4 B and A

5 B and C

6 A and D

7 B and B

8 B and C

9 A and D

背景知识：运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法”。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 （但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）

分析：主要知识点：方法调用的优先问题 ，优先级由高到低依次为：this.show(obj)、super.show(obj)、this.show((super)obj)、super.show((super)obj)，如果弄懂了这个优先级调用问题，那么上面的结果都很好解释了。

比如对于第一个结果，由于A类中没有 show(B obj)方法，且它没有父类，故它会调用第三个优先级，即调用方法show(A obj)，很容易得出上面的结果。

又如第四个，a2.show(b)，a2是一个引用变量，引用变量类型为B，this指的是B的实例，但是show(B obj)方法没有在父类中定义，则不满足由类B的实例决定调用函数，因此转到第三优先级this.show((super)obj)，(super)obj即(super)B即A，因此最终锁定到类B的show(A obj)，输出为"B and A”。（个人观点，欢迎轻拍）

7、

public class Test {
public static void main(String[] args) {
Parent p = new Child();
System.out.println(p.name);
System.out.println(p.get());
}

}

class Parent {
String name = "Parent";
public String get() {
return name;
}
}
class Child extends Parent {
String name = "Child";
public String get() {
return name;
}
}

Parent

Child