java麵試題—精選30道Java筆試題解答（二）

19. 下麵程序能正常運行嗎（）

public class NULL {

    public static void haha(){
        System.out.println("haha");
    }
    public static void main(String[] args) {
        ((NULL)null).haha();
    }

}

答案：能正常運行

解析：輸出為haha，因為null值可以強製轉換為任何java類類型,(String)null也是合法的。但null強製轉換後是無效對象，其返回值還是為null，而static方法的調用是和類名綁定的，不借助對象進行訪問所以能正確輸出。反過來，沒有static修飾就隻能用對象進行訪問，使用null調用對象肯定會報空指針錯了。這裏和C++很類似。這裏感謝@Florian網友解答。

20. 下麵程序的運行結果是什麼（）

class HelloA {

    public HelloA() {
        System.out.println("HelloA");
    }
    
    { System.out.println("I'm A class"); }
    
    static { System.out.println("static A"); }

}

public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }
    
    { System.out.println("I'm B class"); }
    
    static { System.out.println("static B"); }
    
    public static void main(String[] args) { 
　　　　 new HelloB(); 
　　 }

}

答案：

static A
static B
I'm A class
HelloA
I'm B class
HelloB

解析：說實話我覺得這題很好，考查靜態語句塊、構造語句塊（就是隻有大括號的那塊）以及構造函數的執行順序。

對象的初始化順序：（1）類加載之後，按從上到下（從父類到子類）執行被static修飾的語句；（2）當static語句執行完之後,再執行main方法；（3）如果有語句new了自身的對象，將從上到下執行構造代碼塊、構造器（兩者可以說綁定在一起）。

下麵稍微修改下上麵的代碼，以便更清晰的說明情況：

 View Code

此時輸出結果為：

static A
static B
-------main start-------
I'm A class
HelloA
I'm B class
HelloB
I'm A class
HelloA
I'm B class
HelloB
-------main end-------

  如果你想學習java可以來這個群，首先是二二零，中間是一四二，最後是九零六，裏麵有大量的學習資料可以下載。

21. getCustomerInfo()方法如下，try中可以捕獲三種類型的異常，如果在該方法運行中產生了一個IOException，將會輸出什麼結果（）

    public void getCustomerInfo() {

        try {

            // do something that may cause an Exception

        } catch (java.io.FileNotFoundException ex) {

            System.out.print("FileNotFoundException!");

        } catch (java.io.IOException ex) {

            System.out.print("IOException!");

        } catch (java.lang.Exception ex) {

            System.out.print("Exception!");

        }

    }

A IOException!

BIOException!Exception!

CFileNotFoundException!IOException!

DFileNotFoundException!IOException!Exception!

答案：A

解析：考察多個catch語句塊的執行順序。當用多個catch語句時，catch語句塊在次序上有先後之分。從最前麵的catch語句塊依次先後進行異常類型匹配，這樣如果父異常在子異常類之前，那麼首先匹配的將是父異常類，子異常類將不會獲得匹配的機會，也即子異常類型所在的catch語句塊將是不可到達的語句。所以，一般將父類異常類即Exception老大放在catch語句塊的最後一個。

22. 下麵代碼的運行結果為：（）

import java.io.*;
import java.util.*;

public class foo{

    public static void main (String[] args){

        String s;

        System.out.println("s=" + s);

    }

}

A 代碼得到編譯，並輸出“s=”

B 代碼得到編譯，並輸出“s=null”

C 由於String s沒有初始化，代碼不能編譯通過

答案：C

解析：開始以為會輸出null什麼的，運行後才發現Java中所有定義的基本類型或對象都必須初始化才能輸出值。

23.  System.out.println("5" + 2);的輸出結果應該是（）。

A 52                   B7                     C2                     D5

答案：A

解析：沒啥好說的，Java會自動將2轉換為字符串。

24. 指出下列程序運行的結果 （）

public class Example {

    String str = new String("good");

    char[] ch = { 'a', 'b', 'c' };

    public static void main(String args[]) {

        Example ex = new Example();

        ex.change(ex.str, ex.ch);

        System.out.print(ex.str + " and ");

        System.out.print(ex.ch);

    }

    public void change(String str, char ch[]) {

        str = "test ok";

        ch[0] = 'g';

    }
}

A、 good and abc

B、 good and gbc

C、 test ok and abc

對象交換前：p1 = Alexia female
對象交換前：p2 = Edward male

對象交換後：p1 = Alexia female
對象交換後：p2 = Edward male

對象數組交換前：arraya[0] = Alexia female, arraya[1] = Edward male
對象數組交換前：arrayb[0] = jmwang female, arrayb[1] = hwu male

對象數組交換後：arraya[0] = Alexia female, arraya[1] = Edward male
對象數組交換後：arrayb[0] = jmwang female, arrayb[1] = hwu male

基本類型數組交換前：a[0] = 0, a[1] = 1
基本類型數組交換前：b[0] = 1, b[1] = 2

基本類型數組交換後：a[0] = 0, a[1] = 1
基本類型數組交換後：b[0] = 1, b[1] = 2

對象數組內容交換並改變後：arraya[1] = wjl male
對象數組內容交換並改變後：arrayb[1] = Edward male

基本類型數組內容交換並改變後：a[1] = 5
基本類型數組內容交換並改變後：b[1] = 1

RandomAccessFile in = new RandomAccessFile("file.dat", "r");
in.skipBytes(9);
int c = in.readByte();

    public static int getValue(int i) {
        int result = 0;
        switch (i) {
        case 1:
            result = result + i;
        case 2:
            result = result + i * 2;
        case 3:
            result = result + i * 3;
        }
        return result;
    }

public abstract class MyClass {
public int constInt = 5;
     //add code here
     public void method() {
     }
}

（1）接口是公開的，裏麵不能有私有的方法或變量，是用於讓別人使用的，而抽象類是可以有私有方法或私有變量的。

（2）abstract class 在 Java 語言中表示的是一種繼承關係，一個類隻能使用一次繼承關係。但是，一個類卻可以實現多個interface，實現多重繼承。接口還有標識（裏麵沒有任何方法，如Remote接口）和數據共享（裏麵的變量全是常量）的作用。

（3）在abstract class 中可以有自己的數據成員，也可以有非abstarct的成員方法，而在interface中，隻能夠有靜態的不能被修改的數據成員（也就是必須是 static final的，不過在 interface中一般不定義數據成員），所有的成員方法默認都是 public abstract 類型的。

（4）abstract class和interface所反映出的設計理念不同。其實abstract class表示的是"is-a"關係，interface表示的是"has-a"關係。

（5）實現接口的一定要實現接口裏定義的所有方法，而實現抽象類可以有選擇地重寫需要用到的方法，一般的應用裏，最頂級的是接口，然後是抽象類實現接口，最後才到具體類實現。抽象類中可以有非抽象方法。接口中則不能有實現方法。

（6）接口中定義的變量默認是public static final 型，且必須給其初值，所以實現類中不能重新定義，也不能改變其值。抽象類中的變量默認是 friendly 型，其值可以在子類中重新定義，也可以在子類中重新賦值。

class Shape {

       public String name;

}

class Circle extends Shape implements Serializable{

       private float radius;

       transient int color;

       public static String type = "Circle";

}

class People {
    String name;

    public People() {
        System.out.print(1);
    }

    public People(String name) {
        System.out.print(2);
        this.name = name;
    }
}

class Child extends People {
    People father;

    public Child(String name) {
        System.out.print(3);
        this.name = name;
        father = new People(name + ":F");
    }

    public Child() {
        System.out.print(4);
    }
    
}

public class Dervied extends Base {

    private String name = "dervied";

    public Dervied() {
        tellName();
        printName();
    }
    
    public void tellName() {
        System.out.println("Dervied tell name: " + name);
    }
    
    public void printName() {
        System.out.println("Dervied print name: " + name);
    }

    public static void main(String[] args){
        
        new Dervied();    
    }
}

class Base {
    
    private String name = "base";

    public Base() {
        tellName();
        printName();
    }
    
    public void tellName() {
        System.out.println("Base tell name: " + name);
    }
    
    public void printName() {
        System.out.println("Base print name: " + name);
    }
}