Java --- 期末复习卷

一、单选题

1．所有Java应用程序主类必须有一个名叫(    )的方法。[      ]

A．method      B．main()         C．java()         D．hello  

2．编写并保存了一个Java程序文件之后，(    )它。[      ]

A．解释后并编译                  B．解释后并执行

C．编译后并重新保存              D．编译后并解释   

3．"++ "运算符的操作数个数是(    )。[       ]

A．1个         B．2个            C．3个           D．4个

4．保存包含java语言源代码的文本文件使用的扩展名是(    )。[      ]

   A．.java           B．.class           C．.txt               D．.src  

一个类的文件头必须包括(    )。[      ]

A．一个访问权限   B．关键字class   C．关键字static     D．关键字public

5．下列哪一个不是方法访问权限(    )。[      ]

A．general       B．private         C．friendly       D．protected

6．下列对声明为double aMethod(char code)的方法的调用哪一个是正确的？[      ]

A．double aMethod();               B．double aMethod('v'); 

C．double aMethod(int 'm');     （调用时不要带类型名）     D．double Amethod('u');

7．下列哪个选项是合法的标识符？[       ]

A．123         B．1first （数字不打头）         C．class（不和关键字重名）            D．_name

8．一个类的文件头必须包括(    )。[      ]

A．一个访问权限   B．关键字class   C．关键字static     D．关键字public

9．下面代码的输出结果是(    )。[      ]

b=1;
while(b<4){  system .out .println (b+" ");
b=b+1;
 

A．1                               B．1  2  3

C．1  2  3  4                      D．1  1  1  1  1

10．下面程序段的输出结果是(    )。[      ]

for(m=0;m<4;++m)
  for(n=0;n<2;++n);
        system.out.print(m +" "+n +" ");

A．0 0 0 1 1 0 1 1 2 0 2 1 3 0 3 1       B．0 1 0 2 1 1 1 2 2 1 2 2

C．4 2                            D．3 1

11．语句statement  int [ ] value=new int [ 34 ]；为(    )个整数保留了存储空间。[      ]

A．0         B．33               C．34         D．35

12．(    )是类创建的实例。[      ]

A．成员      B．数据             C．其他类     D．对象

13．当编写一个Java Applet时，要以(    )为扩展名将其保存。[      ]

Ａ．.app　    Ｂ．.html            Ｃ．.java　     Ｄ．.class

编译Java  Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为(      )。
  A）.  java                      B)  .class
C） . html                      D）  .exe  

14．Java应用程序和Java Applet有相似之处是因为它们都(    )。[      ]

Ａ．是用javac命令编译的　        Ｂ．是用javac命令执行的　

Ｃ．是用html文档中执行的　　     Ｄ．都拥有一个main方法

15．在Java里，创建继承的关键字是(    )。[      ]

A．static       B．enlarge          C．extends       D．inherits

16．使用相同的方法名来表示不同的实现被称作(    )。[      ]

A．继承       B．多态性          C．不顺从        D．隐藏

17．Java语言的特点：(     )。[      ]

A．面向对象、支持网络和解释型     B.  健壮、安全、平台无关   

C.  多线程和动态                   D.  以上选项都是

18．Java语言使用的字符码集是(    )。[      ]

A． ASCII     B． BCD           C．DCB          D．Unicode  

19．对于一维数组a[10]，下列对数组的引用正确的是(   )。[      ]

A．a[10] （超了）         B.  a[0]         C.  a[3/1.0]（a[n]，n是整数）       D.  a[3.4]

20．在程序读入字符文件时，能够以该文件为直接参数的类是(    )。[      ]

A．FileReader            B．BufferedReader         

C．FileInputStream        D．ObjectInputStream

21．Java.io包的File类是(    )。[      ]

    A．字符流类     B．字节流类        C．对象流类       D．非流类

22．容器被重新设置大小后，哪种布局管理器的容器中的组件大小不随容器大小的变化而改变？ [      ]

A．CardLayout   B．FlowLayout       C．BorderLayout   D．GridLayout  

23．在Java中，实现用户界面功能的包是(    )。 [       ]

A．java.applet    B．java.transaction     C．java.util         D．java.awt

A：java.applet是为Applet提供执行需要的所有类，主要访问Applet内容的通信类

B：transaction包是属于javax而不是 java，javax.transaction包是提供事务处理所需要的包；

C:ava.util包提供使用程序类和集合类，如系统特性定义和使用、日期函数类、集合Collection、Map、List、Array等常用工具类；

24．Java程序中所有类的直接或间接父类是：(      )。[      ]

    A．System类   B.  Object类   C.  Math类   D.  Thread类

25．标签和按钮都是(    )。[       ]

A． 组件       B． 容器            C． Applet         D． 成分

26．监听事件和处理事件(    )。 [       ]

A．都由Listener完成           B．都由相应事件Listener处登记过的构件完成

C．由Listener和构件分别完成   D．由Listener和窗口分别完成

27．下列Java常见事件类中哪个是鼠标事件类？  [       ]

A．InputEvent     B．KeyEvent       C．MouseEvent    D．WindowEvent

28．在Java语言中，不允许使用指针体现出的Java特性是(    )。[      ]

A．可移植       B．解释执行        C．健壮性        D．安全性

29．Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点？ [       ]

A．安全性　    B．多线性　　      C．跨平台　　    D．可移植

30．下列代码段输出的结果是什么？[      ]

     s=20
     if(s>30)
        System.out.println("AAA");
     System.out.println("BBB");//（if只管后跟第一句）

A．AAA          B．BBB        C．AAA BBB        D．什么也不显示

31．  假设数组声明如下:int [ ] num=new int[ 4 ] ;下面的哪一条语句正确地把数组的四个元素都赋值为100? [      ]

A．for(x=0;x<3;++x)num[x]=100;       B．for(x=0;x<4;++x)num[x]=100;

C．for(x=1;x<4;++x)num[x]=100;       D．for(x=1;x<4;++x)num[x]=100;

32．下列的哪个赋值语句是正确的？[       ]

A．char a=12;                  B．int a=12.0;

C．int a=12.0f;                  D．int a=（int）12.0;

，- char a=12。编译器显示正确，但char 类型只能存储一个字符或者一个Unicode码值，不能直接赋值为整数。

33．下列代表十六进制整数的是(  )
        A）0123        B）1900        C）fa00        D）0xa2  

整数表示：0x开头：十六进制   0开头：八进制    只有0,1构成大概率：二进制

34．一个对象的属性也被称为它的(    )。[       ]

A．状态        B．定位         C．方法          D．过程

35．接口的方法语法格式默认为以下哪种访问级(     )。[       ]

A．private     B.  package     C.  public          D.   protected

36．必须把Java语言编写的程序编译成(    )。[       ]

A．字节代码    B．源代码       C．Javadoc语句   D．对象代码

37．所有Java语言语句必须以(    )结尾。[       ]

A．句号        B．逗号         C．分号          D．"} "

38．在Java平台的术语中,执行某个任务的一系列语句是(    )。[       ]

A．过程        B．方法        C．子过程         D．函数

39．一个静态公共方法名为sum()在类A中，从类B中调用该方法，应用语句(    )。 

A．sum (B);         B．B (sum ());         C．A.sum ();        D．不能从B中调用sum();

40．如果方法接收一个整型参数，则下列哪个方法声明对名为displayFacts() 的方法是正确的？ [       ]

A．public void int displayFact()                 B．public void displayFacts (int)

C．public void displayFacts(int data)  D．public void displayFacte()

41．每个对象都是一个通用(    )的一个成员或实例。[       ]

A．类         B．程序          C．方法         D．过程

42．定义一个类可以使用下列哪种访问权限？ [       ]

A．open       B．static          C．abstract       D．concrete

"static" 是用于定义静态成员的关键字，而不是用于定义类的访问权限。

43．假设变量q的值是3，下列那一个语句打印XXX？[       ]

A．if(q!=3) System.out.println("XXX");     B．if(q=3) System.out.println("XXX");

C．if(q==3) System.out.println("XXX"); D．都不打印XXX

B 选项按C语言来说是对的，ButJava中它是错的。 

44．在if语句中嵌入if语句时，例如if（a>b）if(c>d)x=0;那么(    )。[       ]

A．a>b和c>d都必须为true时，x的值才设为0

B．要么a>b要么c>d都必须为true，x的值才设为0

C．a>b和c>d都必须为false时，x的值才设为0

D．没有条件使x的值为0

45．下面程序段的输出结果是(    )。[       ]

for(f=0;f<3;++f)

 for(g=0;g<2;++g)

 System.out.print(f +" "+g +" ");

A．0 0 0 1 1 0 1 1 2 0 2 1           B．0 1 0 2 0 3 1 1 1 2 1 3

C．0 1 0 2 1 1 1 2                 D．0 0 0 1 0 2 1 0 1 1 1 2 2 0 2 1 2 2

46．为一个数组分配存储空间是 (    )。[       ]

A．声明数组名字                 B．使用关键字new  

C． 使用关键字men              D．在数组元素里明确的存储值

47．假如char []responses={Y,y,N,n};,如果字符变量userentry的值在responses列表里，那么下面哪条语句测试userentry并设置布尔变量goodchoice为true?  [       ]

A．for(x=0;x<4;++x)

         if(userentry=responses)         goodchoice= =true;

B．for(x=0;x<4;++x)

         if(userentry[x]=goodresponses)      goodchoice=true

C．for(x=0;x<4;++x)

         if(userentry=goodresponses[x])      goodchoice= =true;

D．for(x=0;x<4;++x)

if(userentry= =goodresponses[x])      goodchoice=true;

48．标签和按钮都是(    )。[       ]

A． 组件         B． 容器        C． Applet        D． 成分

49．如果父类与子类有相同的方法名但有不同的参数列表时，可以(    )。[       ]

A．重载方法                               B．覆盖一个方法

C．创建一个错误提示信息          D．违反了面向对象程序设计的规则

50．关键字(    )总是指使用的类的父类。

    A． parent       B． base         C． super          D． superclass

51．当编写一个Java Applet时，要以(    )为扩展名将其保存。[      ]

Ａ．.app　       Ｂ．.html         Ｃ．.java　        Ｄ．.class

52．(    )下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？ [       ]

A．private        B．无修饰符      C．public        D．protected

在Java中，成员变量的访问权限可以通过访问修饰符来控制。以下是常见的访问修饰符：

53．下列InputStream类中哪个方法可以用于关闭流？[       ]

A．skip（）      B．close（）      C．mark（）     D．reset（）

54．下面哪个String方法进行了两个String对象的比较，比较的时候区分大小写并且将其结果用布尔类型的真值或者假值表示出来(     ) [       ]

A．compareTo()                            B．equalsIgnoreCase()    

C．campareToIgnoreCase()         D．equals()

55． 下述叙述错误的是（C）

A.内部类的外嵌类的成员变量在内部类仍然有效

 B. 内部类的方法也可以调用外嵌类中的方法

C. 在内部类的类体中也可声明类变量（static）

D. 在外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员

56． 下述叙述错误的是（）

A.匿名类没有构造方法                  B.编译器会给匿名类一个名字

C.匿名类一定是final类                D.匿名类一定是内部类

   匿名类可以是一个普通的类或接口的子类，因此可以被其他类继承或扩展。尽管在大多数情况下，匿名类被用作临时实现一个接口或扩展一个类，故匿名类不一定是final类。

57． 下述叙述错误的是（B）

A.非匿名内部类也可以有（内部类）子类

B.内部类不可以是final类

C.不可能用匿名类声明对象,但可以直接用一个匿名类创建一个对象

D.匿名子类（和子类有关的匿名类）可以继承父类的方法，也可以重写父类的方法。

58．下列关于Frame类的说法不正确的是(    )。 [       ]

A．Frame是Window类的直接子类  B．Frame对象显示的效果是一个窗口 

C．Frame被默认初始化为可见      D．Frame的默认布局管理器为BorderLayout 

59． 如果希望所有的控件在界面上均匀排列，应使用下列那种布局管理器？[       ]

A．BoxLayout          B．GridLayout     C．BorderLayout         D．FlowLouLayout

60．下列关于变量的描述中，不正确的一项是(    ) [       ]

A．实例变量的作用域是整个类      B．局部变量必须加初始化

C．类变量能在方法中声明          D．类变量的作用域是整个类

61．保存包含java语言源代码的文本文件使用的扩展名是(    )。[      ]

A．.java       B．.class         C．.txt          D．.src            

               

62． 下列哪个叙述是正确的?

A. final 类可以有子类。

B. abstract类中只可以有abstract方法。

C. abstract类中可以有非abstract方法,但该方法不可以用final修饰。

D. 不可以同时用final和abstract修饰同一个方法。

E. 允许使用static修饰abstract方法

A. final类不可以有子类，final修饰的类是最终类，不允许继承。

B. abstract类中可以有abstract方法，也可以有非abstract方法。、

C. abstract类可以有非abstract方法，但是该方法不能使用final修饰，因为final表示最终方法，不可被子类重写。

D. 在Java中，不可以同时使用final和abstract修饰同一个方法，因为final修饰的方法不可被重写，而abstract修饰的方法必须被子类实现。

E. abstract方法是抽象方法，不允许使用static修饰，因为static方法是与类相关联的，而abstract方法是需要子类实现的，无法直接与类关联。

63．下列元素中哪一个不是在变量声明中所要求的？ [      ]

A．类型     B．标识符        C．赋值        D．分号   

64．java程序语言中的赋值运算符是(    )。[      ]

A．=         B．==            C．:=           D．::

65．下列中哪一个不是java中的简单数据类型? [      ]

   A．布尔型    B．字节型         C．整型        D．扇区

66．方法的参数总是出现在(    )里。[      ]

A．括号      B．双引号         C．单引号      D．花括号

67．下列数据类型中哪一个存储值占用的存储空间最少? [      ]

A．短整型    B．长整型         C．整型        D．字节型

68． 下列哪个叙述是正确的?（D）

A. 子类继承父类的构造方法。

B. abstract类的子类必须是非abstract类。

C. 子类继承的方法只能操作子类继承和隐藏的成员变量。

D. 子类重写或新增的方法也能直接操作被子类隐藏的成员变量。

  A. 子类可以继承父类的构造方法，但并不是每个构造方法都会被子类继承，只有非私有的构造方法才能被子类继承。

B. abstract类的子类可以是abstract类，也可以是非abstract类。子类可以选择性地实现父类的抽象方法。

C. 子类继承的方法可以操作子类继承和隐藏的成员变量，即可以访问子类自身定义的成员变量，也可以访问从父类继承的成员变量。

D. 子类重写或新增的方法可以直接操作被子类隐藏的成员变量，即可以访问子类自身定义的成员变量，而不会访问到父类中同名的被隐藏成员变量。

69．声明为public int aMethod(double d)的方法的类型为(    ) 。[      ]

A．整型      B．双精度         C．空          D．不能决定的类型

70．名叫max()需要的两个整型参数的方法应声明为(    )。[      ]

A．public void max()             B．public void max(int a,b)

C．public void max(int a,int b)      D．public void max(a,b)

71．允许只能通过类自己的方法改变类的私有数据的概念称为(    )。[      ]

A．结构化逻辑        B．面向对象             C．信息隐藏          D．数据掩饰

72．如果类名为student()，那么类的构造方法的名字是(    )。[      ]

A．任何合法的Java标识符       B．studentConstructor

    C．student                      D．用s开始的任何合法的Java标识符

73．假设变量r的值为8，下列哪一个打印ZZZ？[      ]

A．if(r>1)System.out.println("YYY")

   else System.out.println("ZZZ")

B．if(r<1)System.out.println("YYY")

   else System.out.println("ZZZ")

C．if(r!=1)System.out.println("YYY")

   else System.out.println("ZZZ")

D．所有都打印ZZZ

74．假设变量k的初始值是12，下列哪个语句可以设置m为0？[      ]

A．if(k>3&&k>6)m=0            B．if(k<3&&k<20)m=0

C．if(k>3&&k<0)m=0            D．所有的语句都可以设置m为0

75．提示用户输入的值必须在1到4之间，正确 的if语句是(    )。[      ]

A．if(ans >='1'||ans<='4') System.out,println("goodresponse ");

B．if(ans>='1'&&ans<='4') System,out.println("good response");

C．两个语句都正确

D．两个语句都不正确

76．语句for (a=0; a<5; ++a) System.out.println (a+" ")；打印的是(    )。[      ]

A．0  0  0  0  0               B．0  1  2  3  4

C．0  1  2  3  4  5            D．什么也没有

77．下列语句打印的是(    )。[      ]

for(f=1,g=4;f

System.out.print(f+" "+g +" ");

A．1 4 2 3 3 2                   B．1 4 2 3

C．1 4 2 5 3 6 ……              D．什么也没有

78．如果声明数组为int [ ]num=new int[6] ，则数组的最后一个元素是(    )。[      ]

A．num [ 5 ]     B．num [6 ]    C．num [ 7 ]       D．不存在

79．在HTML文档中调用使用CODE的任何Applet的名字要以(    )为扩展名。[   D  ]

A．.exe         B．.code       C．.java          D．.class

80．当用户(    )时，destroy( )方法被调用。[      ]

A．关闭浏览器或AppletViewer窗口        B．最小化AppletViewer窗口

C．离开页面                                               D．退出计算机

81．下列Java常见事件类中哪个是鼠标事件类？  [       ]

A．InputEvent      B．KeyEvent        C．WindowEvent      D．MouseEvent

82．Window和Frame的默认布局管理器是(  )
   

     A）、CardLayout        B）、FlowLayout        C）、BorderLayout        D）、GridLayout         

83．下列InputStream类中哪个方法可以用于关闭流？[       ]

A．skip（）        B．close（）       C．mark（）        D．reset（）

84．(       )可作为所有窗体和对话框的顶层窗体使用。[       ]

A.  JPanel      B.  JFrame      C.  JComponent       D.  JMenuBar

85．下列关于Frame类的说法不正确的是(    )。 [       ]

A．Frame是Window类的直接子类                B．Frame被默认初始化为可见 

C．Frame对象显示的效果是一个窗口         D．Frame的默认布局管理器为BorderLayout 

86． 以下哪项可能包含菜单条（                ）。
A）Panel    B）Frame        C）Applet        D）Dialog  

87． 用于输入压缩文件格式的ZipOutputStream 类所属包是(  )
          A）、java.util.zip        B）、java.io        C）、java.nio        D）、java.util 

88．设有下面两个赋值语句： (  )
        a = Integer.parseInt(“123”);
        b = Integer.valueOf(“123”).intValue();
下述说法正确的是（    ）。
A）、a是整数类型变量，b是整数类对象。B）、a是整数类对象，b是整数类型变量。
C）、a和b都是整数类对象并且值相等。  D）、a和b都是整数类型变量并且值相等。  

89．如果希望所有的控件在界面上均匀排列，应使用下列那种布局管理器？[       ]

A．BoxLayout     B．FlowLouLayout  C．BorderLayout   D．GridLayout

90．假设定义：String s = "Example"; 请问如下代码哪一个是正确的：(    ) [       ]

A．s>=3 ;                     B.  s<=2 ;      

C.  int i=s.length ;          D.  String t = "For " + s ;91.在浏览器中执行applet 程序，以下选项中的哪个方法将被最先执行……… (    )
A）init()    B）start()      C）destroy()        D）stop()  

92.下列叙述中，正确的是 
A）Java语言的标识符是区分大小写的    B）源文件名与public类名可以不相同 
C）源文件扩展名为.jar                  D）源文件中public类的数目不限  

93.在Java中，负责对字节代码解释执行的是______。 

A）垃圾回收器    B）虚拟机          C）编译器          D）多线程机制 

94. 下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？ [       ]

A．private        B．protected       C．public          D．无修饰符

95.对于下列程序，叙述正确的是（）。 

public class E {
public static void main（String args[]) { 
Target target =new Target（); 
Thread thread =new Thread（target); 
thread.start（); 
} 
}
 
class Target implements Runnable{
 public void  run(){
System.out.println("OK");
}
}

A.JVM认为这个应用程序共有两个线程。

B.JVM认为这个应用程序只有一个主线程。

C.JVM认为这个应用程序只有一个thread线程。

D.thread的优先级是10级。

    在该程序中，主线程通过创建一个新的线程对象 Thread，并将其传递给 Target 类的实例 target，然后调用新线程的 start() 方法来启动线程。这样就会创建一个新的线程，并且在新线程中执行 Target 类的 run() 方法中的代码，打印出 "OK"。

 JVM认为这个应用程序共有两个线程，一个是主线程，另一个是通过创建的新线程。

96.对于下列程序，叙述正确的是（）。 

A.JVM认为这个应用程序共有两个线程。

B.JVM认为这个应用程序只有一个主线程。

C.JVM认为这个应用程序只有一个thread线程。

D.程序有编译错误，无法运行

public class E {
public static void main（String args[]) { 
Target target =new Target（); 
Thread thread =new Thread（target); 
thread.run（); 
} 
}
 
class Target implements Runnable{
 public void  run(){
System.out.println("OK");
}
}

      在该程序中，主线程通过创建一个新的线程对象 Thread，并将其传递给 Target 类的实例 target，然后调用新线程的 run() 方法来执行线程的任务。在这种情况下，调用 run() 方法并不会创建一个新的线程，而是在主线程中直接执行 run() 方法中的代码，打印出 "OK"。

    JVM仍然认为这个应用程序只有一个主线程，在主线程中执行了 run() 方法中的代码

97.下列叙述错误的是（).
A.线程新建后，不调用start(）方法也有机会获得CPU资源
B.如果两个线程需要调用同一个同步方法，那么一个线程调用该同步方法时另一个
线程必须等待
C.目标对象中的run(）方法可能不启动多次
D.在默认情况下，所有线程的优先级都是5级

      在Java中，线程的运行是通过调用线程的start()方法来启动的。当调用start()方法时，会创建一个新的线程，并且在新线程中会调用线程的run()方法来执行具体的任务。因此，无论是通过继承Thread类还是实现Runnable接口来创建线程，只要调用了start()方法，就会启动新线程并执行run()方法中的代码。

98.下列叙述正确的是（A)
A.String类是final类，不可以有子类                    B. String 类在java.util包中（java.lang包）
C. "abc"=="abc"的值是false （true）                  D."abc".equals("Abc"）的值是true(false

99.下列表达式正确（无编译错误）的是（B ）

A. int m =Float. parseFloat("567");          B. int m=Short. parseShort("567")；

C. byte m =Integer. parseInt("2");             D. float m =Float. parseDouble("2.9")；

100.对于以下代码，下列叙述正确的是（B)

A.程序编译出现错误                                     B.程序标注的【代码】的输出结果是 bird

 C.程序标注的【代码】的输出结果是fly      D.程序标注的【代码】的输出结果是null

​
​
public class E{
public static void main(String(] args)(
String strOne= "bird";
String strTwo=strOne;
strOne ="fly";
System. out. println(strTwo);//代码
}}
 
​

101.对于以下代码，下列叙述正确的是（）
A.程序出现编译错误
B.无编译错误，在命令行执行程序“java E I love this game”,程序输出this

C.无编译错误，在命令行执行程序“java E let us go”，程序无运行异常

D.无编译错误，在命令行执行程序“java E0123456789”,程序输出3

​
public class E{
public static void main(String(] args)(
String s1= args[1];
String s2= args[2];
String s2= args[3] ;
System. out. println(s3);//代码
}}

102.下列叙述错误的是（C）
A."9dog".matches("\\ddog")的值是true 
B."12hello567".replaceAll("[123456789]+"，"@")返回的字符串是@hello@ 
C.new Date(1000）对象含有的时间是公元后1000小时的时间
D."\\hello\n“是正确的字符串常量

103.下列叙述正确的是（B)
A.创建File对象可能发生异常
B. BufferedReader 流可以指向 FileInputStream流
C. BufferedWriter 流可以指向FileWriter流
D. RandomAccessFile流一旦指向文件就会刷新该文件

104.为了向hello.txt 文件尾加数据，下列选项中，（B）是正确地创建指向hello.txt的流
A. try { OutputStream out=new FileOutputStream ("hello. txt");         catch(IOException e){}
B. try {OutputStream out=new FileOutputStream("hello. txt",true);     catch(IOException e){}
C.try { OutputStream out=new FileOutputStream("hello. txt",false);   catch(IOException e){}
D. try (OutputStream out=new OutputStream("hello.txt",true);     catch(IOException e){}

105. 下列叙述不正确的是（A)
A.一个应用程序中最多只能有一个窗口

B.JFrame创建的窗口默认是不可见的

C.不可以向JFrame窗口中添加JFrame窗口
D.窗口可以调用setTitle(String s）方法设置窗口的标题

106.下列叙述不正确的是（A)
A. JButton 对象可以使用 addActionListener(ActionListener l）方法将没有实现ActionListener 接口的类的实例注册为自己的监视器
B.对于有监视器的JTextField文本框，如果该文本框处于活动状态（有输人焦点），用户即使不输入文本，只要按回车（Enter）键也可以触发 ActionEvent事件

C.监视 KeyEvent事件的监视器必须实现KeyListener接口
D.监视 WindowEvent事件的监视器必须实现WindowListener 接口

107.下列叙述不正确的是（A）。
A.使用FlowLayout 布局的容器最多可以添加5个组件

B.使用BorderLayout 布局的容器被划分成5个区域

C. JPanel的默认布局是FlowLayout布局
D. JDialog的默认布局是BorderLayout布局

(使用FlowLayout布局的容器并没有限制添加组件的数量。FlowLayout布局会按照组件的添加顺序在容器中按行排列，并根据需要自动换行。)

108.下列程序中注释的哪个代码A、B、C、D是错误的？（）

abstract class Takecare{ 
protected void speakHello(){ } //A
 public abstract static void cry(); //B
 static int f(){ return 0; } //C
 abstract float g(); //D
}

 

B. public abstract static cry(); //B - 这个注释有错误。在声明抽象方法时，不能同时使用 abstract 和 static 关键字。抽象方法必须在具体的类中实现，而静态方法不具备多态性，无法被继承或重写。

二、判断题

( ×   ) 1．default在switch选择结构中是必须的。（ x  ）break在switch选择结构中是必须的。

      在Java的switch选择结构中，break语句用于终止当前的case并跳出switch语句块。它可以防止代码继续执行其他case分支。但是，break语句并不是必须的，具体取决于需要实现的逻辑。default语句：switch语句首先会找满足条件的case值做为执行后面的程序入口，若所有的case都不满足，则找default入口，若未找到则退出整个语句；default只是一个备用入口，有没有都无所谓。如果在某个case分支中使用了break语句，则在执行完该case分支后会跳出switch语句块，不会继续执行其他case分支。这是最常见的用法，可以避免现"case穿透"现象。

     但有时候我们可能会有意让代码继续执行下一个case分支，这时就可以不使用break语句。这种情况下，程序会继续执行下一个case分支，直到遇到break语句或者switch语句块结束。

     break语句在switch选择结构中并不是必须的，取决于实际需要控制代码流程的逻辑。

(  ×  ) 2．下面的代码打印值1到10

n=1;

while(n<10)

System.out.println(n++);

（ ×  ）下面的代码打印值1到10

n=1;

while(n<10)

System.out.println(++n);

(  √ ) 3．在java的一个源程序文件中最多只允许有一个public类。

解释：

     在Java中，每个源程序文件都可以包含多个类，但只能有一个类被声明为public。这个public类的类名必须与文件名相同，并且一个Java程序的入口点（例如，包含main方法的类）通常被声明为public类。

      其他非public类可以在同一个源程序文件中存在，但它们的访问权限将受到限制，只能在同一个包中被访问。为了保持Java程序的结构清晰和可维护性，每个源程序文件都有一个清晰的入口点，并且只有特定的类对外可见。

(   × ) 4．如果p是父类Parent的对象，而c是子类Child的对象，则语句c = p;是正确的。

（  √ ）4．如果p是父类Parent的对象，而c是子类Child的对象，则语句“p = c;”是正确的。

      在Java中，父类的对象不能直接赋值给子类的对象。这是因为子类对象具有父类对象的所有特性和行为，但是父类对象不具备子类对象特有的属性和方法。

          正确的赋值应该是将子类对象赋值给父类对象，即可以使用父类引用来引用子类对象，如 p=c;

(  √  ) 5．一个类可以生成多个对象，并且这些对象必须具有相同的属性。

( √  ) 6．构造方法也可以重载。

（ √   ）7、String abc[ ];是合法的Java语句。

（  √ ）8、在Java语言里，do-while语句是先执行循环体，然后再判断的循环条件。

  do/while 语句与 while 语句不同的是,它先执行大括号内的循环体,再判断条件,如果条件不满足,下次不在执行循环体。

（  √ ）9、抽象类不能创建实例。　　　　　　                  

（   √）10、Java源程序在转换为机器语言执行过程中既有编译也有解释。

（ √ ）11．Java语言采用一个字节表示一个字符。

（  √ ）12．String是永久类，一旦创建String类的对象，该对象是不可修改的。

       Java中，String类是不可变的（immutable）类，这意味着一旦创建了String对象，它的值就不能被修改。

      当你对String对象执行字符串操作（例如拼接、替换等），实际上是创建了一个新的String对象，而原始的String对象保持不变。这是因为String类内部使用了字符数组来存储字符串的值，并且该字符数组是被声明为final的，不可更改。

例如，对于以下代码片段
 String str = "Hello"; str = str + " World";

在执行 str = str + " World"; 这行代码时，实际上创建了一个新的String对象来保存 "Hello World" 的值，并将新的String对象赋给变量str。原始的 "Hello" 字符串对象仍然存在，但是没有被修改。这种不可变性使得String类在多线程环境下是线程安全的，也方便进行字符串的共享和缓存，同时提高了性能。

( ×  ) 13．java语言中不用区分字母的大写小写。

(  ×  )14．数组允许存放不同类型的定长元素。

( ×   ) 15．Java中的类的继承支持多继承的。（ × ） 在Java里，允许多重继承。

Java不支持多继承，而是支持多重继承的一种形式。

    多重继承是指一个类可以同时继承多个父类，即一个子类可以有多个直接父类。这在某些编程语言中是允许的，但在Java中是不被支持的。Java中的类只能继承一个直接父类，这是为了避免多继承可能引发的冲突和复杂性问题。

      Java使用接口（interface）来实现类似于多继承的概念，即一个类可以实现多个接口。一个类可以实现多个接口，从而获得多个接口定义的方法。这种机制允许类在实现不同的接口时具备不同的行为和功能。

接口提供了一种灵活而安全的方式来实现多重继承的特性，通过接口的实现，类可以拥有多个不同的行为，同时避免了多继承可能带来的冲突和复杂性。

     Java中的区别是不支持多继承，但支持多重继承的一种形式，即通过实现多个接口来实现类似多继承的效果。

(  √  ) 16．while(1){}将出现编译错误。

 在java中不行，C语言中的1可以当做boolean类型，而java中的1只能是数值型；

（√）17. "\natural"是正确的 String 常量。

\natural 是一个正确的 String 常量。在 Java 中，\ 被用作转义字符 ,\n默认为换行符 

（√）18.表达式"89762.34".matches("[-9.0]+")的值是 false。

（×）19.表达式 new String("abc") == "abc" 的值是true。

使用 new 关键字创建的新对象和常量字符串 "abc" 是不同的对象，它们在内存中的地址不同。 

（√）20.表达式 new String("abc") == new String("abc") 的值是 false。

使用 new 关键字创建的两个新对象是不同的对象

  （√） 21.表达式 "3.1415926".matches("[0-9]+[.]{1}[0-9]+") 的值是 true。

 （√） 22.表达式 "java88_hello_99".matches("[a-zA-Z0-9_]+") 的值是 true。

(√)   23.Random 对象的 nextInt(int n) 方法随机返回 [0，n) 区间的一个整数

（×） 24.表达式 "RedBird".indexOf("Bird") 的值是 4。

"Bird" 出现在字符串中的起始位置是索引 3

（×） 25.表达式 "\t\nABC".length() 的值是 4。

"\t" 和 "\n" 分别表示制表符和换行符，它们占用一个字符的位置，因此字符串的长度是 4

（√）26.可以同时用final和abstract修饰同一个方法。

（√）27.子类继承父类的构造方法。

 （√）28.在子类中想使用被子类隐藏的实例成员变量或实例方法就需要使用关键字super。
 （x） 29.可以用final修饰构造方法。

（X）30.如果在子类的构造方法中没有显式地写出super关键字来调角父类的某个构造方法，那么编译器默认有“super(）；”调用父类的无参数的构造方法，如果父类没有这样的构造方法 ，代码会出现编译错误。

如果父类没有无参数的构造方法且子类没有显式调用其他父类构造方法，编译器会报错。

（x）31.接口中也能声明变量。
（x）32.Java8之后，接口中也能定义非抽象的不加default 修饰的方法。
(x)33.Java 8之后，接口中可以定义private方法。
(√）34.接口中的常量可以不指定初值。
(√）35.可以在接口中只声明常量，不定义任何方法。

（√）36.子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量。

（√）37.如果一个类的所有构造方法的访问权限都是private的，意味着这个类不能有子类，理由是一个类的private方法不能在其他类中被使用，但子类的构造方法中一定会调用父类的个构造方法。

（√）38.子类在进行方法重写时，不可以把父类的实例方法重写为类（static)方法，也不可把父类的类（static）方法重写为实例方法。

（×）39.在abstract类中只可以有abstract方法。

abstract类可以包含非抽象方法。

（x）40.子类可以有多个父类。

Java不支持多继承，一个类只能继承一个父类

三、简答题

1、什么叫方法的重载？构造函数可以重载吗？ 

答：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，
即或者是参数的个数不同，或者是参数的类型不同。    

构造方法能重载。

2、Frame类对象的默认布局是什么？和Panel类对象的默认布局相同吗？ 

答：Frame容器的默认布局是BorderLayout布局，Panel容器的默认布局是FlowLayout布局。所以是不同的。

3、什么是异常？为什么要进行异常处理？         

答：异常，是指由于程序运行时发生错误，从而导致程序错误结束。
     在进行程序设计时，错误的产生是不可避免的，没有异常处理代码的程序，在运行时发生错误则可能非正常结束，引起严重问题。因此，Java给程序员提供了处理运行时错误的功能，称为异常处理。

4、谈谈final, finally, finalize的区别？ 

答：final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重写
       finally—异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
      finalize—Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

5、Overload和Override的区别。 

 答：

    方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading) 

 6．怎样区分Java应用程序和小应用程序？

答：Java应用程序源文件经过编译生成字节码文件，然后直接在Java虚拟机中解释执行，必须包含一个main方法；Java小应用程序必须继承系统提供的Applet类，源文件经过编译生成字节码文件，再编写相应的html文件，在html文件嵌入字节码文件，由Web浏览器来解释执行。 可以用 main和extends来区分Java应用程序和小应用程序。

7．类变量与实例变量有何区别？

答：

       类变量是用关键字static修饰的变量，而实例变量不用关键字static修饰。程序定义的每个对象都有自己的实例变量，而类变量是类所有对象共享的成员变量。不同对象的实例变量将被分配不同的内存空间，改变类的某一个对象的实例变量值不会影响其他对象的实例变量。类变量的内存只有一处，让类的所有对象共享。从类的任一对象改变类变量，类的其他对象都能发现这个改变。

8．简述进程和线程的基本概念以及它们的区别。

答：

        方法重载是指在同一个类中，两个方法具有相同名称、不同的的参数，即或者是参数的个数不同，或者是参数的类型不同。方法覆盖是指在子类对父类中已定义方法的方法体重新加以实现。

9．Java有哪些基本的数据类型？

(1)整型：基本型int、字节型byte、短整型short和长整形long

(2)浮点型：单精度float和双精度double

(3)字符型char

(4)逻辑型boolean

10．类方法与实例方法有何区别？

       类方法是用关键字static修饰的方法，而实例方法不用关键字static修饰。类中的实例方法可以互相调用，并可调用类方法。类方法也能互相调用，但不能直接调用实例方法。实例方法可以引用实例变量也可以引用类变量，类方法可以引用类变量，不能引用实例变量。实例方法只能通过对象名调用，类方法对象名和类名都可以调用。

11．awt和swing是什么关系？

        它们都是提供构造图形界面元素的类。AWT 是抽象窗口组件工具包，是 java 最早的用于编写图形节目应用程序的开发包。 Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的，是AWT的改良版，不是代替AWT。AWT依赖于主平台绘制用户界面组件；而Swing有自己的机制，在主平台提供的窗口中绘制和管理界面组件。

12．简述开发与运行Java程序的主要步骤？

（1）编写源程序，并保存为扩展名为.java的文件。

（2）经过Java编译器把源代码编译为字节码文件，即扩展名为.class的文件。

（3）如果是应用程序，由Java解释器执行；如果是小程序，由Web浏览器来解释执行。

13．简述字节流与字符流的区别。

        字节流用于读写二进制数据。字节流数据是8位的，由InputStream类和OutputStream类为字节流提供API和部分实现。字节流读和写操作由FileInputStream类和FileOutputStream类提供支持。它们分别是InputStream类和OutputStream类的子类。

       字符流用于读写16位的Unicode字符，由Reader类和Writer类为字符流提供API和部分实现。字符流读和写操作由FileReader类和FileWriter类提供支持。它们分别是Reader类和Writer类的子类。

14．请简要说明抽象类和接口的区别。

         abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但一个类却可以实现多个interface。

     在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。

15.请从平台、内存管理和安全的角度分析Java语言的三个主要特点，并与C/C++进行比较。

 答：

平台：C/C++是编译型语言，因此与平台相关，而Java使得语言声明不依赖于实现的方面。Java的字节码对新的硬件平台和操作系统是可移植的。

内存管理：C/C++要求程序员管理内存的分配和维护，不仅增加程序员的负担，而且容易造成错误。而Java不支持指针，它消除重写存储和讹误数据的可能性。Java支持自动的垃圾回收，预防存储漏泄和其它有关动态存储分配和解除分配的有害错误。

安全：Java运行系统使用字节码验证过程来保证装载到网络上的代码不违背任何语言限制。这个安全机制部分包括类如何从网上装载。

16.请说明以下程序在运行过程中出现的问题并解释造成该问题的原因。

 class A{
     A(){print();}
     void print(){
         System.out.println("Hei");
     }
 }
 
 class B extends A{
     int [ ]array;
     B(){
         array=new int[2];
     }
     void print(){
         System.out.println(array[0]+""+array[1]);
     }
 }
 public class Test{
     public static void main(String[] args) {
         A a=new B();
     }
 }

答：

运行时抛出空指针异常。程序运行说程如下！
（L） 程序首先创建B类的实例；
（2）执行B的构造函数前，Java 自动调用super 函数，进行父类A的初始化；
（3）程序进入A的构造函数。调用print；由于该实例的运行时类型为B，程序将调用B的 array函数；

（4）执行B的 array函数时，程序尝试打印array[0]与 array[1];

（5） 由子此时 array 数组尚夫被初始化，因此程序将抛出空指针异常。

17.请说明以下程序在运行过程中出现的问题并解释造成该问题的原因。

class A {
     public int id;
     public A(int id) {
         this.id = id;
     }
 
     synchronized void work(A other) {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
         } 
         synchronized (other) {
             System.out.println("Thread" + id + "is running");
         }
     }
 
     public static void main(String[] args) {
         A a1=new A(1);
         A a2=new A(2);
         Thread t1=new Thread(()->{a1.work(a2);});
         Thread t2=new Thread(()->{a2.work(a1);});
         t1.start();
         t2.start();
     }
 }

答： 该程序会造成死锁。比如下列情形：
（1） t1 的work 函数请求自身对象的实例锁，成功后对自身上锁并执行 sleep
语句进入阻塞状态；
（2） t1的work 函数请求自身对象的实例锁，成功后对自身上锁并执行 sleep
语句进人阻塞状态:
（3） t1在sleep 结束后继续执行，并请求t2的实例锁；由于此时t2的实例锁
为锁住状态，t1将被阻塞 
（4） t2 在 sleep 绪实后继续执行、并请求t1的实例锁；由于此时 t1 的实例锁
为锁住状态，2将被阻塞；
由此，t1与t2将进入死锁状态。

 18.给定以下程序，请判断字符串实例a 被回收的具体时间点，并对你的结论进行解释。

 class A {
     public static void main(String[] args) {
       String a=new String("hello world");
       String b=new String("game over");
         System.out.println(a);
         a=null;
         System.out.println(b);
         b=null;
         System.gc();
     }
 }

字符串a在a=null之后可以被回收。但具体回收时间点取决于JVM的运行时，因此无法确定。

  19.请解释重载和覆盖的区别。 

答：
重载指父类与子类中同名但调用参数类型或个数不同的函数;
覆盖指父关与子关中同名调用参数类型和个数都相同的函数。

20.线程有几种状态？

答：线程有六种状态：新建（New）、可运行（Runnable）、运行（Running）、阻塞（Blocked）、等待（Waiting）和终止（Terminated）。

21.引起线程中断的常见原因是什么？

答：

• 调用线程的 interrupt() 方法
• 调用阻塞方法（如 sleep()、wait()、join() 等）时被中断
• 调用底层 I/O 操作（如读取文件或网络数据）时被中断
• 调用 ThreadGroup 对象的 interrupt() 方法来中断线程组中的所有线程

22.一个线程执行完run(）方法后进入了什么状态？该线程还能再调用start(）方法吗？

答：当一个线程执行完 run() 方法后，进入终止（Terminated）状态。在终止状态下，该线程不能再调用 start() 方法。一旦线程终止，它就无法再次启动。

23.线程在什么状态下调用isAlive()方法返回的值是false?

答：线程在终止（Terminated）状态下调用 isAlive() 方法返回的值是 false。

24.线程调用interrupt(）的作用是什么？

答：线程调用 interrupt() 方法的作用是中断线程。它不会直接停止线程的执行，而是设置线程的中断状态为 true，然后根据线程在执行过程中的逻辑，可以通过检查中断状态来决定是否终止线程的执行。常见的做法是在循环中使用 isInterrupted() 方法来检查中断状态，并根据需要安全地终止线程的执行。

25.建立线程有几种方法？

答：

• 继承 Thread 类并重写 run() 方法。
• 实现 Runnable 接口并将其传递给 Thread 类的构造函数。
• 使用 Executor 框架创建线程池并提交任务。

26.怎样设置线程的优先级？

答：线程的优先级可以通过 setPriority(int priority) 方法来设置，其中优先级的范围是 1（最低）到 10（最高），默认优先级为 5。

27.在多线程中为什么要引入同步机制？

答： 在多线程中引入同步机制的主要目的是确保多个线程之间的操作顺序和数据的一致性。同步机制可以防止多个线程同时访问共享资源导致的数据不一致或并发问题，如竞态条件、死锁等。

28.在什么方法中wait(）方法、notify(）方法及notifyAll(）方法可以被使用？

 答：wait(), notify(), 和 notifyAll() 方法可以在同步代码块或同步方法中使用，用于线程之间的通信和协调。常见的使用场景是使用 wait() 方法使线程等待某个条件的满足，然后通过 notify() 或 notifyAll() 方法来唤醒等待的线程。

29.如果准备按字节读取一个文件的内容，应当使用FilelnputStream 流还是FileReader 流？

答：应当使用FileInputStream流。

30.FileInputStream 流的read()方法和FileReader 流的read(）方法有何不同？

答：

FileInputStream流的read()方法以字节为单位读文件

FileReader流的read()方法以字符为基本单位处理数据

31. BufferedReader 流能直接指向一个文件吗？

答： 不能

32.使用 ObjectInputStream 类和ObjectOutputStream 类有哪些注意事项？

答：

        当用对象流写入或读出对象时,要保证对象是序列化的。这是为了保证能把对象写到文件,并能再次把对象正确读回到程序中。

        Java提供给我们的绝大多数对象都是所谓序列化的,比如组件等。一个类如果实现了Serializable接口,那么这个类创建的对象就是所谓序列化的对象。Serializable接口中的方法对程序是不可见的,因此实现该接口的类不需要实现额外的方法,当把一个序列化的对象写入到对象输出流时,JVM就会实现Serializable接口中的方法,按着一定格式的文本将对象写入到目的地。

33.怎样使用输入和输出流克隆对象？

答：使用对象流很容易得获取一个序列化对象的克隆,只需将该对象写入到对象输出流,那么用对象输入流读回的对象一定是原来对象的一个克隆。

34.什么叫事务？事务处理的步骤是怎么样的？

答：事务由一组SQL语句组成,所谓事务处理是指:应用程序保证事务中的SQL语句要么全部都执行,要么一个都不执行。事务处理步骤是调用:(1)连接对象用setAutoCommit()方法关闭自动提交模式,(2)连接对象用commit()方法处理事务,(3)连接对象用rollback()方法处理事务失败。

35.JFrame类的对象的默认布局是什么布局？

JFrame默认布局是BorderLayout

36.一个容器对象是否可以使用add方法添加一个JFrame窗口呢？

 不可以。JFrame窗口是一个底层容器,其他组件必须被添加到底层容器中,以便借助这个底层容器和操作系统进行交互。窗口默认被系统添加到显示器屏幕上,1个容器对象不可以使用add方法添加一个JFrame窗口

37.JFextField可以触发什么事件？

ActionEvent,KeyEvent

38.JTextArea中文档对象可以触发什么类型的事件？

DocumentEvent

39.MouseListener接口中有几个方法？

5

40.处理鼠标事件拖动触发的MouseEvent事件需使用哪个接口?

MouseMotionListener。

四、填空题

1.、java技术的三大特征分别是  虚拟机   、  垃圾回收器  、 代码安全   。
2、 抽象类是一种特殊的类，它本身不能够被_实例化____,但可被继承。
3、创建一个名为 MyPackage 的包的语句是         package MyPackage   。 

4、开发与运行Java程序需要经过的三个主要步骤为  编辑源程序，编译生成字节码和解释运行字节码。


5、在Java程序中，通过类的定义只能实现单重继承，但通过接口的定义可以实现多重继承关系。

6、 Applet生命周期方法有init( )， start   ( )，stop( )和destroy( )。 

7、 继承 是面向对象的语言一个重要的机制，通过这种机制可以在一个一般类的基础上建立新类。

8.、如果类Alpha继承了类Beta，则类Alpha称为_子_类，类Beta称为_父__ 类。

9、已知int a,b; 则表达式a=2,b=5,a++;b++;a+b;的值为   9  。

10、

3、 

4、

五、写出下面程序执行的结果

49．本小题一共有三个类，类名分别为demo1、demo2和Exam49，编译这三个类都没问题，最后执行类名为Exam49对应的字节码文件。请写出执行的结果。

class Demo1 {
    int x;
    Demo1 (int a) {x=a;}
    void method() {System.out.println("我是demo1类的方法！值是"+x);}
    int getX() {return x;}
}
 
class Demo2 extends Demo1{
        double x;
        Demo2(int m,double n) {super(m); x=n;}
        void method() {
            double d2X=x;
            int d1X =super.getX();
            super.method();
            System.out.println("我是类demo2的方法!值是"+x);
            System.out.println("我获得的信息是："+" d1X ="+ d1X +", d2X ="+ d2X);
        }
}
 
public class A { public static void main(String []args) { 
    Demo2 obj=new Demo2(3,4.0);
    obj.method();
}
}

 答：

我是demo1类的方法！值是3
我是类demo2的方法!值是4.0
我获得的信息是： d1X =3, d2X =4.0

50．本小题有一个类，类名为Exam50，编译这个类没问题，最后执行该类对应的字节码文件。请写出执行的结果。

public class A {
    public static void main(String args[ ]) {
        int sum = 0 ;
        int []a={10,20,30,40,50,60,70,80};
 
    for(int i = 0;iif(i%2==0 ) {
        sum += a[i];
        System.out.print (a[i] +" ");
}
    System.out.println();
    System.out.println("sum= "+sum);
}

答案：

10 30 50 70 
sum= 160

49．本小题一共有三个类，类名分别为Aparentclass、Achildclass和A，编译这三个类都没问题，最后执行类名为Exam49对应的字节码文件。请写出执行的结果。

class Aparentclass {
 
    private int aVal;
 
    public void printclassName() { System.out.println("Aprarentclass");}
 
}
 
 
class Achildclass extends Aparentclass {
    public void printclassName() {
        System.out.println("I am Achildclass");
        System.out.println("My parent is");
        super.printclassName();
        }
        }
 
public class A {
    public static void main(String []args)
    {
        Achildclass child=new Achildclass();
        child.printclassName();
 
    }
 
}

答案：

I am Achildclass
My parent is
Aprarentclass
 

五、程序编程题

1. 请写一个程序, 类名叫HelloWorld，类里面有一个成员方法sayHello()，这个方法能向控制台输出HelloWorld. 

答： 

public class HelloWorld{
     public void sayHello(){
            System.out.println(“HelloWorld!”)  
  }
     public static void main(String args[])   {
            HelloWorld hello=new HelloWorld();
            hello. sayHello
}
}

2. 用Java写一个Singleton出。Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

答：

public class Singleton { 
private Singleton ();
　　private static Singleton instance = null;
　　public static Singleton getInstance() {
　　    if (instance==null)
　　  instance＝new Singleton();
          return instance; 　
　　} 
}

3.补全Fish类，使得以下该程序输出为true.

public class A{
	  public static void main(String []args) {
	        Fish f1=new Fish(20,"WWW");
	        Fish f2=new Fish(20,"WWW");
	        System.out.println(f1.equals(f2));
	}
	
}   
	class Fish {
	    private int weight;
	    private String color;
 
	    public Fish(int weight, String color) {
	        this.weight=weight;
	        this.color =color;
	    }
//补全代码如下
	    public int getWeight() {
	        return weight;
	    }
 
	    public String getColor() {
	        return color;
	    }
	 
	    public boolean equals(Object other) {
	    	if(other==this) return true;
	    	//注意系统会分不清getColor()
	    	if(other instanceof Fish &&((Fish) other).getWeight()==this.weight&& ((Fish) other).getColor()==this.color)
	        return true;
	    	return false;
	  }  
	}

3.银行金库被盗，共有4个嫌疑人，A说罪犯在B、C、D中。B说自己是清白的，罪犯是C。C说A和B中有一个是罪犯。D说B说的是真话。事实是四人中有两个人说真话，两人说假话，请编写程序求谁是罪犯。

public class A{
	 
	    public static void main(String[] args) {
	    	 
	    	  for (int i = 0; i <16 ; i++) {
	              boolean a,b,c,d;//值为true 表示为罪犯
	              a=((i>>0)&1)==1; b=((i>>1)&1)==1;
	             c=((i>>2)&1)==1; d=((i>>3)&1)==1;
	              if(checkStatements(a,b,c,d)==2){
	                  System.out.println("罪犯是：");
	                  if(a) System.out.println('A');
	                  if(b) System.out.println('B');
	                  if(c) System.out.println('C');
	                  if(d) System.out.println('D');
	              }
	          }
	          
	    }
 
	    // 检查嫌疑人的陈述是否符合条件
	    public static int checkStatements(boolean a,boolean b,boolean c,boolean d) {
	        int n=0;
	        if(!b&&!c&&!d) n++;//A 说谎
	        if(b||!c) n++;
	        if(!a&&!b) n++;
	        if(b||!c) n++;
	        
	        return n;
	    }
	}
 
 

54．编写一个Java应用程序，输出200到300间之间能同时被3和5整除的数，每行输出5个数。

答案： 

public class A{
    public static void main(String []args) {
        int i,j=0;
        for(i=200;i<=300;i++) {
         if(i%3==0&&i%5==0) {
             System.out.print(i+" ");//输出能被3/5整除的
             j++;
}
         if(j%5==0)   System.out.println();//每行5个
}
}
 
}

55．编写一个Java应用程序，从键盘输入某职工的工资总额(G)，计算该职工应交纳的个人收入所得税。计税办法是：当G<=800元时，免交个人所得税；8005000元时，按10%的税率纳税。

答案： 

public class A{
    public static void main(String []args)	{
        long m,G;
        double sum,mm,h;//如果用float ，必须要将0.02换成0.02f
        String result=(String)JOptionPane.showInputDialog(null," 工资总额","输入对话框",JOptionPane.PLAIN_MESSAGE,null,null,null);
        G=Integer.parseInt(result);
        if(G<=800) sum=0;
        else if(G>800&&G<=1500) sum=G*0.02;
        else if(G>1500&&G<=3000)  sum=G*0.05;
        else if(G>3000&&G<=5000) sum=G*0.08;
        else sum=G*0.1;
    System.out.println("sum="+sum);
 
    }
}  

55．编写一个Java应用程序，求100～200之间的素数，每行输出5个素数。

public class Exam55{
public static void main(String []args){
int i,j,count=1;
for(i=100;i<=200;i++){
for(j=2;j<=i/2;j++)
 if(i%j==0)
   break;
  if(j>i/2) {
  System.out.print(" "+i);
     count++;
  }
 
   if(count%6==0)  {
  System.out.println();
   count=1;
   }
    }
        }
           }

55．水仙花是一个n(n>=3)位数字的数，它等于每个数字的n次幂之和。例如，153=13+53+33。编写一个Java应用程序，求小于999的所有水仙花数。

答案：

public class Exam54{
     public static void main(String []args) {
   int i,b,s,g,sum;
    for(i=100;i<=999;i++) {
        b=i/100;
        s=i%100/10;
        g=i%10;
        sum=b*b*b+s*s*s+g*g*g;
       if(i==sum)
 System.out.print(" "+i);
  }
 }
}