Java基礎筆試練習（四）

1.編譯Java Application 源程序文件將產生相應的字節碼文件，這些字節碼文件的擴展名爲( )。

A.java
B.class
C.html
D.exe

答案：
B

解析：
Java源程序的後綴名爲「.java」,通過編譯以後生成的字節碼文件後綴名爲「.class」

2. 問如下哪一個說法是正確的？（）

A 派生出子類 B, B 派生出子類 C,而且在 java 源代碼有以下聲明：

1. A a0=new A();
2. A a1=new B();
3. A a2=new C();

A.只有第一行能經過編譯
B.第一、2行能經過編譯，但第3行編譯出錯
C.第一、二、3行能經過編譯，但第二、3行運行時出錯
D.第1行，第2行和第3行的聲明都是正確的

答案：
D

解析：
這個題考了兩個點：

1. 繼承的傳遞性。
2. 多態，父類引用指向子類對象。

3.如下哪一個接口的定義是正確的？（ ）

A.interface B{ void print() { } ;}
B.interface B{ static void print() ;}
C.abstract interface B extends A1, A2 //A一、A2爲已定義的接口{ abstract void print(){ };}
D.interface B{ void print();}

答案：
D

解析：
A，接口中方法的默認修飾符時public abstract，抽象方法但是沒有方法體的，沒有大括號{}
B，JDK8中，接口中的方法能夠被default和static修飾，可是！！！被修飾的方法必須有方法體。
C，注意一下，接口是能夠多繼承的。整個沒毛病，和A選項同樣，抽象方法不能有方法體

4.如下會產生信息丟失的類型轉換是( ）

A.float a=10
B.int a=（int）8846.0
C.byte a=10； int b=-a
D.double d=100

答案：
B

解析：
會產生信息丟失不如說丟失精度，這樣可能更容易明白，而精度丟失只會發生在從大範圍到小範圍的轉換。上面四個選項，只有 B 是從 double 到 int ，也就是從大範圍到小範圍。

5.如下代碼的輸出的正確結果是

public class Test {
    public static void main(String args[]) {
        String s = "祝你考出好成績！";
        System.out.println(s.length());
    }
}

A.24
B.16
C.15
D.8

答案：
D

解析：
java的String底層是char數組，它的length()返回數組大小，而unicode中一個漢字是能夠用一個char表示的。 一個漢字等於一個字符字符是char，一個漢字也等於二個字節，字節是byte。

6.java中，StringBuilder和StringBuffer的區別，下面說法錯誤的是？

A.StringBuffer是線程安全的
B.StringBuilder是非線程安全的
C.StringBuffer對 String 類型進行改變的時候其實都等同於生成了一個新的 String 對象，而後將指針指向新的 String 對象。
D.效率比較String<StringBuffer<StringBuilder，可是在 String S1 = 「This is only a」 + 「 simple」 + 「 test」時，String效率最高。

答案：
C

解析：
效率：String(大姐，出生於JDK1.0時代) 不可變字符序列<StringBuffer(二姐，出生於JDK1.0時代) 線程安全的可變字符序列<StringBuilder(小妹，出生於JDK1.5時代) 非線程安全的可變字符序列。Java中的String是一個類，而並不是基本數據類型。string是值傳入，不是引用傳入。StringBuffer和StringBuilder能夠算是雙胞胎了，這二者的方法沒有很大區別。但在線程安全性方面，StringBuffer容許多線程進行字符操做。這是由於在源代碼中StringBuffer的不少方法都被關鍵字synchronized修飾了，而StringBuilder沒有。StringBuilder的效率比StringBuffer稍高，若是不考慮線程安全，StringBuilder應該是首選。另外，JVM運行程序主要的時間耗費是在建立對象和回收對象上。
關於D:由於進行字符串加運算時其實是在堆中開闢大量空間，爲了不資源耗盡java編譯器自動將String變量變爲StringBulider然後進行append處理。

7.下列關於修飾符混用的說法，錯誤的是( )

A.abstract不能與final並列修飾同一個類
B.abstract類中不該該有private的成員
C.abstract方法必須在abstract類或接口中
D.static方法中能直接調用類裏的非static的屬性

答案：
D

解析：
一、abstract不能與final並列修飾同一個類 對的。
二、abstract類中不該該有private的成員 對的 ：abstract類中能夠有private 可是不該該有。
三、abstract方法必須在abstract類或接口中 對的 ： 若類中方法有abstract修飾的，該類必須abstract修改。接口方法默認public abstract。
四、static方法中能處理非static的屬性 錯誤 ：在JVM中static方法在靜態區，靜態區沒法調用非靜態區屬性。

8.以下語句經過算術運算和邏輯運算以後i和 j的結果是（ ）

int i=0;
int j=0;
if((++i>0)||(++j>0)){
//打印出i和j的值。
}

A.i=0;j=0
B.i=1;j=1
C.i=0;j=1
D.i=1;j=0

答案：
D

解析：
考察的是短路邏輯的用法，即：當第一個邏輯表達式能夠肯定結果時，將再也不進行剩餘表達式的運算。

9.如下是java concurrent包下的4個類，選出差異最大的一個

A.Semaphore
B.ReentrantLock
C.Future
D.CountDownLatch

答案：
C

解析：
A、Semaphore：類，控制某個資源可被同時訪問的個數;
B、ReentrantLock：類，具備與使用synchronized方法和語句所訪問的隱式監視器鎖相同的一些基本行爲和語義，但功能更強大；
C、Future：接口，表示異步計算的結果；
D、CountDownLatch： 類，能夠用來在一個線程中等待多個線程完成任務的類。

10.下面有關java實例變量,局部變量,類變量和final變量的說法，錯誤的是？

A.實例變量指的是類中定義的變量，即成員變量，若是沒有初始化，會有默認值。
B.局部變量指的是在方法中定義的變量，若是沒有初始化，會有默認值
C.類變量指的是用static修飾的屬性
D.final變量指的是用final 修飾的變量

答案：
B

解析：
B.定義在類中的變量是類的成員變量，能夠不進行初始化，Java會自動進行初始化，若是是引用類型默認初始化爲null,若是是基本類型例如int則會默認初始化爲0
局部變量是定義在方法中的變量，必需要進行初始化。
被static關鍵字修飾的變量是靜態的，靜態變量隨着類的加載而加載，因此也被稱爲類變量
被final修飾的變量是常量

11.關於JAVA的垃圾回收機制，下面哪些結論是正確？

A.程序能夠任意指定釋放內存的時間
B.JAVA程序不能依賴於垃圾回收的時間或者順序
C.程序可明確地標識某個局部變量的引用再也不被使用
D.程序能夠顯式地當即釋放對象佔有的內存

答案：
B

解析：
java提供了一個系統級的線程，即垃圾回收器線程。用來對每個分配出去的內存空間進行跟蹤。當JVM空閒時，自動回收每塊可能被回收的內存，GC是徹底自動的，不能被強制執行。程序員最多隻能用System.gc()來建議執行垃圾回收器回收內存，可是具體的回收時間，是不可知的。當對象的引用變量被賦值爲null，可能被當成垃圾。

12.JSP分頁代碼中，哪一個步驟次序是正確的？

A.先取總記錄數，獲得總頁數，最後顯示本頁的數據。
B.先取全部的記錄，獲得總頁數，再取總記錄數，最後顯示本頁的數據。
C.先取總頁數，獲得總記錄數，再取全部的記錄，最後顯示本頁的數據。
D.先取本頁的數據，獲得總頁數，再取總記錄數，最後顯示全部的記錄。

答案：
A

解析：
一、count(*)獲得總記錄數
二、計算總頁數
三、獲取全部記錄(我的感受這一步不須要，能夠直接獲取指定頁數數據)
四、過濾顯示本頁數據

13.關於訪問權限說法正確的是 ？ ( )

A.外部類前面能夠修飾public,protected和private
B.成員內部類前面能夠修飾public,protected和private
C.局部內部類前面能夠修飾public,protected和private
D.以上說法都不正確

答案：
B

解析：
(1)對於外部類而言，它也可使用訪問控制符修飾，但外部類只能有兩種訪問控制級別：public和默認。由於外部類沒有處於任何類的內部，也就沒有其所在類的內部、所在類的子類兩個範圍，所以 private 和 protected 訪問控制符對外部類沒有意義。
(2)內部類的上一級程序單元是外部類，它具備 4 個做用域：同一個類（ private ）、同一個包（ protected ）和任何位置（ public ）。
(3)由於局部成員的做用域是所在方法，其餘程序單元永遠不可能訪問另外一個方法中的局部變量，因此全部的局部成員都不能使用訪問控制修飾符修飾。

14.如下代碼執行的結果顯示是多少（ ）？

public class Demo { 
    class Super{  
         int flag=1;
         Super(){
             test();
         }  
         void test(){
            System.out.println("Super.test() flag="+flag);
         }
    } 
    class Sub extends Super{
        Sub(int i){  
            flag=i;
            System.out.println("Sub.Sub()flag="+flag);
        }  
        void test(){
            System.out.println("Sub.test()flag="+flag);
        }
    } 
    public static void main(String[] args) {  
        new Demo().new Sub(5);
    }
}

A.Sub.test() flag=1,Sub.Sub() flag=5
B.Sub.Sub() flag=5,Sub.test() flag=5
C.Sub.test() flag=0,Sub.Sub() flag=5
D.Super.test() flag=1,Sub.Sub() flag=5

答案：
A

解析：

在繼承中代碼的執行順序爲：
1.父類靜態對象，父類靜態代碼塊
2.子類靜態對象，子類靜態代碼塊
3.父類非靜態對象，父類非靜態代碼塊
4.父類構造函數
5.子類非靜態對象，子類非靜態代碼塊
6.子類構造函數
對於本題來講：在只想new Sub(5)的時候，父類先初始化了int flag=1，而後執行父類的構造函數Super（），父類構造函數中執行的test（）方法，因子類是重寫了test（）方法的，所以父類構造函數中的test（）方法實際執行的是子類的test（）方法，因此輸出爲Sub.test() flag=1，接着執行子類構造函數Sub(5) 將flag賦值爲5，所以輸出結果Sub.Sub() flag=5。最終選擇了A。

15.Java多線程有幾種實現方法？

A.繼承Thread類
B.實現Runnable接口
C.實現Thread接口
D.以上都不正確

答案：
AB

解析：
AB.
多線程一共有三種實現方式
方式1：繼承Thread類，並重寫run()方法
方式2：實現Runnable接口，實現run()方法
方式3：實現Callable接口，線程結束後能夠有返回值，可是該方式是依賴於線程池的。

16.在Jdk1.7中，下述說法中抽象類與接口的區別與聯繫正確的有哪些？

A.抽象類中能夠有普通成員變量，接口中沒有普通成員變量。
B.抽象類和接口中均可以包含靜態成員常量。
C.一個類能夠實現多個接口，但只能繼承一個抽象類
D.抽象類中能夠包含非抽象的普通方法，接口中的方法必須是抽象的，不能有非抽象的普通方法。

答案：
A B C D

解析：
總結一下

1. 一個子類只能繼承一個抽象類,但能實現多個接口
2. 抽象類能夠有構造方法,接口沒有構造方法
3. 抽象類能夠有普通成員變量,接口沒有普通成員變量
4. 抽象類和接口均可有靜態成員變量,抽象類中靜態成員變量訪問類型任意,接口只能public static final(默認)
5. 抽象類能夠沒有抽象方法,抽象類能夠有普通方法,接口中都是抽象方法
6. 抽象類能夠有靜態方法,接口不能有靜態方法
7. 抽象類中的方法能夠是public、protected;接口方法只有public

17.根據下面這個程序的內容，判斷哪些描述是正確的：（ ）

public class Test {
    public static void main(String args[]) {
    String s = "tommy";
    Object o = s;
    sayHello(o); //語句1
    sayHello(s); //語句2
    }
    public static void sayHello(String to) {
        System.out.println(String.format("Hello, %s", to));
    }
    public static void sayHello(Object to) {
        System.out.println(String.format("Welcome, %s", to));
    }
}

A.這段程序有編譯錯誤
B.語句1輸出爲:Hello, tommy
C.語句2輸出爲:Hello, tommy
D.語句1輸出爲:Welcome, tommy
E.語句2輸出爲:Welcome, tommy
F.根據選用的Java編譯器不一樣，這段程序的輸出可能不一樣

答案：
CD

解析：
略

18.Java特性中,abstract class和interface有什麼區別（）

A.抽象類能夠有構造方法，接口中不能有構造方法
B.抽象類中能夠有普通成員變量，接口中沒有普通成員變量
C.抽象類中不能夠包含靜態方法，接口中能夠包含靜態方法
D.一個類能夠實現多個接口，但只能繼承一個抽象類。

答案：
A B D

解析：
接口中的成員變量被隱式的聲明爲public static final ，jdk1.8後接口中能夠有靜態方法並且存在方法體

19.關於下面代碼片斷敘述正確的是（）

代碼片斷：

byte b1=1,b2=2,b3,b6; 
final byte b4=4,b5=6; 
b6=b4+b5; 
b3=(b1+b2); 
System.out.println(b3+b6);

A.輸出結果：13
B.語句：b6=b4+b5編譯出錯
C.語句：b3=b1+b2編譯出錯
D.運行期拋出異常

答案：
C

解析：
C.被final修飾的變量是常量，這裏的b6=b4+b5能夠當作是b6=10；在編譯時就已經變爲b6=10了。而b1和b2是byte類型，java中進行計算時候將他們提高爲int類型，再進行計算，b1+b2計算後已是int類型，賦值給b3，b3是byte類型，類型不匹配，編譯不會經過，須要進行強制轉換。Java中的byte，short，char進行計算時都會提高爲int類型。

20.下列那些方法是線程安全的(所調用的方法都存在)

A.

public class MyServlet implements Servlet {
public void service (ServletRequest req, ServletResponse resp) {
    BigInteger I = extractFromRequest(req);
    encodeIntoResponse(resp,factors);
}
}

B.

public class MyServlet implements Servlet {
private long count =0;
public long getCount() {
return count;
}
public void service (ServletRequest req, ServletResponse resp) {
BigInteger I = extractFromRequest(req);
BigInteger[] factors = factor(i);
count ++;
encodeIntoResponse(resp,factors);
}
}

C.

public class MyClass {
private int value;
public synchronized int get() {
return value;
}
public synchronized void set (int value) {
this.value = value;
}
}

D.

public class Factorizer implements Servlet {
private volatile MyCache cache = new MyCache(null,null);

public void service(ServletRequest req, ServletResponse resp) {
BigInteger i = extractFromRequest(req);
BigInteger[] factors = cache.getFactors(i);
if (factors == null) {
factors = factor(i);
cache = new MyCache(i,factors);
}
encodeIntoResponse(resp,factors);
}

答案：
A C D

解析：
A：沒有成員（沒有共享資源），線程安全；
B：假設存在線程1和線程2，count初始值爲0，當線程1執行count++中count+1（此時未寫回最終計算值），這時線程2執行count++中讀取count，發生數據錯誤，致使線程1線程2的結果都爲1，而不是線程1的結果爲1，線程2的結果爲2，線程不安全；
C：成員私有，對成員的set get方法都加劇量級鎖，線程安全； D：volatile有兩個做用：可見性（volatile變量的改變能使其餘線程當即可見，但它不是線程安全的，參考B）和禁止重排序；這裏是可見性的應用，類中方法對volatile修飾的變量只有賦值，線程安全； 歡迎指正。

推薦

大廠筆試內容集合（內有詳細解析） 持續更新中....

ProcessOn是一個在線做圖工具的聚合平臺~

文末

歡迎關注我的微信公衆號：Coder編程
歡迎關注Coder編程公衆號，主要分享數據結構與算法、Java相關知識體系、框架知識及原理、Spring全家桶、微服務項目實戰、DevOps實踐之路、每日一篇互聯網大廠面試或筆試題以及PMP項目管理知識等。更多精彩內容正在路上~
新建了一個qq羣：315211365，歡迎你們進羣交流一塊兒學習。謝謝了！也能夠介紹給身邊有須要的朋友。

文章收錄至
Github: https://github.com/CoderMerlin/coder-programming
Gitee: https://gitee.com/573059382/coder-programming
歡迎關注並star~