JAVA——javaSE試題

一、填空題（共20個題目，總計20分）
1.Java虛擬機就是一個虛擬的用于執行 字節碼文件 .class 的計算機。它是Java最核心的技術，是Java跨平臺的基礎。
2.使用Java開發應用程序包括編寫源程序，編譯源程序，解釋并運行三個步驟，其中編譯和解釋分別需要使用javac.exe和 java.exe 實現。
3.一個十進制整數轉換成八進制數后是1234，則它轉為十六進制數后是 29c 。
4.Java中浮點數據類型包括float和double兩種類型，其中float類型又被稱作單精度類型，尾數可以精確到7位有效數字，在內存中占用
4 個字節。
1.使用Math.random( )返回帶正號的 double值，該值大于等于0.0且小于1.0。使用該函數生成[30,60]之間的隨機整數的語句是(int)(Math.random(
)*31)+30 5
6.for循環的語法格式是for (表達式1;表達式2;表達式3) {循環體}，其中在整個循環過程中只執行一次的部分是 表達式1 。
7.Java中 構造 方法與類名相同，沒有返回值，在創建對象實例時由new運算符自動調用。
8.package 語句作為Java源文件的第一條語句，指明該源文件定義的類所在的包。
9.局部變量的名字與成員變量的名字相同，若想在該方法內使用成員變量，必須使用關鍵字 this
10.Java異常處理中，如果一個方法中出現了多個Checked異常，可以在方法聲明中使用關鍵字 throws 聲明拋出，各異常類型之間使用逗號分隔。
11.聲明數組僅僅是給出了數組名字和元素的數據類型，要想真正地使用數組還必須為它 分配內存空間 。
12.Arrays類的binarySearch( ) 方法使用二分搜索法來搜索指定的數組，以獲得指定的值。必須在進行此調用之前對數組進行 排序 ，否則否則結果是不確定的。
13.Object類有一個public方法是 toString() ，一個對象通過調用該方法可以獲得該對象的字符串表示。
14.StringBuilder類是StringBuffer類的替代類，兩者的共同點是都是可變長度字符串，其中線程安全的類是 StringBuffer 。
15.Java集合框架提供了一套性能優良、使用方便的接口和類，包括Collection和Map兩大類，它們都位于 java.util 包中
16.TreeSet 是一種Collection類型的集合類，其中元素唯一，并采用二叉樹作為存儲結構，元素按照自然順序排列。
17.Java IO流可以分為 節點流 和處理流兩大類，其中前者處于IO操作的第一線，所有操作必須通過他們進行。
18.處于新建狀態的線程被啟動后，將進入線程隊列排隊等待CPU服務，此時它已經具備了運行條件，一旦輪到享用CPU資源時，就可以脫離創建它的主線程獨立開始自己的生命周期。上述線程是處于
就緒 狀態。
19.在線程通信中，調用 wait() 方法可以是當前線程處于等待狀態，而為了喚醒一個等待的線程，需要調用的方法是notify( )。
20.在Socket編程中，IP地址用來標志一臺計算機，但是一臺計算機上可能提供多種應用程序，使用 端口號 來區分這些應用程序。

二、選擇題（共25個題目，總計25分）
有一段Java 程序，其中public類名是A1，那么保存它的源文件名可以是（ A ）。（選擇一項）

A A1.java
B. A1.class
C. A1
D. 都不對

在Java中，byte數據類型的取值范圍是（ A ）。（選擇一項）

A -128 ~ 127
B. -228 ~128
C. -255 ~ 256
D. -255 ~ 255

有以下方法的定義，請選擇該方法的返回類型（ D ）。（選擇一項）
method(byte x, double y) {
return (short)x/y*2;
}

A byte
B. short
C. int
D. double

以下選項中添加到代碼中橫線處會出現錯誤的是（ B D ）。（選擇二項）
public class Test {
public float aMethod(float a, float b) {
return 0;
}

}

A public float aMethod(float a, float b, float c) {
return 0;
}
B. public float aMethod(float c, float d) {
return 0;
}
C. public int aMethod(int a, int b) {
return 0;
}
D. private int aMethod(float a, float b) {
return 0;
}

閱讀下列文件定入的Java代碼，其執行結果是（ D ）。（選擇一項）
public class Test {
public static void main(String[] args) {
char ch = ‘c’;
switch (ch) {
case ‘a’:
System.out.print(“a”); break;
case ‘b’:
System.out.print(“ab”);
case ‘c’:
System.out.print(“c”);
default:
System.out.print(“d”);
}
}
}

A a
B. b
C. c
D. cd

下面程序執行的結果是在屏幕上打?。?B ）次Java基礎班。（選擇一項）
for(int i=1;i<=10;i++){
if (i<5)
continue;
System.out.println(“Java基礎班”);
}

A 5
B. 6
C. 7
D. 8

以下四個選項中和下面代碼功能相同的是（ B ）。（選擇一項）
int i = 1;
int sum = 0;
while (i <= 100) {
if (i % 2 == 0)
sum = sum + i;
i++;
}

A for (int x =1; x<=100;x++){ sum=sum+x;}
B. for (int x =0; x<=100;x+=2){ sum=sum+x;}
C. for (int x =1; x<=100;x+=2){ sum=sum+x;}
D. 上述全對

以下代碼中錯誤的語句是（ D ）。（選擇一項）
public class Something{
public static void main(String[] args){
final Other o=new Other();
new Something().addOne(o);//1
}
public void addOne( Other o){
o.i++;//2
o = new Other();//3
}
}
class Other{
public int i;
}

A 1
B. 2
C. 3
D. 沒有錯誤

在Java中，以下程序編譯運行后的輸出結果為（ D ）。（選擇一項）
public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}

A 6
B. 34
C. 8
D. 7

下列選項中關于Java中類方法的說法錯誤的是（ AC ）。（選擇二項）

A 在類方法中可用this來調用本類的類方法
B. 在類方法中調用本類的類方法時可直接調用
C. 在類方法中只能調用本類中的類方法
D. 在類方法中調用實例方法需要先創建對象

下列選項中關于Java中super關鍵字的說法正確的是（ AD ）。（選擇一項）

A super關鍵字是在子類對象內部指代其父類對象的引用
B. super關鍵字不僅可以指代子類的直接父類，還可以指代父類的父類
C. 子類通過super關鍵字只能調用父類的方法，而不能調用父類的屬性
D. 子類通過super關鍵字可以調用父類的構造方法

編譯運行如下Java代碼，輸出結果是（ D ）。（選擇一項）
class Base {
public void method(){
System.out.print (“Base method”);
}
}
class Child extends Base{
public void methodB(){
System.out.print (“Child methodB”);
}
}
class Sample {
public static void main(String[] args) {
Base base= new Child();
base.methodB();
}
}

A Base method
B. Child methodB
C. Base method
Child methodB
D. 編譯錯誤

在Java中，關于引用數據類型的類型轉換說法正確的是（ AB ）。（選擇二項）

A 引用數據類型的類型轉換有向上轉型和向下轉型
B. 向下轉型，必須轉換成其真實子類型，而不能隨意轉換
C. 向下轉型是自動進行的，也稱隱式轉換
D. 向上轉型可以使用instanceof操作符來判斷轉型的合法性

在Java接口中，下列選項中屬于有效的方法聲明是（ AC ）。（選擇二項）

A public void aMethod( );
B. final void aMethod( );
C. void aMethod(){ }
D. private void aMethod( );

以下選項中關于匿名內部類的說法正確的是（ BD ）。（選擇二項）

A. 匿名內部類可以實現多個接口，或者繼承一個父類
B. 匿名內部類不能是抽象類，必須實現它的抽象父類或者接口里包含的所有抽象方法
C. 匿名內部類沒有類名，所以匿名內部類不等定義構造方法
D. 匿名內部類可以直接訪問外部類的所有局部變量

閱讀如下Java代碼，在控制臺輸入"-1",執行結果是（B）。（選擇一項）
public class Demo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“請輸入數字：”);
try {
int num = input.nextInt();
if (num < 1 || num > 4) {
throw new Exception(“必須在1-4之間！”);
}
} catch (InputMismatchException e) {
System.out.println(“InputMismatchException”);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}

A 輸出：InputMismatchException
B. 輸出：必須在1-4之間！
C. 什么也沒輸出
D. 編譯錯誤

關于Integer類中的靜態方法parseInt()方法說法正確的是（ BC ）。（選擇二項）

A 將小數轉換成整數
B. 將數字格式的字符串轉成整數
C. 使用parseInt()方法可能拋出異常
D. 將單個字符轉成整數

以下程序片段中可以正常編譯的是（ C ）。（選擇一項）

A String s = “Gone with the wind”;
String k = s+t;
String t = “good”;
B. String s = “Gone with the wind”;
String t;
t = s[3]+“one”;
C. String s = “Gone with the wind”;
String stanfard = s.toUpperCase();
D. String s = “home directory”;
String t = s – “directory”;

以下代碼的執行結果是（ C ）。（選擇一項）
Set s=new HashSet();
s.add(“abc”);
s.add(“abc”);
s.add(“abcd”);
s.add(“ABC”);
System.out.println(s.size());

A. 1
B. 2
C. 3
D. 4

File類中的isDirectory( )方法的作用是（ BD ）。（選擇二項）

A. 判斷File對象封裝的是否是文件
B. 判斷File對象封裝的是否是目錄
C. 判斷File對象中封裝的是否是根目錄
D. 返回值類型是boolean

閱讀下列文件定入的JAVA代碼，共有（ C ）處錯誤。（選擇一項）
import java.io.*;
public class TestIO {
public static void main(String []args){
String str =“文件寫入練習”;
FileWriter fw = null; //1
try{
fw = new FileWriter(“c:\mytext.txt”); //2
fw.writerToEnd(str); //3
}catch(IOException e){ //4
e.printStackTrace();
}finally{
//此處省略關閉流
}
}
}

A 0
B. 1
C. 2
D. 3

以下選項中關于Java中線程控制方法的說法正確的是（ AD ）。（選擇二項）

A. join ( ) 的作用是阻塞指定線程等到另一個線程完成以后再繼續執行
B. sleep ( ) 的作用是讓當前正在執行線程暫停，線程將轉入就緒狀態
C. yield ( ) 的作用是使線程停止運行一段時間，將處于阻塞狀態
D. setDaemon( )的作用是將指定的線程設置成后臺線程

Java中線程安全問題是通過關鍵字（ c ）解決的?。（選擇一項）

A. finally
B. wait( )
C. synchronized
D. notify( )

ServerSocket的監聽方法accept( )方法的返回值類型是（ A ）。（選擇一項）

A. Socket
B. void
C. Object
D. DatagramSocket

以下選項中關于Java中獲取Class對象的方式正確的是（ CD ）。（選擇二項）

A. Class c1 = String.getClass( );
B. String str = new String(“bjsxt”);
Class clazz = str.class;
C. Class c1 = Integer.TYPE;
D. Class clazz = Class.forName(“java.lang.Object”);

三、判斷題（共20個題目，總計10分，正確√，錯誤×）
1.和C++相比，Java取消了指針，不再有多重繼承，不需要手動回收垃圾。（ 對 ）
2.Java具有一次編譯，到處運行的特點，其含義是Java的源代碼可以一次性編譯成計算機的機器碼，并在不同的平臺上運行。（ 錯 ）
3.char 數據類型用來表示在ASCII編碼表中的一個字符，在內存中占用1個字節空間，所以不能表示一個漢字。（ 錯 ）
4.賦值和條件運算符是運算級別最低的兩種運算符，兩者都具有自右向左的結合性。（ 對 ）
5.多重循環是指一個循環體內又包含另一個完整的循環結構。外層循環變量變化一次，內層循環變量要從頭到尾變化一遍。（ 對 ）
6.任何可用遞歸解決的問題也能使用循環解決，遞歸既花時間又耗內存，在要求高性能的情況下盡量避免使用遞歸。（對 ）
7.訪問權限是private的變量，只能在本類和與本類同一個包中的其他類使用。（ 錯 ）
8.對于子類創建的一個對象，如果子類繼承了父類的方法，未重寫，則運行時調用子類的方法。（ 錯 ）
9.ArithmeticException，ArrayIndexOutOfBoundsException，NullPointerException是運行時異常，而ClassNotFoundException，ClassCastException是Checked異常。（錯 ）
10.數組的長度是確定的，數組一旦被創建，它的大小就是不可以改變的。但是其元素類型可以是不同類型，允許出現混合類型。（ 錯 ）
11.創建數組后，系統會給每個數組元素一個默認值，如double型元素的默認值是0.0。（ 對 ）
12.JK1.5后提供了自動裝箱和自動拆箱功能，從而可以實現基本數據類型和對應包裝類之間的自動轉換，簡化了操作。（ 對 ）
13.java.sql.Date類和java.util.Date類的關系是前者是后者的父類，其中前者沒有提供無參數構造方法，而后者可以提供無參數構造方法來獲取當前時間。（ 錯 ）
14.Collection是Java集合頂級接口，其中的元素無序，唯一。Java平臺不提供這個接口任何直接的實現。（ 對 ）
15.Iterator接口可以遍歷任何Collection接口的實現類，可以從一個Collection中使用iterator( )方法來獲取迭代器實例。迭代器取代了Java集合框架中的Enumeration。（ 對 ）
16.序列化是指將字節序列轉換成Java對象，只有實現了Serializable接口的類的對象才可以被序列化。（ 錯 ）
17.一個進程可以包括多個線程。兩者的一個主要區別是：線程是資源分配的單位，而進程CPU調度和執行的單位。（ 錯 ）
18.用new關鍵字建立一個線程對象后，該線程對象就處于新生狀態。處于新生狀態的線程有自己的內存空間，通過調用start進入就緒狀態。（ 對 ）
19.TCP協議是一種面向無連接的、可靠的、基于字節流的傳輸層通信協議，該協議占用系統資源多、效率較低。（ 錯 ）
20.Java反射技術中，對于一個private修飾的成員變量，可以再設置setAccessible(true)后進行暴力訪問。（ 對 ）

四、簡答題（共5個題目，總計25分）
1.面向過程和面向對象的區別。（5分）

1.編程思路不同： 面向過程以實現功能的函數開發為主，而面向對象要首先抽象出類、屬性及其方法，然后通過實例化類、執行方法來完成功能。（1分）
2.封裝性：都具有封裝性，但是面向過程是封裝的是功能，而面向對象封裝的是數據和功能。（1分）
3.面向對象具有繼承性和多態性，而面向過程沒有繼承性和多態性，所以面向對象優勢是明顯。（1分）
4.面向對象耦合性低，更利于修改維護。（蓋澆飯/蛋炒飯）。（1分）
5.面向過程更適合解決簡單問題。面向對象更適合解決復雜問題。（1分）

2.Error和Exception的區別。（5分）

1.Error類，表示僅靠程序本身無法恢復的嚴重錯誤，比如說內存溢出、動態鏈接異常、虛擬機錯誤。（1分）應用程序不應該拋出這種類型的對象。假如出現這種錯誤，除了盡力使程序安全退出外，在其他方面是無能為力的。（1分）
2.Exception類，由Java應用程序拋出和處理的非嚴重錯誤，比如所需文件沒有找到、零作除數，數組下標越界等。（1分）它的各種不同子類分別對應不同類型異常?？煞譃閮深悾篊hecked異常和Runtime異常。（1分）所以在進行程序設計時，應該更關注Exception類。（1分）

3.列舉常用的字節輸入流和輸出流并說明其特點，至少5對。（5分）

1.FileInputStream和FileOutputStream 節點流 以文件為數據源和目的地（1分）
2.BufferedInputStream和BufferedOutputStream 處理流 提供了緩沖功能，提高讀寫效率（1分）
3.DataInputStream和DataOutputStream 處理流 提供了方便讀寫基本數據類型和String數據的方法（1分）
4.ObjectInputStream和ObjectOutputStream 處理流 不僅提供了方便讀寫基本數據類型和String數據的方法，也提供了讀寫引用類型數據的方法（1分）
5.ByteArrayInputStream和ByteArrayOutputStream 節點流 以字節數組為數據源和目的地（1分）

4.創建線程的兩種方式分別是什么？各有什么優缺點。（5分）

1.方式1：繼承java.lang.Thread類，并覆蓋run() 方法。（1分）
優勢：編寫簡單；（0.5分）
劣勢：無法繼承其它父類（0.5分）
2.方式2：實現java.lang.Runnable接口，并實現run()方法。（1分）
優勢：可繼承其它類，多線程可共享同一個Thread對象；（1分）
劣勢：編程方式稍微復雜，如需訪問當前線程，需調用Thread.currentThread()方法（1分）

5.簡述基于UDP的Socket編程的主要步驟。
提示：分別說明服務器端和客戶端的編程步驟。（5分）

服務器端（server）：
1)構造DatagramSocket實例。（0.5分）
2)創建數據包DatagramPacket，存取發送和接收的數據、IP和端口。（0.5分）
3)通過DatagramSocket實例的receive方法接收客戶端數據。（0.5分）
4)通過DatagramSocket的send方法向客戶端發出反饋信息。（0.5分）
5)關閉DatagramSocket。（0.5分）
客戶端（client）：
1)構造DatagramSocket實例。（0.5分）
2)創建數據包DatagramPacket，存取發送和接收的數據、IP和端口。（0.5分）
3)通過DatagramSocket實例的receive方法接收客戶端數據。（0.5分）
4)通過DatagramSocket的send方法向客戶端發出反饋信息. （0.5分）
5)關閉DatagramSocket。（0.5分）

五、編碼題（共3個題目，總計20分）
1.給20塊錢買可樂，每瓶可樂3塊錢，喝完之后退瓶子可以換回1塊錢，問最多可以喝到多少瓶可樂。（5分）
public class Test {
public static void main(String[] args) {
int money = 20, price = 3; //0.5分
// temp表示每一次購買的可樂瓶數
int temp = 0;
// change表示每次購買完可樂剩下的錢
int change = 0;
// sum表示總的可樂瓶數
int sum = 0; //0.5分
// 如果錢數大于可樂價格
while (money >= price) {//0.5分
// 購買可樂
temp = money / price; //0.5分
// 總可樂瓶數增加
sum += temp; //0.5分
// 計算買可樂剩下的錢
change = money % price; //0.5分
// 兌換可樂瓶子，計算剩余的總錢數
money = temp + change; //0.5分
}
// 輸出結果
System.out.println(sum); //0.5分
}
}


2.寫一個方法對任意數據類型數組進行排序。（6分）具體要求如下:
1)方法聲明為public void sortArr(Object arr[]){ }
2)方法中首先輸出排序前數組內容，然后進行排序，最后輸出排序后數組內容。
3)可以是冒泡排序或其他算法實現，不直接調用Java提供的方法實現排序。
關鍵點：如何實現不同數據類型數組元素的大小比較

public void sort(Object [] arr){
//輸出排序前數組 1分
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
//大循環，一共n個元素，達到最終有序，至多n-1趟比較
Object temp;
for(int i=0;i<arr.length-1 ;i++){
//定義一個符號量
boolean flag = true;//沒有交換，有序
//小循環
for(int j=0;j<arr.length-1-i;j++){
//如果前一個大于后一個
Comparables c1 = (Comparables)arr[j];
Comparables c2 = (Comparables)arr[j+1];
if(c1.compareTo(c2)>0){
//交換
temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
//修改符號量
flag = false;//交換過，無序
}
}
//判斷經過此趟循環后是否已經有序
if(flag){
break;//退出外層循環，省略后續趟循環
}
}
//輸出排序后數組
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}

3.實現List和Map數據的轉換。（9分）具體要求如下：
功能1：定義方法public void listToMap( ){ }將List中Student元素封裝到Map中
1)使用構造方法Student(int id,String name,int age,String sex )創建多個學生信息并加入List
2)遍歷List，輸出每個Student信息
3)將List中數據放入Map，使用Student的id屬性作為key，使用Student對象信息作為value
4)遍歷Map，輸出每個Entry的key和value
功能2：定義方法public void mapToList( ){ }將Map中Student映射信息封裝到List
1)創建實體類StudentEntry，可以存儲Map中每個Entry的信息
2)使用構造方法Student(int id,String name,int age,String sex )創建多個學生信息，并使用Student的id屬性作為key，存入Map
3)創建List對象，每個元素類型是StudentEntry
4)將Map中每個Entry信息放入List對象

在這里插入代碼片public class TestListToMap {
public void listToMap () {
//1.創建多個學生信息
Student stu1 = new Student(110, "小明", 23, 98.0);
Student stu2 = new Student(111, "大剛", 21, 80.5);
Student stu3 = new Student(112, "小白", 12, 93.0);
//2.加入List
List<Student> list = new ArrayList<Student>();
list.add(stu1);
list.add(stu2);
list.add(stu3);
//3.遍歷List，輸出每個Student信息
for(Student stu:list){
System.out.println(stu);
}
//4.將List中數據放入Map，使用Student的id屬性作為key
Map<Integer, Student> map = new HashMap<Integer, Student>();
Iterator<Student> it = list.iterator();
while(it.hasNext()){
Student stu = it.next();
map.put(stu.getId(), stu);
}
//5.遍歷Map，輸出每個Entry的key和value
Set<Entry<Integer,Student>> entrySet = map.entrySet();
for(Entry<Integer,Student> entry:entrySet){
System.out.println(entry.getKey()+"---->"+entry.getValue());
}
}
}

public class TestMapToList {
public void mapToList () {
//1.創建多個學生信息
Student stu1 = new Student(110, "小明", 23, 98.0);
Student stu2 = new Student(111, "大剛", 21, 80.5);
Student stu3 = new Student(112, "小白", 12, 93.0);
//2.使用Student的id屬性作為key，存入Map
Map<Integer, Student> map = new HashMap<Integer, Student>();
map.put(stu1.getId(), stu1);
map.put(stu2.getId(), stu2);
map.put(stu2.getId(), stu3);
//3.創建List對象，每個元素類型是StudentEntry
List<StudentEntry> list = new ArrayList<StudentEntry>();
//4.將Map對象轉化為List集合
for (Entry<Integer, Student> entry : map.entrySet()) {
StudentEntry studentEntry = new StudentEntry();
// 將map中的一個映射關系，封裝為一個studentEntry對象
studentEntry.setKey(entry.getKey());
studentEntry.setStu(entry.getValue());
// 將studentEntry對象List集合
list.add(studentEntry);
}
//5.遍歷Map
for (StudentEntry se : list) {
System.out.println(se.getKey() + "\t" + se.getStu());
}
}
}