Java语言程序设计考试题大全（含答案）

1．Java application中的主类需包含main方法，以下哪项是main方法的正确形参？（ B ）
A、 String args B、String args[] C、Char arg D、StringBuffer args[]
2．以下代码段执行后的输出结果为（ A ）
int x=－3； int y=－10；
System.out.println(y%x);
A、 -1 B、2 C、1 D、3
3．以下关于继承的叙述正确的是（ A ）。
A、在Java中类只允许单一继承
B、在Java中一个类只能实现一个接口
C、在Java中一个类不能同时继承一个类和实现一个接口
D、在Java中接口只允许单一继承
4. 若有定义：byte[] x={11,22,33,-66};
其中0≤k≤3，则对x数组元素错误的引用是（C）
A）x[5-3]
B）x[k]
C）x[k+5]
D）x[0]
5．paint()方法使用哪种类型的参数? （ A ）
A、Graphics B、Graphics2D C、String D、Color
6．以下哪个不是Java的原始数据类型（ B ）
A、int B、Boolean C、float D、char
7．在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序特性称为（ C ）
A） 隐藏
B） 重写
C） 重载
D） Java不支持此特性
8． 以下有关构造方法的说法，正确的是：（ A ）
A． 一个类的构造方法可以有多个
B． 构造方法在类定义时被调用
C． 构造方法只能由对象中的其它方法调用。
D． 构造方法可以和类同名，也可以和类名不同
9．在浏览器中执行applet 程序，以下选项中的哪个方法将被最先执行（ A ）。
A、init() B、start() C、destroy() D、stop()
10．给出下面代码，关于该程序以下哪个说法是正确的？（ C ）
public class Person{
static int arr[] = new int[5];
public static void main(String a[])
{
　　System.out.println(arr[0]);　}
}
A、编译时将产生错误 B、编译时正确，运行时将产生错误
C、输出零 D、输出空
11、有以下方法的定义，请选择该方法的返回类型（ D ）。
ReturnType method(byte x, double y)
{
return (short)x/y*2;
}
A、byte B、short C、int D、double

12．下列类定义中哪些是合法的抽象类的定义？（ C ）
A、abstract Animal{abstract void growl();}
B、class abstract Animal{abstract void growl();}
C、abstract class Animal{abstract void growl();}
D、abstract class Animal{abstrac t void growl(){System.out.println(“growl”);};}

13．有以下程序片段，下列哪个选项不能插入到行1。（ D ）
1.
2.public class Interesting{
3.//do sth
4. }
A、import java.awt.; B、package mypackage;
C、class OtherClass{ } D、public class MyClass{ }
14. 设有下面两个赋值语句：
a = Integer.parseInt(“12”);
b = Integer.valueOf(“12”).intValue();
下述说法正确的是（ D ）。
A、a是整数类型变量，b是整数类对象。B、a是整数类对象，b是整数类型变量。
C、a和b都是整数类对象并且值相等。 D、a和b都是整数类型变量并且值相等。
15．在编写Java Applet程序时，需在程序的开头写上( B )语句。
A、import java.awt. ; B、import java.applet.Applet ;
C、import java.io.* ; D、import java.awt.Graphics ;
16．下列哪一项不属于Swing的顶层容器？（ B ）
A）JApplet
B）JTree
C）JDialog
D）JFrame
17. 为了使包ch4在当前程序中可见，可以使用的语句是（ A ）。
A）import ch4.;
B）package ch4.;
C）ch4 import;
D）ch4 package;
18. 请问所有的异常类皆继承哪一个类？（ B ）。
A）java.io.Exception
B）java.lang.Throwable
C）java.lang.Exception
D）java.lang.Error
19．进行Java基本的GUI设计需要用到的包是（ C ）。
A）java.io
B）java.sql
C）java.awt
D）java.rmi

20. 当点击鼠标或者拖动鼠标时，触发的事件是下列的哪一个？（ D ）
    A）KeyEvent
    B）ActionEvent
    C）ItemEvent
    D）MouseEvent

1．下列哪个选项是合法的标识符？（_B ）
A、 123 B、 _name C、 class D、1first
2. 下列的哪个选项可以正确用以表示八进制值8？（_D ）
A）0x8
B）0x10
C）08
D）010
3． 已知有下列Test类的说明，则下列哪个语句是正确的？（A ）
public class Test
{
private float f = 1.0f;
int m = 12;
static int n=1;
public static void main（String args［］）
{
Test t = new Test（）;
}
}
A）t.f；
B）this.n；
C）Test.m；
D）Test.f；
4． 欲定义类字段或类方法（静态方法），应该使用下列哪一个修饰符修饰（B ）
A、public B、 static C、 protected D、 synchronized
5．与InputStream流相对应的Java系统的“标准输入对象”是（A ）。
A）System.in
B）System.out
C）System.err
D）System.exit()
6．在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序特性称为（ C ）
A） 隐藏
B） 重写
C） 重载
D） Java不支持此特性
7． 以下有关构造方法的说法，正确的是：（A ）
A． 一个类的构造方法可以有多个
B． 构造方法在类定义时被调用
C． 构造方法只能由对象中的其它方法调用。
D． 构造方法可以和类同名，也可以和类名不同
8． 设 int x=1,float y=2，则表达式 x / y的值是：（__D ）
A．0 B．1 C．2 D．以上都不是
9． 下列属于容器的组件有（B ）
A． JButton B． JPanel C． Thread D． JTextArea
10．进行Java基本的GUI设计需要用到的包是（ C ）。
A）java.io
B）java.sql
C）java.awt
D）java.rmi
11．下列类定义中哪些是合法的抽象类的定义？（____C ）
A、abstract Animal{abstract void growl();}
B、class abstract Animal{abstract void growl();}
C、abstract class Animal{abstract void growl();}
D、abstract class Animal{abstrac t void growl(){System.out.println(“growl”);};}
12．顺序执行下列程序语句后，则b的值是（D ）
String a=“Hello”;
String b=a.substring（0,2）;
A）Hello
B）hello
C）Hel
D）null
13．下列整型的最终属性 i 的定义中，正确的是(A )。
A) static final int i=100; B) final i;
C) static int i; D) final float i=1.2f;
14．Java Applet在被浏览器加载的时候首先被执行且在applet整个生命周期中只被运行一次的方法是（______A ）？
A) init() B) stop() C) opreationcrawl() D) reader()
15．下列哪一项不属于Swing的顶层容器？（_B ）
A）JApplet
B）JTree
C）JDialog
D）JFrame
16. 为了使包ch4在当前程序中可见，可以使用的语句是（___A ）。
A）import ch4.;
B）package ch4.;
C）ch4 import;
D）ch4 package;
17. 请问所有的异常类皆继承哪一个类？（_B ）。
A）java.applet.Applet
B）java.lang.Throwable
C）java.lang.Exception
D）java.lang.Error
18. 若有定义：byte[] x={11,22,33,-66};
其中0≤k≤3，则对x数组元素错误的引用是（C ）
A）x[5-3]
B）x[k]
C）x[k+5]
D）x[0]
19. 当点击鼠标或者拖动鼠标时，触发的事件是下列的哪一个？（D ）
A）KeyEvent
B）ActionEvent
C）ItemEvent
D）MouseEvent
20.下列语句序列执行后，输出结果是（_B ）。
public class ex {
public static void main(String[] args) {
int a=13;
a=a/5;
System.out.println(a);
}
}
A） 1
B） 2
C） 3
D） 4

1．Java application中的主类需包含main方法，以下哪项是main方法的正确形参？（ B ）
A、 String args B、String args[] C、Char arg D、StringBuffer args[]
2.下列的哪个选项可以正确用以表示八进制值8？（D ）
A）0x8
B）0x10
C）08
D）010

3． 设 int x=1,float y=2，则表达式 x / y的值是：（ D ）
A．0 B．1 C．2 D．以上都不是
4. 若有定义：byte[] x={11,22,33,-66};
其中0≤k≤3，则对x数组元素错误的引用是（ C ）
A）x[5-3]
B）x[k]
C）x[k+5]
D）x[0]

5．Java Applet在被浏览器加载的时候首先被执行且在applet整个生命周期中只被运行一次的方法是（ A ）？
A、init() B、start() C、opreationcrawl() D、reader()
6．在浏览器中执行applet 程序，以下选项中的哪个方法将被最先执行（ A ）。
A、init() B、start() C、destroy() D、stop()
7．在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序特性称为（ C ）
A） 隐藏
B） 重写
C） 重载
D） Java不支持此特性
8． 以下有关构造方法的说法，正确的是：（ A ）
A． 一个类的构造方法可以有多个
B． 构造方法在类定义时被调用
C． 构造方法只能由对象中的其它方法调用。
D． 构造方法可以和类同名，也可以和类名不同
9．类Parent、Child定义如下：
1． public class Parent
2．{ public float aFun(float a, float b) throws
3． IOException { }
4．}
5．public class Child extends Parent{
6．
7．}
将以下哪种方法插入行6是不合法的。（ A ）
A、float aFun(float a, float b){ }
B、public int aFun(int a, int b)throws Exception{ }
C、public float aFun(float p, float q){ }
D、public int aFun(int a, int b)throws IOException{ }
10．给出下面代码，关于该程序以下哪个说法是正确的？（ C ）
public class Person{
static int arr[] = new int[5];
public static void main(String a[])
{
　　System.out.println(arr[0]);　}
}
A、编译时将产生错误 B、编译时正确，运行时将产生错误
C、输出零 D、输出空
11．在编写Java Applet程序时，需在程序的开头写上( B )语句。
A、import java.awt.* ; B、import java.applet.Applet ;
C、import java.io.* ; D、import java.awt.Graphics ;
12．下列类定义中哪些是合法的抽象类的定义？（ C ）
A、abstract Animal{abstract void growl();}
B、class abstract Animal{abstract void growl();}
C、abstract class Animal{abstract void growl();}
D、abstract class Animal{abstrac t void growl(){System.out.println(“growl”);};}
13．在使用interface声明一个接口时，只可以使用（ D ）修饰符修饰该接口。
A、private B、protected C、private protected D、public 14. 设有下面两个赋值语句：
a = Integer.parseInt(“12”);
b = Integer.valueOf(“12”).intValue();
下述说法正确的是（ D ）。
A、a是整数类型变量，b是整数类对象。B、a是整数类对象，b是整数类型变量。
C、a和b都是整数类对象并且值相等。 D、a和b都是整数类型变量并且值相等。
14．在使用interface声明一个接口时，只可以使用（ D ）修饰符修饰该接口。
A、private B、protected C、private protected D、public
15．以下哪项可能包含菜单条（B ）。
A、Panel B、Frame C、Applet D、Dialog
16．下列哪一项不属于Swing的顶层容器？（ B ）
A）JApplet
B）JTree
C）JDialog
D）JFrame
17、给定下列表达式
Integer I= new Integer(42);
Long L= new Long(42);
Double D= new Double(42.0);
则下列表达式输出为true的是__D___
(A) (IL) (B) (ID) © (D==L) (D) (I.equals (D))

18. 请问所有的异常类皆继承哪一个类？（ B ）。
    A）java.io.Exception
    B）java.lang.Throwable
    C）java.lang.Exception
    D）java.lang.Error
    19．进行Java基本的GUI设计需要用到的包是（ C ）。
    A）java.io
    B）java.sql
    C）java.awt
    D）java.rmi

19. 当点击鼠标或者拖动鼠标时，触发的事件是下列的哪一个？（ D ）
    A）KeyEvent
    B）ActionEvent
    C）ItemEvent
    D）MouseEvent

1．Java语言最初是面向哪个应用领域设计的？（C ）
A） Internet B） 制造业
C） 消费电子产品 D） CAD
2．下列关于注释语句的描述中，正确的一项是（C）
A） 以//开始的是多行注释语句
B） 以/开始，/结束的是单行注释语句
C） 以/**开始，/结束的是可以用于生成帮助文档的注释语句
D） 以/**开始，/结束的是单行注释语句
3．下列标识符中，正确的是：（ C）
A） class B） 123_rr
C） _lei D） test&12
4．下列关于类、包和源文件的描述中，不正确的一项是（D）。
A） 一个包可以包含多个类
B） 一个源文件中，只能有一个公共类
C） 属于同一个包的类在默认情况下可以相互访问
D） 系统不会为源文件创建默认的包
5．关于被保护访问控制符 protected 修饰的成员变量，以下说法正确的是（B ）
A )可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B )可以被两种类访问和引用：该类本身、该类的所有子类
C )只能被该类自身所访问和修改
D )只能被同一个包中的类访问
6．为了区分重载多态中同名的不同方法，要求（A）。
A） 形式参数个数或者类型不同 B） 返回值类型不同
C） 调用时用类名或对象名做前缀 D） 形式参数名称不同
7．定义类时，不可能用到的保留字是（A）。
A） private B） class
C） extends D） implements
8．下列描述中不正确的一项是（B）。
A） import语句告诉Java用户需要哪个包（package）中的类
B） 所有的类必须实例化，才能调用它的数据成员和方法
C） package语句用于将源文件存入所指定的包中
D） System类不能实例化，它的所有方法都是通过类变量来调用的
9．为 AB 类的一个无形式参数无返回值的方法 method 书写方法头，使得使用类名 AB 作为前缀就可以调用它，该方法头的形式为 ( A) 。
A） static void method( ) B） public void method( )
C） final void method ( ) D） abstract void method( )
10．下面在命令行运行Java应用程序A：
java A the first snow came first
怎样才能在main(String args[])方法中访问单词”first”（C）
A ）args[0] B） args[2] C） args[4] D） args[5]
11．以下程序段，运行时会出现什么结果（C ）
public class Person{
static int arr[] = new int[5];
public static void main(String a[])
{
　　System.out.println(arr[0]);　}
}
A）编译时将产生错误 B）编译时正确，运行时将产生错误
C）输出零 D）输出空
12．对于下面这段程序，说法正确的是（D ）
class test1
{
public static void main(String args[])
{
int y,x=1,total=0;
while(x<=3)
{
y=x*x;
System.out.println(y);
total+=y;
++x;
}
System.out.println("total is "+total);
}
}
A）编译时将产生错误 B）程序将会陷入死循环
C）total的值是为3！ D）total的值最终为14
13．对于下面的不完整的类代码：（C ）
class person
{
String name,department;
public person(String n)
{
name=n;
}
public person(String n,String d)
{
_______________
department=d;
}
}
下面表达式中，哪个可以加到构造方法中的“___________”处
A）person(n) B）this(person(n))
C）this(n) D）this(n,a);
14．阅读下面代码：（A ）
class person
{
public int addvalue(int a,int b)
{
int s;
s=a+b;
return s;
}
}
class child extends parent
{
}
若要在child类中对addvalue方法进行重写，下面对于child类中的addvalue方法头的描述哪个是正确的：
A）int addvalue(int I,int j) B）void addvalue()
C）void addvalue(double i) D）int addvalue(int a)
15．下面程序中，有错误的一行是：（D ）
Final class MyClass ①
          { int var=100 ； ②
            static int getVar() ③
           {
            return var; ④
       } }
A）① B）② C）③ D）④

1．下面关于Java语言说法错误的是：（ D ）
A．java语言是解释运行的 B。java语言是从c和c++演变而来的
C．java语言支持多线程 D。java语言要求程序员必须自己回收内存
2．下面标识符中正确的是：（ A ）
A．$123_x B。12java C．new D。java#next
3．下面哪个不属于java的基本数据类型：（C ）
A．short B。boolean C．String D。char
4．下面关于方法的说法中不正确的是：（ D ）
A．方法可以没有返回值 B。方法调用时要求形参和实参保持一致
C．方法允许重载 D。方法的参数不能为空
5．下面定义数组的格式中正确的是：（ C ）
A．int a[10] B。int a=new int[10] C．int []a=new int[5] D.int a[]
6．下面说法中不正确的是：（ C ）
A．类是对象的抽象，对象是类的实例 B。类是组成java程序的最小的单位
C．java语言支持多继承 D。java一个程序中只能有一个public类
7．main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的（ B ）
A．public static void main（） B。public static void main（String[ ] args）
C．public static int main（String[ ] arg） D。public void main（String arg[ ]）
8．为 AB 类的一个无形式参数无返回值的方法 method 书写方法头，使得使用类名 AB 作为前缀就可以调用它，该方法头的形式为 （A ）
A．static void method( ) B。public void method( )
C．final void method ( ) D。abstract void method( )
9．下面说法中不正确的是：（A）
A．java中一个类只允许实现一个接口 B。抽象类中允许有非抽象方法的存在
C．类变量（实例变量）可以直接用类名调用 D。通过super可以调用基类的构造函数
10．容器Panel和Applet默认使用的布局编辑策略是（ B ）
A．BorderLayout B。FlowLayout C。GridLayout D。CardLayout
11．以下哪个表达式是不合法的（ B ）
A．String x=“Hello”; int y=9; x+=y;
B．String x=“Hello”; int y=9; if(x= =y) { }
C．String x=“Hello”; int y=9; x=x+y;
D．String x=null; int y=(x!=null)&&(x.length()>0)
12．对于下面的不完整的类代码：（ C ）
class person
{
String name,department;
public person(String n)
{
name=n;
}
public person(String n,String d)
{
_______________
department=d;
}
}
下面表达式中，哪个可以加到构造方法中的“”处
A．person(n) B。this(person(n) C．this(n) D。this(n,a);
13．下面程序在fun（）方法运行正常下的输出结果是：（D ）
public void test()
{try
{fun();
System.out.print(“情况1”);
}catch(ArrayIndexOutOfBoundsException e)
{ System.out.print(“情况2”);
}
catch(Exception e)
{ System.out.print(“情况3”);
}
finally{ System.out.print(“finally”);
}
}
A．情况1 B。情况2 C。情况3 D情况1finally
14．下面程序运行后，正确的显示界面是：（A ）
import java.awt.;
import java.applet.Applet;
public class awt6 extends Applet
{
CardLayout card=new CardLayout();
Button b[]=new Button[5];
public void init()
{
setLayout(card);
for(int i=0;i<=4;i++)
{
b[i]=new Button(“卡片号为：”+i);
add(String.valueOf(i),b[i]);
}
}
}
A． B。
C． D。
15．下面程序填空正确的是：（B）
import java.awt.;
import java.applet.Applet;
import java.awt.event.*;
public class action1 extends Applet _____________
{
Button b1=new Button(“press me”);
Label l1=new Label("提示信息栏 ");
public void init()
{
setLayout(new FlowLayout(FlowLayout.LEFT,5,20));
add(b1);
add(l1);
b1.addActionListener(this);
}
public void actionPerformed(ActionEvent e)
{
l1.setText(“button1 clicked”);}}
A．implements ActionEvent B. implements ActionListener
C. ,ActionListener D extends ActionEvent

1．下面关于Java语言说法错误的是：（ B ）
A．java语言是完全面向对象的 B。java语言支持多继承
C．java语言支持多线程 D。java语言最早是为消费电子产品领域设计的
2．下面标识符中正确的是：（ D ）
A．123 B。12java C．continue D。java$next
3．下列关于注释语句的描述中，正确的一项是（D ）
A。以//开始的是多行注释语句
B。以/开始，/结束的是单行注释语句
C。以/**开始，/结束的是可以用于生成帮助文档的注释语句
D。以/**开始，/结束的是单行注释语句
4．为了区分重载多态中同名的不同方法，要求（A）。
A） 形式参数个数或者类型不同 B） 返回值类型不同
C） 调用时用类名或对象名做前缀 D） 形式参数名称不同
5．下面定义数组的格式中正确的是：（C ）
A．int a[10] B。int a=new int[10] C．int []a=new int[5] D.int a[]
6．下面说法中不正确的是：（ C ）
A．类是对象的抽象，对象是类的实例 B。类是组成java程序的最小的单位
C．java语言支持多继承 D。java一个程序中只能有一个public类
7．定义类时，不可能用到的保留字是（ A ）。
A） private B） class
C） extends D） implements
8．为 AB 类的定义一个公共的构造函数，该方法头的形式为（ D ）
A．void AB( ) B。public void method( )
C．public method ( ) D。public AB( )
9．下面说法中不正确的是：（A）
A．java中一个类只允许实现一个接口 B。抽象类中允许有非抽象方法的存在
C．类变量（实例变量）可以直接用类名调用 D。通过super可以调用基类的构造函数
10．容器JFrame 默认使用的布局编辑策略是（ A ）
A．BorderLayout B。FlowLayout C。GridLayout D。CardLayout
11．以下哪个表达式是不合法的（ B ）
A．String x=“Hello”; int y=9; x+=y;
B．String x=“Hello”; int y=9; if(x= =y) { }
C．String x=“Hello”; int y=9; x=x+y;
D．String x=null; int y=(x!=null)&&(x.length()>0)
12．class person
{
public int addvalue(int a,int b)
{
int s;
s=a+b;
return s;
}
}
class child extends parent
{
}
若要在child类中对addvalue方法进行重写，下面对于child类中的addvalue方法头的描述哪个是正确的：(A)
A）int addvalue(int I,int j) B）void addvalue()
C）void addvalue(double i) D）int addvalue(int a)
13．下面程序在fun（）方法当出现数组下标超过界限的情况下的输出结果是：（ C ）
public void test()
{try
{fun();
System.out.print(“情况1”);
}catch(ArrayIndexOutOfBoundsException e)
{ System.out.print(“情况2”);
}
catch(Exception e)
{ System.out.print(“情况3”);
}
finally{ System.out.print(“finally”);
}
}
A．情况1 B。情况2 C。情况2finally D情况3finally
14．下面程序运行后，正确的显示界面是：（B ）
import java.awt.;
import java.applet.Applet;
public class awt6 extends Applet
{
GridLayout card=new GridLayout();
Button b[]=new Button[4];
public void init()
{
setLayout(card);
for(int i=0;i<4;i++)
{
b[i]=new Button(“卡片号为：”+i);
add(b[i]);
}
}
}
A． B。
C． D。
15．下面程序填空正确的是：（B）
import java.awt.;
import java.applet.Applet;
import java.awt.event.;
public class action1 extends Applet ________________________
{
Button b1=new Button(“press me”);
Label l1=new Label("提示信息栏 ");
public void init()
{
setLayout(new FlowLayout(FlowLayout.LEFT,5,20));
add(b1);
add(l1);
b1.addActionListener(this);
}
public void actionPerformed(ActionEvent e)
{
l1.setText(“button1 clicked”);}}
A．implements ActionEvent B. implements ActionListener
C. ,ActionListener D extends ActionEven
什么叫方法的重载？
答:①一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同（方法的重载体现了多态性，即功能多态性）。
②构造方法可以重载。

2、分析下列程序得出输出结果。
public class E3_1
{ public static void main( String args[] )
{ char x= ‘你’,y= ’ e’,z= ‘他’;
if(x>’A’)
{ y= ‘叫’ ;
Z= ‘呼’ ;
}
else
y= ‘我’;
z=‘她’;
System.out.println(" "+x+y+z) ;
}
}
你叫她

11、分析下列程序得出输出结果。
class E6_1
{ public static void main(String args[])
{ String s1,s2;
s1=new String(“we are students”);
s2=new String(“we are students”);
System.out.println(s1.equals(s2));
System.out.println(s1s2);
String s3,s4;
s3=“how are you”;
s4=“how are you”;
System.out.println(s3.equals(s4));
System.out.println(s3s4);
}
}
true
false
true
true

12、分析下列程序得出输出结果。
class Fibi
{ public static long fibinacii(int n)
{ long c=0;
if(n1||n2)
c=1;
else
c=fibinacii(n-1)+fibinacii(n-2);
return c;
}
}
public class E6_2
{ public static void main(String args[])
{ System.out.println(Fibi.fibinacii(6));
}
}

13．阅读程序段，回答问题:
public class ClassA{
public void method1(int i){}
public void method2(int i){}
public static void method3(int i){}
public static void method4(int i){}
}
public class ClassB extends ClassA{
public static void method1(int i){}
public void method2(int i){}
public void method3(int i){}
public static void method4(int i){}
}
ClassB中（method1、method2、method3、method4）四个方法，方法 覆盖了父类方法；方法 隐藏了父类方法。

程序填空题

１.下列程序中，指定变量b=50为字节类型，变量f=0.55F为单精度实型，变量1=0xfffL为64位整型，并将该三个变量打印输出.请将程序补充完整.
2．模板代码
import java.io.*;
public class Assign}
　　public static void main(String args[]){
　　　　【代码1】 b=50;
　　　　【代码2】 f=0.55F;
　　　　【代码3】 l=0xfffL;
　　　　System.out.println(“b=”+b);
　　　　System.out.println(“f=”+f);
　　　　System.out.println(“l=”+l);
　　}
}

多态
2．模板代码
abstract class 动物{ //声明一个抽象类
abstract void cry();
}
class 狗 extends 动物
{ void cry()
{ System.out.println(“汪汪…”);
}
}
class 猫 extends 动物
{ System.out.println(“，喵喵~~~~”);//重写猫的cry方法
}
class Example4_20
{ public static void main(String args[])
{ 动物 dongwu;
dongwu=new 狗();
dongwu.cry();//用dongwu对象来使用狗的cry方法；
dongwu=new 猫();
dongwu.cry();//用dongwu对象来使用猫的cry方法；
}
}

接口回调
2．模板代码
【代码1】 ShowMessage //声明一个接口
{ void 显示商标(String s);
}
class TV implements ShowMessage
{ 【代码2】 //重写TV的"显示商标"输出方法
}
class PC implements ShowMessage
{ public void 显示商标(String s)
{ System.out.println(s);
}
}
public class Example4_27
{ public static void main(String args[])
{ ShowMessage sm;
【代码3】//用sm对象来使用TV的"显示商标"方法，输出"长城牌电视机"内容；
【代码4】//用sm对象来使用PC的"显示商标"方法，输出"联想奔月5008PC机"内容；
}
}

1、下列哪个是Java应用程序主类中正确的main方法（D ）。
A、public void main(String args[]) B、static void main(String args[])
C、public static void main(String args) D、public static void main(String args[])
2、下列哪个是JDK提供的编译器（ B）。
A、java.exe B、javac.exe C、javap.exe D、javaw.exe
3、下列那个可以作为Java标识符（D ）。
A、boy-girl B、2int_ long C、byte D、$Boy
4、正则表达式 ([0-9]{3})-([a-z]{3})-([a-z]*?ab) 与下列哪个字符串相匹配（ D）。
A、123-abc{3}-cab B、123{3}-abc-cab C、123-abc-cb D、123-abc-ccab
5、下列那个类的声明是错误的（A ）。
A、final abstract class A B、final class A
C、abstract class A D、public class A
6、下列叙述那个是正确的（ A）。
A、final 类不可以有子类
B、abstract类中只可以没有abstract方法
C、abstract类中可以有非abstract方法，但该方法不可以用final修饰
D、可以同是用final 和abstract修饰一个方法
7、下列叙述那个是错误的（ C）。
A、String类是final类，不可有子类 B、String类在java.lang包中
C、“abc”==“abc"的值是false D、“abc”.equals(“abc”)的值是ture
8、下列叙述那个是正确的（ B）。
A、Frame类对象的默认的布局是FlowLayout布局
B、Panel类对象的默认的布局是FlowLayout布局
C、Button类的直接父类是Container
D、TextField对象可以触发ItemEvent事件
9、假设组建com的宽和高分别为w和h，要讲组件的中心放置在(x,y)坐标点上，请问下列那个是正确的放置方法（ A）。
A、com.setLocation(x-w/2,y-h/2) B、com.setLocation(x,y)
C、com.setLocation(x-w,y-h) D、com.setLocation(x+w/2,y+h/2)
10、下列叙述那个是正确的（ A）。
A、任何组件都可以触发MouseEvent事件
B、处理WindowEvent事件的接口是FocusListener
C、java.awt.event.MouseAdapter类实现了ActionListener接口
D、java.awt.event.WindowAdapter是一个接口
11、下列那个类创建的对象可以触发ActionEvent事件（ C）。
A、java.awt.Button类 B、java.awt.color类
C、java.util.Date类 D、java.lang.StringBuffer类
12、下列那个类创建的对象可以触发FocusEvent事件（B ）。
A、java.awt.color类 B、java.awt.TextField类
C、java.util.Date类 D、java.lang.StringBuffer类
13、下列叙述那个是正确的（A ）。
A、无模式对话框处于激活状态时，程序仍能激活它所依赖的窗口或组件
B、有模式对话框处于激活状态时，程序仍能激活它所依赖的窗口或组件
C、无模式对话框不可以添加按钮组件
D、有模式对话框不可以添加按文本框组件
14、以下哪一个包是默认导入到Java类当中的（A ）
A、java.lang B、java.io C、java.net D、java.long
15、对于以下类（ D）
public class Q2{
public static void main(String[] args){
method();
}
private static void method(){
System.out.println(“Hello”);
}
}
A、编译失败,行3错误。 B、编译失败，行5错误。
C、编译通过，无运行结果。 D、打印Hello。
16、以下哪个是不正确的标识符（D ）
A、Abc3 B、a_bc_3 C、_3abc D、3_abc
17、局部变量boolean的默认值为：D
A、false B、true C、null D、无默认值，必初始化
18、对于Person p = new Person();，以下哪个能编译通过（ C）
A、Object o = new Object§; B、p = new Object();
C、boolean b = p instanceof Object; D、boolean b = Object instanceof p;
19、对于以下代码，运行的结果是（C ）
public class Q6{
int a=1;
public static void main(String[] args){
i++;
++i;
System.out.println(i);
}
}
A、2 B、3 C、编译出错 D、运行出错
20、对于boolean b = (2>=1 || 2/0>=0)；b的结果为（C ）
A、false B、运行出错，2/0抛出被0除错误
C、true D、null
21、以下能编译通过的for循环是（C ）
A、for(int a,int b;a<100;a++){} B、for(int a=0,int b = 0;a<100;😉{}
C、for(int a=0,b=100;a<50;a++,b–){}
D、for(int a=0,b=100;a<50,b>50;a++,b–){}
22、对于方法public void a(int a,String b){}以下哪一个是它正确的重载方法（C ）
A、public int a(int a,String b){} B、protected void a(int a,String b){}
C、public int a(int a,String[] b){} D、public static void a(int a,String b){}
23、以下哪一个不是受检查的异常类（C ）
A、SQLException B、FileNotfoundException
C、NullPointerException D、IOException
24、将一个对像序列化的方式是，使此类实现以下哪一个接口（ B）
A、Cloneable B、Serializable
C、File D、Exception
25、启动一个线程应使用线程类的（B ）
A、run() B、start()
C、go() D、thread()
26、以下哪一个是正确初始化数组的方式（C ）
A、int[1] a = new int[1]{1}; B、int[] a = new int[1]{1};
C、int[] a = new int[]{1}; D、int[1] a = new int[1];
27、以下代码输出的结果是：D
public class Q14{
int a = 20;
static{
int a = 10;
}
public static void main(String[] args){
Q14 q14 = new Q14();
System.out.println(q14.a);
}
}
A、编译出错，变量a重复定义 B、运行出错，q14.a不能确定是哪个变量a
C、打印10 D、打印20。
28、以下代码编译/运行结果为（ C）
public class Q15{
public static void main(String[] args){
int i=10;
int j = 10;
boolean b = false;
if(b= i = = j){ //行6
System.out.println(“true”);
}else{
System.out.println(“false”);
}
}
A、在第6行编译出错 B、在第6行运行出错
C、打印true D、打印false
29、对于以下代码，哪个能编译通过（ C）
public interface Animal{}
public class Dog implements Animal{}
public class Cat implements Animal{}
A、Dog dog = new Cat(); B、Cat cat = new Animal();
C、Animal cat = new Dog(); D、Cat c = new Cat(); Dog d = (Dog)c;
30、对于以下类，那一行是正确的方法覆盖（ D）
public class Q17{
public void method(int a) throws Exception{}
}
public class Q17_A{
//在此输入正确的一行，
}
A、void method(int a){} B、void method(String a){}
C、public int method(int a){} D、public void method(int a) throws IOException{}
31、以下代码输出的值为（ B）
public class Q18{
Boolean[] boo = new Boolean[1];
Q18(){
System.out.println(boo[0]);
}
public static void main(String[] args){
new Q18();
}
}
A、false B、null C、true D、运行出错
32、对于以下代码,运行结果为，即a的值为（A ）
HashMap map = new HashMap();
map.put(“a”,“Hello”);
map.put(“a”,“World”);
String a = map.get(“a”);
A、最后一行编译出错 B、最后一行运行出错。
C、a的值为Hello D、a的值为World
33、以下哪个是jsp声明（ B）
A、<%= %> B、<%! %> C、<% %> D<%@ %>
34、在web项目的Filter中，通过以下哪个方法能获取web.xml配置的初始化参数（B ）
A、doFilter B、init C、destory D、service
35、在web项目中，日志级别由高到低为（C ）
A、ERROR，FATAL，INFO，WARN，DEBUG
B、FATAL，ERROR，INFO，WARN，DEBUG
C、FATAL，ERROR，WARN，INFO，DEBUG
D、WARN，ERROR，FATAL，INFO，DEBUG
36、以下代码运行结果为（ ）
public class ForBar{
public static void main(String[] args) {
int i=0,j=5;
tp: for( ; ; i++) {
for ( ; ; --j)
if (i>j) break tp;
}
System.out.println(“i=”+i+”,j=“+j);
}
}
A、程序可以运行并打印"i=1, j=-1”
B、程序可以运行并打印"i=1, j=4"
C、程序可以运行并打印"i=0, j=-1"
D、第4行有个错误导致编译失败
24、哪个事件类标识基于一个java.awt.component的按键动作? （A ）
A、KeyEvent
B、KeyDownEvent
C、KeyPressEvent
D、KeyTypedEvent
25、如何得到文件"file.txt"的父目录名字? （B）
A、String name=File.getParentName(“file.txt”);
B、String name=(new File(“file.txt”)).getParent();
C、String name=(new File(“file.txt”)).getParentName();
D、String name=(new File(file.txt)).getParentFile();
26、以下哪一个是正确处理事务的开始(conn是Connection对像的变量)：（A ）
A、conn.setAutoCommit(false); B、conn.autoCommit = false;
C、conn.setCommit(false); D、conn.rollback();
27、以下哪一个是ant中，将java文件编译成class文件的内置任务：（C ）
A、java B、complier C、javac D、mkclass
28、以下哪一个是正确的将自定义标签导入到jsp页面上：（B ）
A、<%@ page uri=“/aa.tld” prefix=“aa”%>
B、<%@ taglib uri=“/aa.tld” prefix=“aa”%>
C、<%@ include uri=“/a.tld” prefix=“aa”%>
D、<% taglib uri=“/a.tld” prefix=“aa”%>
29、jsp页面上有以下语句<% request.setAttribute(“hello”,“HelloWorld”);%>，取出并正确输出到页面的方法为（C ）
A、<% String hello = request.getAttribute(“hello”)； out.print(hello)；%>
B、<% String hello = request.getParameter(“hello”)；out.print(hello)；%>
C、<% String hello = (String)request.getAttribute(“hello”)； out.print(hello)；%>
D、<%=request.getAttribute(“hello”)； %>
30、以下是一段javascript脚本，请问最后i的值是多少：（ B）
function abc(){
for(var i=0;i<10;i++){
}
alert(i); //此处i的值是多少?
}
A、 运行出错，因为i在for之外不能访问
B、 提示10 C、提示11 D、提示null或是undefained
31、PreparedStatement或是Statement执行批处理executeBatch()后返回以下哪种数据类型：（ C）
A、int类型 B、boolean类型 C、int[]类型 D、void类型
32、看以下代码，说出结果（B ）
public void a() throws Exception{
try{
int a = 0;
int b = 0;
int c = a/b; （行5）
}catch(Exception e){
e.printStackTrace();
}
}
A、编译出错，不能try与throws共同使用 B、运行出错在第5行
C、不打出任何结果 D、运行不出错。也不出结果。
33、以下代码（ B）
public void a(){
try{
int a = 0/0; //行3
}catch(Exception e){//行4
System.err.println(“error”);//出错,行5
}catch(ArithmeticException e){//行6
System.err.println(“/ by zero”);//被0除错误,行7
}
}
A、编译出错在第4行。 B、编译出错在第6行。
C、编译通过，打出errro D、编译通过，打出/ by zero.
34、以下程序运行的结果为（ C）
public void abc(){
try{
return;
}catch(Exception e){//行4
}finally{
System.err.println(“finally”);//行6
}
}
A、编译出错在第4行。 B、运行不打出任何结果
C、运行打出finally D、编译出错在第6行。
35、垃圾回收的时间说哪个正确（ C）
A、System.gc()时执行 B、Runtime.getRuntime().gc()时执行
C、不确定 D、CPU空闲时执行
36、当子类中的内部类与父类中的内部类同名时（D ）
A、子类复盖了父类的内部类 B、编译出错
C、运行出错 D、各自拥有自己的内部类，互不影响
37、对于以下代码，运行打印什么结果（ D）
class RunHandler{
public void run(){
System.out.println(“run”);
}
}
public class Tester{
public static void main(String[] args){
Thread t = new Thread(new RunHandler());
t.start();
}
}
A、打印run B、不打印任何内容 C、运行出错 D、编译出错
38、创建FileChannel的方式，以下哪一个是正确的（ C）
A、FileChannel f = new FileChannel()
B、FileChannel f = FileChannel.getChannel();
C、FileChannel f = new InputStream(“d:/a.txt”).getFileChannel();
D、FileChannel f = new FileOutputStream(“d:/a.txt”).getChannel();
39、取消JFrame frame = new JFrame()的默认布居管理器的方式是（C ）
A、frame.setLayout(“”); B、frame.setLayout(“none”);
C、frame.setLayout(null); D、frame.deleteLayout();
40、以下哪一个是正确了使用BigDecimal b = new BigDecimal(10)对像的加方法（ C）
Ａ、b = b +10 B、b = b.add(10)
Ｃ、b = b.add(new BigDecimal(10); D、b +=10;
41、JFrame是以下哪个类的子类：B
A、JComponent B、Frame C、JPanel D、JApplet
42、继承使用（ ）关键字，实现一个接口，使用（B ）关键字？
A、implements、extends B、extends、implements
C、extends、static D、implements、abstract
43、方法public void abc(int a){}，以下哪一个是它的重载方法（C ）
A、private void a(){}
B、private int abc(int a){}
C、public int abc(int a,String name){}
D、private void abc(int a){}
44、局部变量可以被下列哪一个修饰（ C ）
A、public B、synchronized
C、final D、native
45、double d = 0.0/0 的结果是：（D ）
A、正无穷大 B、不能编译 C、运行出错 D、NaN
46、声明成员变量：public final String name;后，直接输出，结果为：（ A）
A、null B、NULL C、空 D、编译出错
47、接口当中，所有的成员变量默认都是（C ）
A、public abstract类型 B、public abstract final类型
C、public static final类型 D、private类型
48、接口中的方法默认都是：（ C）
A、protetcted类型。 B、public abstract final类型。
C、public abstract类型 D、protected abstract类型
49、在子类中，声明了同父类相同名称的成员变量，此时要引用父类的成员变量，可以使用关键字：（ C ）
A、this B、abstract C、super D、parent
50、在一个接口当中，只定义很多常量，不包含任何的方法，这种模式叫做：（ B ）
A、代理模式 B、常量接口模式 C、标识模式 D、适配器模式
判断题
1、类中实例变量在声明（创建、赋值、使用）时候会被分配内存空间。（）
2、类中的实例方法可以操作类变量（static变量）。（）
3、类方法（static方法）可以操作类实例变量。（）
4、类中的实例方法可以用类名直接调用。（）
5、类方法可以用类名直接调用。（）
6、子类在声明一个与父类成员变量名字相同的成员变量时隐藏了父类的成员变量。（）
7、子类在声明一个与父类方法名字、类型、参数相同的方法时隐藏了父类的方法。（）
8、在子类中允许有一个方法和父类的方法名字相同，而类型不同的方法。（）
9、父类的final方法可以被子类重写。（）
10、子类一定要重写父类中的abstract方法。（）
11、Frame类对象的默认布局是BorderLayout。（）
12、Panel类对象的默认布局是FlowLayout。（）
13、一个容器对象可以使用add方法添加一个Frame窗口。（）
14、Checkbox对象可以触发ItemEvent事件。（）
15、一个线程执行完run()方法后，该线程还能再调用start()方法。（ ）
16、线程处于新建、死亡状态时，调用isAlive()方法返回的值是false。（ ）
17、线程处于运行、中断状态时，调用isAlive()方法返回的值是false。（ ）

1、Java的类不允许多重继承，但接口支持多重继承。（ ）。
2、在Java的方法中定义一个常量要用const关键字。（ ）。
3、在一个Java源程序文件中，只能有一个main方法。（ ）。
4、在一个Java源程序文件中，可以有多个public类。（ ）。
5、基本数据类型没有Class对象。（ ）。
6、Java中一个类型所对应的Class对象可以有多个。（ ）。
8、使用方法length( )可以获得字符串或数组的长度。（ ）。
9、Java的字符类型采用的是Unicode编码。（ ）。
10、Java中数组的元素可以是简单数据类型的量，也可以是某一类的对象。（ ）。
简答题
1、java程序由什么组成的？一个程序中必须要有public类吗？java源文件的命名规则是怎样的？
答： ①Java程序由类组成。
②应用程序可以没有public类；小应用程序一定有一个类是public类（主类）。
③应用程序:如果只有一个类，源文件名与该类的类名相同，拓展名为.java；
有多个类时，如果有public类（最多一个）,源文件名与public类的类
名相同，拓展名是.java；没有public类，源文件名与任何一个类的类名
相同即可，拓展名为.java。
小应用程序:源文件名与主类的类名相同，拓展名是.java。

2、什么叫标识符，标识符的规则是什么？
答：①用来标识类名、变量名、、方法名、类型名、数组名、文件名的有效字符序列。
②由字母、下划线、美元符号和数字组成，并且第一个字符不能是数字字符，而且关键字不能作为标识符。

３、Java的基本数据类型都是什么？
答：boolean(逻辑型) char(字符型) float、double(浮点型) byte、short、int、long(整型)。

４、什么叫方法的重载？
答:①一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同（方法的重载体现了多态性，即功能多态性）。
②构造方法可以重载。

５、什么叫对象的上转型对象？
答: B类是A类的子类或间接子类，当用子类B创建一个对象b并把这个对象的引用放到A类的对象a中时，称A类对象a是子类对象b的上转型对象。

６、什么叫接口的回调？
答: 可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中。

７、在类的继承过程中，子类将继承父类的哪些成员变量和方法？子类在什么情况下隐藏父类的成员变量和方法？
答:①子类和父类在同一个包中时，子类可以继承父类的除private属性的所有方法和成员变量，当子类与
父类不在同一个包中时，子类只能继承父类的protected和public属性的成员变量和方法。
②子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量；子类中定义一个方法，并且这个方法的名字、返回类型、参数个数和类型与从父类继承的方法完全相同，子类就隐藏从父类继承来的方法（方法的重写）。
③在子类中允许有一个方法和父类的方法名字相同而类型不同。

８、线程有几种状态？
答: 一个线程在它的一个完整的生命周期有4种状态，分别是：新建、运行、中断和死亡,即(运行、就绪、挂起、结束)。

９、引起线程中断的常见原因是什么？
答: ①JVM将CPU资源从当前线程切换给其他线程，使本线程让出CPU的使用权处于中断状态；
②线程使用CPU资源期间，执行了sleep(int millsecond)方法，使当前线程进入休眠状态；
③线程使用CPU资源期间，执行了wait()方法，使得当前线程进入等待状态；
④线程使用CPU资源期间，执行某个操作进入阻塞状态，比如执行读/写操作引起阻塞。

１０、建立线程有几种方法，是那几种？
答:①用Thread类直接创建一个线程；创建时要向构造方法Thread(Runnable target)传递一个Runnable接口的实例。
②用Thread类的子类创建一个线程；需要重写父类的run()方法。

１１、线程调用interrupt()的作用是什么？
答: interrupt()方法用来“吵醒”休眠的线程。即: 它所完成的是当线程处于阻塞状态时，抛出InterruptedException异常，使其从阻塞状态退出来。注: interrupt()方法不会中断一个正在运行的线程。

12．Java语言的特点？
简单 面向对象 与平台无关 解析型 多线程 安全 动态

程序改错：
public class Fuxi{
public static void main(String args[]){
int i=1,j;
float f1=0.1, float f2=123;
long l1=12345678,l2=8888888888;
double d1=2e20,d2=124;
byte b1=1,b2=2,b3=129;
j=j+10;
i=i/10;
i=i0.1;
char c1=‘a’,c2=125;
byte b=b1-b2;
float f3=f1+f2;
float f4=f1+f20.1;
double d=d1i+j;
float f=(float)(d15+d2);
}
}
程序设计题 ：
1、设计一个程序实现一下功能：从键盘读取一个数据，将该数据转换成double类型并打印输出，如果从键盘读取的这个数据转换成double型时发生异常则打印输出“该数据不是double型数据！”。
2、编写程序实现1+3+5+……+99，并将结果打印输出。
3、从键盘输入一串字符串，分别输出字符串中的每个单词，并统计单词总个数。
程序分析题
1、分析下列程序得出输出结果。
public class E2_1
{ public static void main( String args[] )
{ long[] a={1,2,3,4};
long[] b={100,200,300,400,500};
b=a;
System.out.println(“数组b的长度：”+b.length) ;
System.out.println(“b[0]=”+ b[0]) ;
}
}
数组b的长度：4
b[0]=1

2、分析下列程序得出输出结果。
class Chengji
{ float f(float x,float y)
{ return x*y;
}
}
class Xiangjia extends Chengji
{ float f(float x,float y)
{ return x+y ;
}
}
public class Example4_16
{ public static void main(String args[])
{ Xiangjia sum;
sum=new Xiangjia();
float c=sum.f(4,6);
System.out.println©;
}
}

10.0

3、分析下列程序得出输出结果。
public class E3_2
{ public static void main( String args[] )
{ char c=‘\0’;
for(int i=1;i<=4;i++)
{ switch(i)
{ case 1: c=‘b’;
System.out.print ©;
case 2: c=‘e’;
System.out.print ©;
break;
case 3: c=‘p’;
System.out.print ©;
default: System.out.print (“!”);
}
}
}
}
beep!!

4、分析下列程序得出输出结果。
class A4_1
{ int x;
public void setX( int x )
{ this.x=x;
}
public int getX()
{ return x;
}
}
class B4_1
{ public void f(A4_1 a)
{ a.setX(100);
}
}
public class E4_1
{ public static void main( String args[] )
{ A4_1 a=new A4_1();
a.setX(8);
System.out.println(a.getX());
B4_1 b=new B4_1();
b.f(a);
System.out.println(a.getX());
}
}

8
100

5、分析下列程序得出输出结果。
class A4_2
{ int x=100,y=200;
public void setX( int x )
{ x=x;
}
public void setY( int y )
{ this.y=y;
}
public int getXYSum()
{ return x+y;
}
}
public class E4_2
{ public static void main( String args[] )
{ A4_2 a=new A4_2();
a.setX(-100);
a.setY(-200);
System.out.println(“sum=”+a.getXYSum());
}
}

sum=-100

6、分析下列程序得出输出结果。
class A4_3
{ int n;
static int sum=0;
public void setN( int n )
{ this.n=n;
}
public int getSum()
{ for(int i=1;i<=n;i++)
sum=sum+i;
return sum;
}
}
public class E4_3
{ public static void main( String args[] )
{ A4_3 a1=new A4_3(),a2=new A4_3();
a1.setN(3);
a2.setN(5);
int s1=a1.getSum();
int s2=a2.getSum();
System.out.println(s1+s2);
}
}

27

7、分析下列程序得出输出结果。
class A4_4
{ public int f( int x )
{ return x+1;
}
}
class B4_4 extends A4_4
{ public int f( int x )
{ return x*x;
}
}
public class E4_4
{ public static void main( String args[] )
{ A4_4 a=new B4_4();
int m=a.f(10);
System.out.println(m) ;
}
}

100

8、分析下列程序得出输出结果。
class A4_5
{ double f(double x,double y )
{ return x+y;
}
static int g(int n )
{ return nn;
}
}
class B4_5 extends A4_5
{ double f(double x,double y )
{ double m=super.f(x,y);
return m+xy;
}
static int g(int n )
{ int m=A 4_5.g(n) ;
return m+n;
}
}
public class E4_5
{ public static void main( String args[] )
{ B4_5 b=new B4_5();
System.out.println(b.f(10.0,8.0)) ;
System.out.println(b.g(3)) ;
}
}

98.0
12

9、分析下列程序得出输出结果。
class Example5_4
{ public static void main(String args[])
{ String path=“c:\myfile\pack\result.txt”;
int index=path.lastIndexOf(“\”);
String fileName=path.substring(index+1);
String newName=fileName.replaceAll(“.txt”,“.doc”);
System.out.println(path);
System.out.println(fileName);
System.out.println(newName);
}
}

c:\myfile\pack\result.txt
result.txt
result.doc

10、分析下列程序得出输出结果。
public class E5_1
{ public static void main( String args[] )
{ String s=“xx大学xx学院”;
char a=s.charAt(2),b=s.charAt(6);
System.out.print (a);
System.out.println(b);
}
}

大学

11、分析下列程序得出输出结果。
import java.util.*;
public class E5_2
{ public static void main( String args[] )
{ int a[]={23,67,89,90,-987};
double b[]={12.89,90.87,34,678.987,-98.78,0.89};
Arrays.sort(a);
Arrays.sort(b,1,4);
for(int i=0;i<=4;i++)
{ System.out.print (a[i]+ “,”);
}
System.out.println(“”);
for(int i=0;i<=b.length-1;i++)
{ System.out.print (b[i]+ “,”);
}
}
}

-987,23,67,89,90,
12.89,34.0,90.87,678.987,-98.78,0.89,

12、分析下列程序得出输出结果。已知计算机D：\chapter9目录下有A .java、chapter.txt、B.java三个文件
import java.io.*;
class FileAccept implements FilenameFilter
{ String str=null;
FileAccept(String s)
{ str=“.”+s;
}
public boolean accept(File dir,String name)
{ return name.endsWith(str);
}
}
public class Example10_2
{ public static void main(String args[ ])
{
try{
File dir=new File(“d:\chapter9”);
if(!dir.exists())dir.mkdir();
File deletedFile=new File(dir,“E.java”);
if(!deletedFile.exists())deletedFile.createNewFile();
FileAccept acceptCondition=new FileAccept(“java”);
File fileName[]=dir.listFiles(acceptCondition);
for(int i=0;i< fileName.length;i++)
{ System.out.println(“文件名称:”+fileName[i].getName());
}
boolean boo=deletedFile.delete();
if(boo)
{ System.out.println(“文件:”+deletedFile.getName()+“被删除”);
}
}catch(IOException e){}
}
}

文件名称:E.java
文件:E.java被删除

程序填空题
输出希腊字母表
模板代码
GreekAlphabet.java
public class GreekAlphabet
{
public static void main (String args[ ])
{
int startPosition=0,endPosition=0;
char cStart=‘α’,cEnd=‘ω’;
startPosition=(int)cStart; //cStart做int型转换据运算，并将结果赋值给startPosition
endPosition=(int)cEnd ; //cEnd做int型转换运算，并将结果赋值给endPosition
System.out.println(“希腊字母’α’在unicode表中的顺序位置:”+(int)c);
System.out.println(“希腊字母表：”);
for(int i=startPosition;i<=endPosition;i++)
{
char c=‘\0’;
c=(char)i; //i做char型转换运算，并将结果赋值给c
System.out.print(" "+c);
if((i-startPosition+1)%100)
System.out.println(“”);
}
}
}
以下程序功能是两个线程共同完成1+2+3+……+10，一个线程计算完1+2+3+4+5后启动另一个线程，根据提示（【代码X】）完成程序填空，代码模板如下： ( 6分)
class Example9_7
{ public static void main(String args[ ])
{ ComputerSum2 sum=new ComputerSum2();
sum.computer1.start();//启动sum中的computer1线程
}
}
class ComputerSum2 implements Runnable
{
Thread computer1,computer2;
int i=1,sum=0;
ComputerSum2()
{ computer1=new Thread(this);
computer2=new Thread(this);//初始化两个线程 }
public void run()
{ while(i<=10)
{ sum=sum+i;
System.out.println(sum);
i++;
if(i6&&Thread.currentThread()computer1)
{ System.out.println(computer1.getName()+“完成任务了！”);
computer2.start(); //启动另外一个线程
return;
}
}
}}
猜数字游戏
模板代码
GuessNumber.java
import javax.swing.JOptionPane;
public class GuessNumber
{
public static void main (String args[ ])
{
System.out.println(“给你一个1至100之间的整数,请猜测这个数”);
int realNumber=(int)(Math.random()100)+1;
int yourGuess=0;
String str=JOptionPane.showInputDialog(“输入您的猜测:”);
yourGuess=Integer.parseInt(str);
while(yourGuess!=realNumber) //循环条件
{
if(yourGuess>realNumber ) //条件代码
{
str=JOptionPane.showInputDialog(“猜大了,再输入你的猜测:”);
yourGuess=Integer.parseInt(str);
}
else if(yourGuess<realNumber) //条件代码
{
str=JOptionPane.showInputDialog(“猜小了,再输入你的猜测:”);
yourGuess=Integer.parseInt(str);
}
}
System.out.println(“猜对了!”);
}
}
Java数据库
import java.sql.;
public class Example15_1
{ public static void main(String args[])
{ Connection con;
Statement sql;
ResultSet rs;
try { Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
}
catch(ClassNotFoundException e)
{ System.out.println(“”+e);
}
try { con=DriverManager.getConnection(“jdbc:odbc:sun”,“gxy”,“123”);
sql=con.createStatement();
rs=sql.executeQuery(“SELECT * FROM chengjibiao”);
while(rs.next())
{ String number=rs.getString(1);
String name=rs.getString(2);
String date=rs.getString(3);
int math=rs.getInt(“math”);
int english=rs.getInt(“english”);
System.out.print(“学号：”+number);
System.out.print(" 姓名：“+name);
System.out.print(” 出生：“+date);
System.out.print(” 数学：“+math);
System.out.println(” 英语：“+english);
}
con.close();
}
catch(SQLException e)
{ System.out.println(e);
}
}
}
实例成员与类成员
模板代码
Example.java
class A
{
float a; //声明一个float型实例变量a
static float b; //声明一个float型类变量b,即static变量b
void setA(float a)
{
this.a=a; //将参数a的值赋值给成员变量a
}
void setB(float b)
{
this.b=b; //将参数b的值赋值给成员变量b
}
float getA()
{
return a;
}
float getB()
{
return b;
}
void inputA()
{
System.out.println(a);
}
static void inputB()
{
System.out.println(b);
}
}
public class Example
{
public static void main(String args[])
{
A.b=100; //通过类名操作类变量b,并赋值100
A.inputB(); //通过类名调用方法inputB()
A cat=new A();
A dog=new A();
cat.setA(200); //cat象调用方法setA(int a)将cat的成员a的值设置为200
cat.setB(400); //cat调用方法setB(int b)将cat的成员b的值设置为400
dog.setA(150); //dog象调用方法setA(int a)将dog的成员a的值设置为150
dog.setB(300); //dog调用方法setB(int b)将dog的成员b的值设置为300
cat.inputA(); //cat调用inputA()。
cat.inputB(); //cat调用inputB()。
dog.inputA(); //dog调用inputA()。
dog.inputB(); //dog调用inputB()。
}
}
继承
模板代码
Example.java
class People
{
protected double weight,height;
public void speakHello()
{
System.out.println(“yayawawa”);
}
public void averageHeight()
{
height=173;
System.out.println(“average height:”+height);
}
public void averageWeight()
{
weight=70;
System.out.println(“average weight:”+weight);
}
}
class ChinaPeople extends People
{
public void speakHello()
{
System.out.println(“你好,吃饭了吗?”);
} //重写public void speakHello()方法，要求输出类似“你好，吃了吗”这样的
//汉语信息
public void averageHeight()
{
height=173;
System.out.println(“中国人的平均身高：”+height+“厘米”);
} //重写public void averageHeight()方法，要求输出类似
//“中国人的平均身高：168.78厘米”这样的汉语信息
public void averageWeight()
{
weight=67.34;
System.out.println(“中国人的平均体重：”+weight+“公斤”);
} //重写public void averageWeight()方法，
//要求输出类似“中国人的平均体重：65公斤”这样的汉语信息
public void chinaGongfu()
{
System.out.println(“坐如钟,站如松,睡如弓”);//输出中国武术的信息，例如：“坐如钟,站如松,睡如弓"等
}
}
class AmericanPeople extends People
{
public void speakHello()
{
System.out.println(“How do You do”);
} //重写public void speakHello()方法，要求输出类似
//“How do you do”这样的英语信息。
public void averageHeight()
{
height=188;
System.out.println(“Amerian Average height:”+height+” cm”);
} //重写public void averageHeight()方法
public void averageWeight()
{
weight=80.23;
System.out.println(“Amerian Average weight:”+weight+" kg");
} //重写public void averageWeight()方法
public void americanBoxing()
{
System.out.println(“直拳、钩拳”);//输出拳击的信息，例如，“直拳”、“钩拳”等
}
}
class BeijingPeople extends ChinaPeople
{
public void speakHello()
{
System.out.println(“您好”);
} //重写public void speakHello()方法，要求输出类似“您好”这样的汉语信息
public void averageHeight()
{
height=16;
System.out.println(“北京人的平均身高：”+height+“厘米”);
} //重写public void averageHeight()方法
public void averageWeight()
{
weight=6;
System.out.println(“北京人的平均体重：”+weight+“公斤”);
} //重写public void averageWeight()方法
public void beijingOpera()
{
System.out.println(“京剧术语”);//输出京剧的信息
}
}
public class Example
{
public static void main(String args[])
{
ChinaPeople chinaPeople=new ChinaPeople();
AmericanPeople americanPeople=new AmericanPeople();
BeijingPeople beijingPeople=new BeijingPeople();
chinaPeople.speakHello();
americanPeople.speakHello();
beijingPeople.speakHello();
chinaPeople.averageHeight();
americanPeople.averageHeight();
beijingPeople.averageHeight();
chinaPeople.averageWeight();
americanPeople.averageWeight();
beijingPeople.averageWeight();
chinaPeople.chinaGongfu();
americanPeople.americanBoxing();
beijingPeople.beijingOpera() ;
beijingPeople.chinaGongfu();
}
}
上转型对象
模板代码
HardWork.java
abstract class Employee
{
public abstract double earnings();
}
class YearWorker extends Employee
{
public double earnings()
{
return 50000.456;
} //重写earnings()方法
}
class MonthWorker extends Employee
{
public double earnings()
{
return 122300;
} //重写earnings()方法。
}
class WeekWorker extends Employee
{
public double earnings()
{
return 52500;
}//重写earnings()方法。
}
class Company
{
Employee[] employee;
double salaries=0;
Company(Employee[] employee)
{
this.employee=employee;
}
public double salariesPay()
{
salaries=0;
for(int i=0;i<employee.length;i++)
{
salaries=salaries+employee[i].earnings();
} //计算salaries。
return salaries;
}
}
public class HardWork
{
public static void main(String args[])
{
Employee[] employee=new Employee[20];
for(int i=0;i<employee.length;i++)
{
if(i%30)
employee[i]=new WeekWorker();
else if(i%31)
employee[i]=new MonthWorker();
else if(i%32)
employee[i]=new YearWorker();
}
Company company=new Company(employee);
System.out.println(“公司年工资总额:”+company.salariesPay());
}
}

接口回调
模板代码
Road.java
interface ComputerWeight
{
public double computeWeight();
}
class Television implements ComputerWeight
{ public double computeWeight()
{ return 45.5;
} //实现computeWeight()方法。
}
class Computer implements ComputerWeight
{ public double computeWeight()
{ return 65.5;
} //实现computeWeight()方法。
}
class WashMachine implements ComputerWeight
{ public double computeWeight()
{
return 145;
} //实现computeWeight()方法。
}
class Car
{ ComputerWeight[] goods;
double totalWeights=0;
Car(ComputerWeight[] goods)
{
this.goods=goods;
}
public double getTotalWeights()
{
totalWeights=0;
for(int k=0;k<goods.length;k++)
{
totalWeights=totalWeights+goods[k].computeWeight();
} //计算totalWeights
return totalWeights;
}
}
public class Road
{
public static void main(String args[])
{ ComputerWeight[] goodsOne=new ComputerWeight[50],
goodsTwo=new ComputerWeight[22] ;
for(int i=0;i<goodsOne.length;i++)
{ if(i%30)
goodsOne[i]=new Television();
else if(i%31)
goodsOne[i]=new Computer();
else if(i%32)
goodsOne[i]=new WashMachine();
}
for(int i=0;i<goodsTwo.length;i++)
{ if(i%30)
goodsTwo[i]=new Television();
else if(i%31)
goodsTwo[i]=new Computer();
else if(i%32)
goodsTwo[i]=new WashMachine();
}
Car 大货车=new Car(goodsOne);
System.out.println(“大货车装载的货物重量:”+大货车.getTotalWeights());
Car 小货车=new Car(goodsTwo);
System.out.println(“小货车装载的货物重量:”+小货车.getTotalWeights());
}
}
打开与保存文件
以下程序功能为使用文件对话框打开和保存文件，请根据提示（【代码X】）完成程序填空，代码模板如下：
import java.awt.;import java.io.;
import java.awt.event.*;
public class FileOpenAndSave
{ public static void main(String args[])
{ FileWindows win=new FileWindows();
}
}
class FileWindows extends Frame implements ActionListener
{ FileDialog filedialog_save,filedialog_load;//声明2个文件对话筐
MenuBar menubar;
Menu menu;
MenuItem itemOpen,itemSave;//声明打开与保存菜单项
TextArea text;
BufferedReader in;
FileReader file_reader;
BufferedWriter out;
FileWriter tofile;
FileWindows()
{ super(“带文件对话框的窗口”);
setSize(260,270);
setVisible(true);
menubar=new MenuBar();
menu=new Menu(“文件”);
itemOpen=new MenuItem(“打开文件”);
itemSave=new MenuItem(“保存文件”);
itemOpen.addActionListener(this);//对打开和保存菜单项目增加监听
itemSave.addActionListener(this);
menu.add(itemOpen);
menu.add(itemSave);
menubar.add(menu);
setMenuBar(menubar);
filedialog_save=new FileDialog(this,“保存文件话框”,FileDialog.SAVE);
filedialog_load=new FileDialog(this,“打开文件话框”,FileDialog.LOAD);
filedialog_save.addWindowListener(new WindowAdapter()
{public void windowClosing(WindowEvent e)
{ filedialog_save.setVisible(false);
}
});
filedialog_load.addWindowListener(new WindowAdapter()//对话框增加适配器
{public void windowClosing(WindowEvent e)
{ filedialog_load.setVisible(false);
}
});
addWindowListener(new WindowAdapter()
{public void windowClosing(WindowEvent e)
{ System.exit(0);}
});
text=new TextArea(10,10);
add(text,BorderLayout.CENTER);
}
public void actionPerformed(ActionEvent e) //当点击打开文件或保存文件菜单项时所做的处理
{ if(e.getSource()==itemOpen)
{ filedialog_load.setVisible(true);
text.setText(null);
String s;
if(filedialog_load.getFile()!=null)
{ try{ File file= new
File(filedialog_load.getDirectory(),filedialog_load.getFile());
file_reader=new FileReader(file);
in=new BufferedReader(file_reader);
//按行读取文件中数据并写入到text中，直到文件末尾
while((s=in.readLine())!=null)
text.append(s+‘\n’);
in.close();
file_reader.close();
validate();//组件的更新
}
catch(IOException e2){}
}
}
else if(e.getSource()==itemSave)
{ filedialog_save.setVisible(true);
if(filedialog_save.getFile()!=null)
{ try { File file=new
File(filedialog_save.getDirectory(),filedialog_save.getFile());
tofile=new FileWriter(file);
out=new BufferedWriter(tofile);
out.write(text.getText(),0,(text.getText()).length());//将text中的所有内容写入到要保存的文件中
out.close();
tofile.close();

                 }
            catch(IOException e2){}
          }
    }

}
}
英语单词拼写训练
模板代码
RondomString.java
public class RondomString
{ String str=“”;
public String getRondomString(String s)
{ StringBuffer strBuffer=new StringBuffer(s);
int m=strBuffer.length();
for(int k=0;k<m;k++)
{ int index=(int)(Math.random()strBuffer.length());
char c=strBuffer.charAt(index);
str=str+c;
strBuffer=strBuffer.deleteCharAt(index);
}
return str;
}
}
LetterLabel.java
import java.awt.;
import java.awt.event.;
public class LetterLabel extends Button implements FocusListener,MouseListener
{ LetterLabel()
{ addFocusListener(this); //将当前对象注册为自身的焦点视器
addMouseListener(this); //将当前对象注册为自身的标监视器
setBackground(Color.cyan);
setFont(new Font(“”,Font.BOLD,30));
}
public static LetterLabel[] getLetterLabel(int n)
{ LetterLabel a[]=new LetterLabel[n];
for(int k=0;k<a.length;k++)
{ a[k]=new LetterLabel();
}
return a;
}
public void focusGained(FocusEvent e)
{ setBackground(Color.red);
}
public void focusLost(FocusEvent e)
{ setBackground(Color.cyan);
}
public void mousePressed(MouseEvent e)
{ requestFocus();
}
public void setText(String c)
{ setLabel(“”+c);
}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mouseClicked(MouseEvent e){}
}
SpellingWordFrame.java
import java.awt.;
import java.awt.event.;
import javax.swing.Box;
public class SpellingWordFrame extends Frame implements KeyListener,ActionListener
{ TextField inputWord;
Button button;
LetterLabel label[];
Panel northP,centerP;
Box wordBox;
String hintMessage=“用鼠标单击字母，按左右箭头交换字母，将其排列成所输入的单词”;
Label messageLabel=new Label(hintMessage);
String word=“”;
SpellingWordFrame()
{ inputWord=new TextField(12);
button=new Button(“确定”);
button.addActionListener(this);
inputWord.addActionListener(this);
northP=new Panel();
northP.add(new Label(“输入一个英文单词：”));
northP.add(inputWord);
northP.add(button);
centerP=new Panel();
wordBox=Box.createHorizontalBox();
centerP.add(wordBox);
add(northP,BorderLayout.NORTH);
add(centerP,BorderLayout.CENTER);
add(messageLabel,BorderLayout.SOUTH);
setBounds(100,100,350,180);
setVisible(true);
validate();
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{ System.exit(0);
}
}
);
}
public void actionPerformed(ActionEvent e)
{ word=inputWord.getText();
int n=word.length();
RondomString rondom=new RondomString();
String randomWord=rondom.getRondomString(word);
wordBox.removeAll();
messageLabel.setText(hintMessage);
if(n>0)
{ label=LetterLabel.getLetterLabel(n);
for(int k=0;k<label.length;k++)
{ label[k].addKeyListener(this); //将当前窗口注册为label[k]的键盘监视器
label[k].setText(“”+randomWord.charAt(k));
wordBox.add(label[k]);
}
validate();
inputWord.setText(null);
label[0].requestFocus();
}
}
public void keyPressed(KeyEvent e)
{ LetterLabel sourceLabel=(LetterLabel)e.getSource();
int index=-1;
if(e.getKeyCode()==KeyEvent.VK_LEFT) //判断按下的是否是←键)
{ for(int k=0;k<label.length;k++)
{ if(label[k]==sourceLabel)
{ index=k;
break;
}
}
if(index!=0)
{ String temp=label[index].getLabel();
label[index].setText(label[index-1].getLabel());
label[index-1].setText(temp);
label[index-1].requestFocus();
}
}
else if(e.getKeyCode()==KeyEvent.VK_RIGHT) //判断按下的是否是→键
{ for(int k=0;k<label.length;k++)
{ if(label[k]==sourceLabel)
{ index=k;
break;
}
}
if(index!=label.length-1)
{ String temp=label[index].getLabel();
label[index].setText(label[index+1].getLabel());
label[index+1].setText(temp);
label[index+1].requestFocus();
}
}
validate();
}
public void keyTyped(KeyEvent e){}
public void keyReleased(KeyEvent e)
{ String success=“”;
for(int k=0;k<label.length;k++)
{ String str=label[k].getLabel();
success=success+str;
}
if(success.equals(word))
{ messageLabel.setText(“恭喜你，你成功了”);
for(int k=0;k<label.length;k++)
{ label[k].removeKeyListener(this);
label[k].removeFocusListener(label[k]);
label[k].setBackground(Color.green);
}
inputWord.requestFocus();
}
}
}
WordMainClass.java
public class WordMainClass
{ public static void main(String args[])
{ new SpellingWordFrame();
}
}
1、下列哪个是Java应用程序主类中正确的main方法（ b）。
A、public void main(String args[]) B、public static void main(String args[])
C、public static void main(String args) D、static void main(String args[])
2、下列那个可以作为Java标识符（c ）。
A、boy-girl B、2int_ long C、$Boy D、byte
3、正则表达式 ([0-9]{3})-([a-z]{3})-([a-z]?ab) 与下列哪个字符串相匹配（ ）。
A、123-abc{3}-cab B、123{3}-abc-cab C、123-abc-cb D、123-abc-ccab
4、下列那个类的声明是错误的（ ）。
A、final abstract class A B、final class A
C、abstract class A D、public class A
5、下列叙述那个是错误的（ ）。
A、String类是final类，不可有子类 B、String类在java.lang包中
C、“abc”.equals(“abc”)的值是ture D、“abc”=="abc"的值是false
6、方法public void abc(int a){}，以下哪一个是它的重载方法（ ）
A、private void a(){} B、private int abc(int a){}
C、public int abc(int a,String name){} D、private void abc(int a){}
7、以下哪一个不是受检查的异常类（ ）
A、SQLException B、NullPointerException
C、FileNotfoundException D、IOException
8、接口当中，所有的成员变量默认都是（ ）
A、public abstract类型 B、public abstract final类型
C、public static final类型 D、private类型
9、将一个对像序列化的方式是，使此类实现以下哪一个接口（ ）
A、Cloneable B、Serializable C、File D、Exception1
10、当子类中的内部类与父类中的内部类同名时（ ）
A、子类复盖了父类的内部类 B、编译出错
C、运行出错 D、各自拥有自己的内部类，互不影响
11、下列叙述那个是正确的（ ）。
A、Frame类对象的默认的布局是FlowLayout布局
B、Panel类对象的默认的布局是FlowLayout布局
C、Button类的直接父类是Container
D、TextField对象可以触发ItemEvent事件
12、下列叙述那个是正确的（ ）。
A、任何组件都可以触发MouseEvent事件
B、处理WindowEvent事件的接口是FocusListener
C、java.awt.event.MouseAdapter类实现了ActionListener接口
D、java.awt.event.WindowAdapter是一个接口
13、下列那个类创建的对象可以触发FocusEvent事件（ ）。
A、java.awt.color类 B、java.awt.TextField类
C、java.util.Date类 D、java.lang.StringBuffer类
14、启动一个线程应使用线程类的（ ）
A、run() B、start() C、go() D、thread()
15、对于以下代码，哪个能编译通过（ ）
public interface Animal{}
public class Dog i{}
public class Cat implements Animal{}
A、Dog dog = new Cat(); B、Cat cat = new Animal();
C、Animal cat = new Dog(); D、Cat c = new Cat(); Dog d = (Dog)c;

1、类中实例变量在声明时候会被分配内存空间。（ ）
2、类方法（static方法）可以操作类实例变量。（ ）
3、类中的实例方法可以用类名直接调用。（ ）
4、子类在声明一个与父类成员变量名字相同的成员变量时隐藏了父类的成员变量。（ ）
5、在子类中不允许有一个方法和父类的方法名字相同，而类型不同的方法。（ ）
6、父类的final方法可以被子类重写。（ ）
7、Panel类对象的默认布局是FlowLayout。（ ）
8、一个容器对象可以使用add方法添加一个Frame窗口。（ ）
9、Java中数组的元素可以是简单数据类型的量，也可以是某一类的对象。（ ）。
10、线程处于新建、死亡状态时，调用isAlive()方法返回的值是false。（ ）

1、什么叫标识符，标识符的规则是什么？
2、什么叫方法的重载？
3、什么叫对象的上转型对象？
4、引起线程中断的常见原因是什么？
5、线程调用interrupt()的作用是什么？

1、分析下列程序得出输出结果。
public class E3_1
{ public static void main( String args[] )
{ string x= ‘你’,y= ‘看’,z= ‘她’;
if(x>‘A’)
{ y= ‘呼叫’ ;
z= 'Call ’ ;
}
else
y= ‘我’;
z=‘他’;
System.out.println(" "+x+y+z) ;
}

}
2、分析下列程序得出输出结果。
public class E3_2
{ public static void main( String args[] )
{ char c=‘\0’;
for(int i=1;i<=4;i++)
{ switch(i)
{ case 1: c=‘r’;
System.out.print ©;
case 2: c=‘o’;
System.out.print ©;
break;
case 3: c=‘t’;
System.out.print ©;
default: System.out.print (“!”);
}
}
}
}

root!!
3、分析下列程序得出输出结果。
class A4_3
{ int n;
static int sum=0;
public void setN( int n )
{ this.n=n;
}

public int getSum()
{ for(int i=1;i<=n;i++)
sum=sum+i;
return sum;
}
}
public class E4_3
{ public static void main( String args[] )
{ A4_3 a1=new A4_3(),a2=new A4_3();
a1.setN(4);
a2.setN(10);
int s1=a1.getSum();
int s2=a2.getSum();
System.out.println(s1+s2);
}
}

75
4、分析下列程序得出输出结果。
class A4_4
{ public int f( int x )
{ return x+1;
}
}
class B4_4 extends A4_4
{ public int f( int x )
{ return xx;
}
}
public class E4_4
{ public static void main( String args[] )
{ A4_4 a=new B4_4();
int m=a.f(15);
System.out.println(m) ;
}
}
225
5、分析下列程序得出输出结果。
import java.util.;
public class E5_2
{ public static void main( String args[] )
{ int a[]={13,37,80,81,-98};
double b[]={-98.08,87.87,17,68.97, 12.12 ,7.89};
Arrays.sort(a);
Arrays.sort(b,1,4);
for(int i=0;i<=4;i++)
{ System.out.print (a[i]+ “,”);
}
System.out.println(“”);
for(int i=0;i<=b.length-1;i++)
{ System.out.print (b[i]+ “,”);
}
}
}
-98,13,37,80,81,
-98.08,17.0,68.97,87.87,12.12,7.89,

1、根据提示（【代码X】）完成程序填空，输出希腊字母表的代码模板如下：
GreekAlphabet.java
public class GreekAlphabet
{ public static void main (String args[ ])
{ int startPosition=0,endPosition=0;
char cStart=‘α’,cEnd=‘ω’;
【代码1】 //cStart做int型转换据运算，并将结果赋值给startPosition
【代码2】 //cEnd做int型转换运算，并将结果赋值给endPosition
System.out.println(“希腊字母’α’在unicode表中的顺序位置:”+(int)c);
System.out.println(“希腊字母表：”);
for(int i=startPosition;i<=endPosition;i++)
{ char c=‘\0’;
【代码3】 //i做char型转换运算，并将结果赋值给c
System.out.print(" “+c);
if((i-startPosition+1)%100)
System.out.println(“”);
}
}
}
2、根据提示（【代码X】）完成程序填空，上转型对象的代码模板如下：
HardWork.java
abstract class Employee
{ public abstract double earnings();
}
class YearWorker extends Employee
{ 【代码1】 //重写earnings()方法，返回值年薪50000元的总数
}
class MonthWorker extends Employee
{ 【代码2】 //重写earnings()方法，返回月薪2300元的总数。
}
class WeekWorker extends Employee
{ 【代码3】 //重写earnings()方法，返回值周薪500元的总数。
}
class Company
{ Employee[] employee;
double salaries=0;
Company(Employee[] employee)
{ this.employee=employee;
}
public double salariesPay()
{ salaries=0;
【代码4】 //计算salaries。
return salaries;
}
}
public class HardWork
{ public static void main(String args[])
{ Employee[] employee=new Employee[20];
for(int i=0;i<employee.length;i++)
{ if(i%30)
employee[i]=new WeekWorker();
else if(i%31)
employee[i]=new MonthWorker();
else if(i%32)
employee[i]=new YearWorker();
}
Company company=new Company(employee);
System.out.println(“公司年工资总额:”+company.salariesPay());
}
}
3、根据提示（【代码X】）完成程序填空，算术测试的代码模板如下：
Teacher.java
public class Teacher
{ int numberOne,numberTwo;
String operator=”“;
boolean right;
public int giveNumberOne(int n)
{ numberOne=(int)(Math.random()n)+1;
return numberOne;
}
public int giveNumberTwo(int n)
{ numberTwo=(int)(Math.random()n)+1;
return numberTwo;
}
public String giveOperator()
{ double d=Math.random();
if(d>=0.5)
operator=“+”;
else
operator=“-”;
return operator;
}
public boolean getRight(int answer)
{ if(operator.equals(“+”))
{ if(answernumberOne+numberTwo)
right=true;
else
right=false;
}
else if(operator.equals(“-”))
{ if(answernumberOne-numberTwo)
right=true;
else
right=false;
}
return right;
}
}
ComputerFrame.java
import java.awt.;
import java.awt.event.;
public class ComputerFrame extends Frame implements ActionListener
{ TextField textOne,textTwo,textResult;
Button getProblem,giveAnwser;
Label operatorLabel,message;
Teacher teacher;
ComputerFrame(String s)
{ super(s);
teacher=new Teacher();
setLayout(new FlowLayout());
textOne=【代码1】 //创建textOne,其可见字符长是10
textTwo=【代码2】 //创建textTwo,其可见字符长是10
textResult=【代码3】 //创建textResult,其可见字符长是10
operatorLabel=new Label(”+“);
message=new Label(“你还没有回答呢”);
getProblem=new Button(“获取题目”);
giveAnwser=new Button(“确认答案”);
add(getProblem);
add(textOne);
add(operatorLabel);
add(textTwo);
add(new Label(”=“));
add(textResult);
add(giveAnwser);
add(message);
textResult.requestFocus();
textOne.setEditable(false);
textTwo.setEditable(false);
【代码4】//将当前窗口注册为getProblem的ActionEvent事件监视器
【代码5】//将当前窗口注册为giveAnwser的ActionEvent事件监视器
【代码6】//将当前窗口注册为textResult的ActionEvent事件监视器
setBounds(100,100,450,100);
setVisible(true);
validate();
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{ System.exit(0);
}
}
);
}
public void actionPerformed(ActionEvent e)
{ if(【代码7】) //判断事件源是否是getProblem
{ int number1=teacher.giveNumberOne(100);
int number2=teacher.giveNumberTwo(100);
String operator=teacher.givetOperator();
textOne.setText(”“+number1);
textTwo.setText(”"+number2);
operatorLabel.setText(operator);
message.setText(“请回答”);
textResult.setText(null);
}
if(e.getSource()==giveAnwser)
{ String answer=textResult.getText();
try{ int result=Integer.parseInt(answer);
if(teacher.getRight(result)==true)
{ message.setText(“你回答正确”);
}
else
{ message.setText(“你回答错误”);
}
}
catch(NumberFormatException ex)
{ message.setText(“请输入数字字符”);
}
}
textResult.requestFocus();
validate();
}
}
MainClass.java
public class MainClass
{ public static void main(String args[])
{ ComputerFrame frame;
frame=【代码8】//创建窗口，其标题为：算术测试
}
}

1、下列哪个是JDK提供的编译器（ ）。
A、java.exe B、javac.exe C、javap.exe D、javaw.exe
2、以下哪个是不正确的标识符（ ）
A、Abc3 B、a_bc_3 C、_3abc D、3_abc
3、以下哪一个是正确初始化数组的方式（ ）
A、int[1] a = new int[1]{1}; B、int[] a = new int[1]{1};
C、int[] a = new int[]{1}; D、int[1] a = new int[1];
4、下列叙述那个是正确的（ ）。
A、final 类不可以有子类
B、abstract类中只可以没有abstract方法
C、abstract类中可以有非abstract方法，但该方法不可以用final修饰
D、可以同是用final 和abstract修饰一个方法
5、以下哪一个包是默认导入到Java类当中的（ ）
A、java.long B、java.io C、java.net D、java.lang
6、对于方法public void a(int a,String b){}以下哪一个是它正确的重载方法（ ）
A、public int a(int a,String b){} B、protected void a(int a,String b){}
C、public int a(int a,String[] b){} D、public static void a(int a,String b){}
7、声明成员变量：public final String name;后，直接输出，结果为（ ）
A、null B、NULL C、空 D、编译出错
8、接口中的方法默认都是（ ）
A、protetcted类型。 B、public abstract final类型。
C、public abstract类型 D、protected abstract类型
9、继承使用（ ）关键字，实现一个接口，使用（ ）关键字？
A、implements、extends B、extends、implements
C、extends、static D、implements、abstract
10、在子类中，声明了同父类相同名称的成员变量，此时要引用父类的成员变量，可以使用关键字。（ ）
A、this B、abstract C、super D、parent
11、假设组建com的宽和高分别为w和h，要讲组件的中心放置在(x,y)坐标点上，请问下列那个是正确的放置方法（ ）。
A、com.setLocation(x,y) B、com.setLocation(x-w/2,y-h/2)
C、com.setLocation(x-w,y-h) D、com.setLocation(x+w/2,y+h/2)
12、哪个事件类标识基于一个java.awt.component的按键动作? （ ）
A、KeyEvent B、KeyDownEvent C、KeyPressEvent D、KeyTypedEvent
13、下列那个类创建的对象可以触发ActionEvent事件（ ）。
A、java.awt.Button类 B、java.awt.color类
C、java.util.Date类 D、java.lang.StringBuffer类
14、下列叙述那个是正确的（ ）。
A、无模式对话框处于激活状态时，程序仍能激活它所依赖的窗口或组件
B、有模式对话框处于激活状态时，程序仍能激活它所依赖的窗口或组件
C、无模式对话框不可以添加按钮组件
D、有模式对话框不可以添加按文本框组件
15、对于Person p = new Person();，以下哪个能编译通过（ ）
A、Object o = new Object§; B、p = new Object();
C、boolean b = p instanceof Object; D、boolean b = Object instanceof p;

1、类中实例变量在创建时候会被分配内存空间。（ ）
2、类中的实例方法可以操作类变量（static变量）。（ ）
3、类方法可以用类名直接调用。（ ）
4、子类在声明一个与父类方法名字、类型、参数相同的方法时隐藏了父类的方法。（ ）
5、在子类中允许有一个方法和父类的方法名字相同，而类型不同的方法。（ ）
6、子类一定要重写父类中的abstract方法。（ ）
7、Frame类对象的默认布局是BorderLayout。（ ）
8、Checkbox对象可以触发ItemEvent事件。（ ）
9、一个线程执行完run()方法后，该线程还能再调用start()方法。（ ）
10、线程处于运行、中断状态时，调用isAlive()方法返回的值是false。（ ）

1、Java有什么特点？
2、Java的基本数据类型都是什么？
3、什么叫接口的回调？
4、建立线程有几种方法，是那几种？
5、线程有几种状态？

1、分析下列程序得出输出结果。
public class E2_1
{ public static void main( String args[] )
{ long[] a={1,2,3,4};
long[] b={100,200,300,400,500};
b=a;
System.out.println(“数组b的长度：”+b.length) ;
System.out.println(“b[0]=”+ b[0]) ;
}
}
2、分析下列程序得出输出结果。
class A4_1
{ int x;
public void setX( int x )
{ this.x=x;
}
public int getX()
{ return x;
}
}
class B4_1
{ public void f(A4_1 a)
{ a.setX(100);
}
}
public class E4_1
{ public static void main( String args[] )
{ A4_1 a=new A4_1();
a.setX(8);
System.out.println(a.getX());
B4_1 b=new B4_1();
b.f(a);
System.out.println(a.getX());
}
}
3、分析下列程序得出输出结果。
class A4_2
{ int x=100,y=200;
public void setX( int x )
{ x=x;
}
public void setY( int y )
{ this.y=y;
}
public int getXYSum()
{ return x+y;
}
}
public class E4_2
{ public static void main( String args[] )
{ A4_2 a=new A4_2();
a.setX(-100);
a.setY(-200);
System.out.println(“sum=”+a.getXYSum());
}
}
4、分析下列程序得出输出结果。
class A4_5
{ double f(double x,double y )
{ return x+y;
}
static int g(int n )
{ return nn;
}
}
class B4_5 extends A4_5
{ double f(double x,double y )
{ double m=super.f(x,y);
return m+xy;
}
static int g(int n )
{ int m=A 4_5.g(n) ;
return m+n;
}
}
public class E4_5
{ public static void main( String args[] )
{ B4_5 b=new B4_5();
System.out.println(b.f(10.0,8.0)) ;
System.out.println(b.g(3)) ;
}
}
5、分析下列程序得出输出结果。
public class E5_1
{ public static void main( String args[] )
{ String s=“xx大学xx学院”;
char a=s.charAt(2),b=s.charAt(6);
System.out.print (a);
System.out.println(b);
}
}
1、根据提示（【代码X】）完成程序填空，猜数字游戏的代码模板如下：
GuessNumber.java
import javax.swing.JOptionPane;
public class GuessNumber
{ public static void main (String args[ ])
{ System.out.println(“给你一个1至100之间的整数,请猜测这个数”);
int realNumber=(int)(Math.random()100)+1;
int yourGuess=0;
String str=JOptionPane.showInputDialog(“输入您的猜测:”);
yourGuess=Integer.parseInt(str);
while(【代码1】) //循环条件
{ if(【代码2】) //条件代码
{ str=JOptionPane.showInputDialog(“猜大了,再输入你的猜测:”);
yourGuess=Integer.parseInt(str);
}
else if(【代码3】) //条件代码
{ str=JOptionPane.showInputDialog(“猜小了,再输入你的猜测:”);
yourGuess=Integer.parseInt(str);
}
}
System.out.println(“猜对了!”);
}
}
2、根据提示（【代码X】）完成程序填空，接口回调的代码模板如下：
Road.java
interface ComputerWeight
{ public double computeWeight();
}
class Television implements ComputerWeight
{ 【代码1】 //实现computeWeight()方法，返回值45.5。
}
class Computer implements ComputerWeight
{ 【代码2】 //实现computeWeight()方法，返回值65.5。
}
class WashMachine implements ComputerWeight
{ 【代码3】 //实现computeWeight()方法，返回值145。
}
class Car
{ ComputerWeight[] goods;
double totalWeights=0;
Car(ComputerWeight[] goods)
{ this.goods=goods;
}
public double getTotalWeights()
{ totalWeights=0;
【代码4】 //计算totalWeights
return totalWeights;
}
}
public class Road
{ public static void main(String args[])
{ ComputerWeight[] goodsOne=new ComputerWeight[50],
goodsTwo=new ComputerWeight[22] ;
for(int i=0;i<goodsOne.length;i++)
{ if(i%30)
goodsOne[i]=new Television();
else if(i%31)
goodsOne[i]=new Computer();
else if(i%32)
goodsOne[i]=new WashMachine();
}
for(int i=0;i<goodsTwo.length;i++)
{ if(i%30)
goodsTwo[i]=new Television();
else if(i%31)
goodsTwo[i]=new Computer();
else if(i%32)
goodsTwo[i]=new WashMachine();
}
Car 大货车=new Car(goodsOne);
System.out.println(“大货车装载的货物重量:”+大货车.getTotalWeights());
Car 小货车=new Car(goodsTwo);
System.out.println(“小货车装载的货物重量:”+小货车.getTotalWeights());
}
}
3、根据提示（【代码X】）完成程序填空，信号灯的代码模板如下：
SignalCanvas.java
import java.awt.;
public class SignalCanvas extends Canvas
{ int red,green,yellow,x,y,r;
SignalCanvas()
{ setBackground(Color.white);
}
public void setRed(int r)
{ red=r; }
public void setGreen(int g)
{ green=g; }
public void setYellow(int y)
{ yellow=y; }
public void setPosition(int x,int y)
{ this.x=x;
this.y=y;
}
public void setRadius(int r)
{ this.r=r;
}
public void paint(Graphics g)
{ if(red1)
{ g.setColor(Color.red);
}
else if(green1)
{ g.setColor(Color.green);
}
else if(yellow==1)
{ g.setColor(Color.yellow);
}
g.fillOval(x,y,2r,2r);
}
}
SignalFrame.java
import java.awt.;
import java.applet.;
import java.awt.event.;
public class SignalFrame extends Frame implements ItemListener
{ Choice choice;
SignalCanvas signal=null;
String itemRed=“红灯”,itemYellow=“黄灯”,itemGreen=“绿灯”;
public SignalFrame()
{ choice=【代码1】 //创建choice
【代码2】 //创建choice添加itemRed
【代码3】 //创建choice添加itemYellow
【代码4】 //创建choice添加itemGreen
【代码5】 //将当前窗口注册为choice的ItemEvent事件监视器
add(choice,BorderLayout.NORTH);
try{ Class cs=Class.forName(“SignalCanvas”);
signal=(SignalCanvas)cs.newInstance();
add(signal,BorderLayout.CENTER);
}
catch(Exception e)
{ add(new Label(“您还没有编写SignalCanvas类”),BorderLayout.CENTER);
}
setBounds(100,100,360,300);
setVisible(true);
validate();
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{ System.exit(0);
}
}
);
}
public void itemStateChanged(ItemEvent e)
{ String item= 【代码6】 // choice返回被选中的条目
int w=signal.getBounds().width;
int h=signal.getBounds().height;
int m=Math.min(w,h);
signal.setRadius(m/6);
if(【代码7】) //判断item的值是否为itemRed
{ if(signal!=null)
{ signal.setRed(1);
signal.setYellow(0);
signal.setGreen(0);
signal.setPosition(w/3,0);
signal.repaint();
}
}
else if(【代码8】) //判断item的值是否为itemYellow
{ if(signal!=null)
{ signal.setRed(0);
signal.setYellow(1);
signal.setGreen(0);
signal.setPosition(w/3,h/3);
signal.repaint();
}
}
else if(item.equals(itemGreen))
{ if(signal!=null)
{ signal.setRed(0);
signal.setYellow(0);
signal.setGreen(1);
signal.setPosition(w/3,2h/3);
signal.repaint();
}
}
}
}
SignalMainClass.java
public class SignalMainClass
{ public static void main(String args[])
{ SignalFrame frame;
frame=new SignalFrame() ;
frame.setTitle(“信号灯”);
}
}

1、Java语言最初是面向哪个应用领域设计的？（ ）
A、Internet B、制造业 C、消费电子产品 D、CAD
2、下列关于注释语句的描述中，正确的一项是（ ）
A、以//开始的是多行注释语句
B、以/开始，/结束的是单行注释语句
C、以/**开始，/结束的是可以用于生成帮助文档的注释语句
D、以/**开始，/结束的是单行注释语句
3、下列标识符中，正确的是：（ ）
A、class B、123_rr C、_lei D、test&12
4、下列关于类、包和源文件的描述中，不正确的一项是（ ）。
A、一个包可以包含多个类
B、一个源文件中，只能有一个公共类
C、属于同一个包的类在默认情况下可以相互访问
D、系统不会为源文件创建默认的包
5、关于被保护访问控制符 protected 修饰的成员变量，以下说法正确的是（ ）
A 、可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B 、可以被两种类访问和引用：该类本身、该类的所有子类
C 、只能被该类自身所访问和修改
D 、只能被同一个包中的类访问
6、下列哪个是Java应用程序主类中正确的main方法（ ）。
A、public void main(String args[]) B、public static void main(String args[])
C、public static void main(String args) D、static void main(String args[])
7、正则表达式 ([0-9]{3})-([a-z]{3})-([a-z]?ab) 与下列哪个字符串相匹配（ ）。
A、123-abc{3}-cab B、123{3}-abc-cab C、123-abc-cb D、123-abc-ccab
8、下列那个类的声明是错误的（ ）。
A、final abstract class A B、final class A
C、abstract class A D、public class A
9、方法public void abc(int a){}，以下哪一个是它的重载方法（ ）
A、private void a(){} B、private int abc(int a){}
C、public int abc(int a,String name){} D、private void abc(int a){}
10、以下哪一个不是受检查的异常类（ ）
A、SQLException B、NullPointerException
C、FileNotfoundException D、IOException
11、当子类中的内部类与父类中的内部类同名时（ ）
A、子类复盖了父类的内部类 B、编译出错
C、运行出错 D、各自拥有自己的内部类，互不影响
12、下列叙述那个是正确的（ ）。
A、Frame类对象的默认的布局是FlowLayout布局
B、Panel类对象的默认的布局是FlowLayout布局
C、Button类的直接父类是Container
D、TextField对象可以触发ItemEvent事件
13、下列叙述那个是正确的（ ）。
A、任何组件都可以触发MouseEvent事件
B、处理WindowEvent事件的接口是FocusListener
C、java.awt.event.MouseAdapter类实现了ActionListener接口
D、java.awt.event.WindowAdapter是一个接口
14、启动一个线程应使用线程类的（ ）
A、run() B、start() C、go() D、thread()
15、对于以下代码，哪个能编译通过（ ）
public interface Animal{}
public class Dog implements Animal{}
public class Cat implements Animal{}
A、Dog dog = new Cat(); B、Cat cat = new Animal();
C、Animal cat = new Dog(); D、Cat c = new Cat(); Dog d = (Dog)c;
16、以下程序段，运行时会出现什么结果（ ）
public class Person{
static int arr[] = new int[5];
public static void main(String a[])
{ 　System.out.println(arr[0]);　
}
}
A、编译时将产生错误 B、编译时正确，运行时将产生错误
C、输出零 D、输出空
17、对于下面这段程序，说法正确的是（ ）
class test1
{ public static void main(String args[])
{ int y,x=1,total=0;
while(x<=3)
{ y=xx;
System.out.println(y);
total+=y;
++x;
}
System.out.println("total is "+total);
}
}
A、编译时将产生错误 B、程序将会陷入死循环
C、total的值是为3！ D、total的值最终为14
18、对于下面的不完整的类代码：（ ）
class person
{ String name,department;
public person(String n)
{ name=n;
}
public person(String n,String d)
{ _______________
department=d;
}
}
下面表达式中，哪个可以加到构造方法中的“___________”处
A、person(n) B、this(person(n)) C、this(n) D、this(n,a);
19、阅读下面代码：（ ）
class person
{ public int addvalue(int a,int b)
{ int s;
s=a+b;
return s;
}
}
class child extends parent{}
若要在child类中对addvalue方法进行重写，下面对于child类中的addvalue方法头的描述哪个是正确的：
A、int addvalue(int I,int j) B、void addvalue()
C、void addvalue(double i) D、int addvalue(int a)
20、下面程序中，有错误的一行是：（ ）
Final class MyClass ①
{ int var=100 ； ②
static int getVar() ③
{ return var; ④
}
}
A、① B、② C、③ D、④

1、Java有什么特点？
2、Java的基本数据类型都是什么？
3、什么是类体，类体的内容由哪两部分构成？
4、什么叫接口的回调？
5、引起线程中断的常见原因是什么？

1、分析下列程序得出输出结果。
public class E2_1
{ public static void main( String args[] )
{ long[] a={5,4,3,2,1};
long[] b={100,200,300,400};
b=a;
System.out.println(“数组b的长度：”+b.length) ;
System.out.println(“b[0]=”+ b[0]) ;
}
}
2、分析下列程序得出输出结果。
class A4_2
{ int x=300,y=200;
public void setX( int x )
{ x=x;
}
public void setY( int y )
{ this.y=y;
}
public int getXYSum()
{ return x+y;
}
}
public class E4_2
{ public static void main( String args[] )
{ A4_2 a=new A4_2();
a.setX(-300);
a.setY(-200);
System.out.println(“sum=”+a.getXYSum());
}
}
3、分析下列程序得出输出结果。
class A4_5
{ double f(double x,double y )
{ return x+y;
}
static int g(int n )
{ return nn;
}
}
class B4_5 extends A4_5
{ double f(double x,double y )
{ double m=super.f(x,y);
return m+xy;
}
static int g(int n )
{ int m=A 4_5.g(n) ;
return m+n;
}
}
public class E4_5
{ public static void main( String args[] )
{ B4_5 b=new B4_5();
System.out.println(b.f(5.0,15.0)) ;
System.out.println(b.g(4)) ;
}
}
4、分析下列程序得出输出结果。
import java.util.*;
public class E5_2
{ public static void main( String args[] )
{ int a[]={3,60,91,90,-987};
double b[]={12.09,87.87,36,678. 876,-90.90,7.12};
Arrays.sort(a);
Arrays.sort(b,1,4);
for(int i=0;i<=4;i++)
{ System.out.print (a[i]+ “,”);
}
System.out.println(“”);
for(int i=0;i<=b.length-1;i++)
{ System.out.print (b[i]+ “,”);
}
}
}
5、阅读程序段，回答问题。
public class ClassA{
public void method1(int i){}
public void method2(int i){}
public static void method3(int i){}
public static void method4(int i){}
}
public class ClassB extends ClassA{
public static void method1(int i){}
public void method2(int i){}
public void method3(int i){}
public static void method4(int i){}
}
ClassB中（method1、method2、method3、method4）四个方法，方法 覆盖了父类方法；方法 隐藏了父类方法。
6、分析下列程序得出输出结果。
class Fibi
{ public static long fibinacii(int n)
{ long c=0;
if(n1||n2)
c=1;
else
c=fibinacii(n-1)+fibinacii(n-2);
return c;
}
}
public class E6_2
{ public static void main(String args[])
{ System.out.println(Fibi.fibinacii(6));
}
}

1、根据提示（【代码X】）完成程序填空，代码模板如下：
模板代码：E4_20.java
【代码1】 动物{ //声明一个抽象类
abstract void cry();
}
class 狗 extends 动物
{ void cry()
{ System.out.println(“汪汪…”);
}
}
class 猫 extends 动物
{ 【代码2】//重写猫的cry方法
}
class E4_20
{ public static void main(String args[])
{ 动物 dongwu;
【代码3】：//用dongwu对象来使用狗的cry方法；
【代码4】：//用dongwu对象来使用猫的cry方法；
}
}
2、根据提示（【代码X】）完成程序填空，接口回调的代码模板如下
模板代码：Road.java
interface ComputerWeight
{ public double computeWeight();
}
class Television implements ComputerWeight
{ 【代码1】 //实现computeWeight()方法,返回45.5。
}
class Computer implements ComputerWeight
{ 【代码2】 //实现computeWeight()方法,返回65.5。
}
class WashMachine implements ComputerWeight
{ 【代码3】 //实现computeWeight()方法,返回145。
}
class Car
{ ComputerWeight[] goods;
double totalWeights=0;
Car(ComputerWeight[] goods)
{ this.goods=goods;
}
public double getTotalWeights()
{ totalWeights=0;
【代码4】 //计算totalWeights
return totalWeights;
}
}
public class Road
{ public static void main(String args[])
{ ComputerWeight[] goodsOne=new ComputerWeight[50],
goodsTwo=new ComputerWeight[22] ;
for(int i=0;i<goodsOne.length;i++)
{ if(i%30)
goodsOne[i]=new Television();
else if(i%31)
goodsOne[i]=new Computer();
else if(i%32)
goodsOne[i]=new WashMachine();
}
for(int i=0;i<goodsTwo.length;i++)
{ if(i%30)
goodsTwo[i]=new Television();
else if(i%31)
goodsTwo[i]=new Computer();
else if(i%32)
goodsTwo[i]=new WashMachine();
}
Car 大货车=new Car(goodsOne);
System.out.println(“大货车装载的货物重量:”+大货车.getTotalWeights());
Car 小货车=new Car(goodsTwo);
System.out.println(“小货车装载的货物重量:”+小货车.getTotalWeights());
}
}
3、根据提示（【代码X】）完成程序填空，信号灯的代码模板如下：
模板代码：SignalCanvas.java
import java.awt.;
public class SignalCanvas extends Canvas
{ int red,green,yellow,x,y,r;
SignalCanvas()
{ setBackground(Color.white);
}
public void setRed(int r)
{ red=r; }
public void setGreen(int g)
{ green=g; }
public void setYellow(int y)
{ yellow=y; }
public void setPosition(int x,int y)
{ this.x=x;
this.y=y;
}
public void setRadius(int r)
{ this.r=r;
}
public void paint(Graphics g)
{ if(red1)
{ g.setColor(Color.red);
}
else if(green1)
{ g.setColor(Color.green);
}
else if(yellow==1)
{ g.setColor(Color.yellow);
}
g.fillOval(x,y,2r,2r);
}
}
SignalFrame.java
import java.awt.;
import java.applet.;
import java.awt.event.;
public class SignalFrame extends Frame implements ItemListener
{ Choice choice;
SignalCanvas signal=null;
String itemRed=“红灯”,itemYellow=“黄灯”,itemGreen=“绿灯”;
public SignalFrame()
{ choice=【代码1】 //创建choice
【代码2】 //创建choice添加itemRed
【代码3】 //创建choice添加itemYellow
【代码4】 //创建choice添加itemGreen
【代码5】 //将当前窗口注册为choice的ItemEvent事件监视器
add(choice,BorderLayout.NORTH);
try{ Class cs=Class.forName(“SignalCanvas”);
signal=(SignalCanvas)cs.newInstance();
add(signal,BorderLayout.CENTER);
}
catch(Exception e)
{ add(new Label(“您还没有编写SignalCanvas类”),BorderLayout.CENTER);
}
setBounds(100,100,360,300);
setVisible(true);
validate();
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{ System.exit(0);
}
});
}
public void itemStateChanged(ItemEvent e)
{ String item= 【代码6】 // choice返回被选中的条目
int w=signal.getBounds().width;
int h=signal.getBounds().height;
int m=Math.min(w,h);
signal.setRadius(m/6);
if(【代码7】) //判断item的值是否为itemRed
{ if(signal!=null)
{ signal.setRed(1);
signal.setYellow(0);
signal.setGreen(0);
signal.setPosition(w/3,0);
signal.repaint();
}
}
else if(item.equals(itemYellow))
{ if(signal!=null)
{ signal.setRed(0);
signal.setYellow(1);
signal.setGreen(0);
signal.setPosition(w/3,h/3);
signal.repaint();
}
}
else if(item.equals(itemGreen))
{ if(signal!=null)
{ signal.setRed(0);
signal.setYellow(0);
signal.setGreen(1);
signal.setPosition(w/3,2*h/3);
signal.repaint();
}
}
}
}
SignalMainClass.java
public class SignalMainClass
{ public static void main(String args[])
{ SignalFrame frame;
frame=new SignalFrame() ;
frame.setTitle(“信号灯”);
}
}

1、下面关于Java语言说法错误的是：（ ）
A、java语言是解释运行的 B、java语言是从c和c++演变而来的
C、java语言支持多线程 D、java语言要求程序员必须自己回收内存
2、下面标识符中正确的是：（ ）
A、$123_x B、12java C、new D、java#next
3、下面哪个不属于java的基本数据类型：（ ）
A、short B、boolean C、String D、char
4、下面关于方法的说法中不正确的是：（ ）
A、方法可以没有返回值 B、方法调用时要求形参和实参保持一致
C、方法允许重载 D、方法的参数不能为空
5、下面定义数组的格式中正确的是：（ ）
A、int a[10] B、int a=new int[10] C、int []a=new int[5] D、int a[]
6、下列叙述那个是正确的（ ）。
A、final 类不可以有子类
B、abstract类中只可以没有abstract方法
C、abstract类中可以有非abstract方法，但该方法不可以用final修饰
D、可以同是用final 和abstract修饰一个方法
7、以下哪一个包是默认导入到Java类当中的（ ）
A、java.long B、java.io C、java.net D、java.lang
8、对于方法public void a(int a,String b){}以下哪一个是它正确的重载方法（ ）
A、public int a(int a,String b){} B、protected void a(int a,String b){}
C、public int a(int a,String[] b){} D、public static void a(int a,String b){}
9、声明成员变量：public final String name;后，直接输出，结果为（ ）
A、null B、NULL C、空 D、编译出错
10、继承使用（ ）关键字，实现一个接口，使用（ ）关键字？
A、implements、extends B、extends、implements
C、extends、static D、implements、abstract
11、在子类中，声明了同父类相同名称的成员变量，此时要引用父类的成员变量，可以使用关键字。（ ）
A、this B、abstract C、super D、parent
12、哪个事件类标识基于一个java.awt.component的按键动作? （ ）
A、KeyEvent B、KeyDownEvent C、KeyPressEvent D、KeyTypedEvent
13、下列那个类创建的对象可以触发ActionEvent事件（ ）。
A、java.awt.Button类 B、java.awt.color类
C、java.util.Date类 D、java.lang.StringBuffer类
14、下列叙述那个是正确的（ ）。
A、无模式对话框处于激活状态时，程序仍能激活它所依赖的窗口或组件
B、有模式对话框处于激活状态时，程序仍能激活它所依赖的窗口或组件
C、无模式对话框不可以添加按钮组件
D、有模式对话框不可以添加按文本框组件
15、对于Person p = new Person();，以下哪个能编译通过（ ）
A、Object o = new Object§; B、p = new Object();
C、boolean b = p instanceof Object; D、boolean b = Object instanceof p;
16、以下哪个表达式是不合法的（ a）
A、String x=“Hello”; int y=9; x+=y;
B、String x=“Hello”; int y=9; if(x.equals(y)) { }
C、String x=“Hello”; int y=9; x=x+y;
D、String x=null; int y= (x!=null)&&(x.length()>0)
17、对于下面的不完整的类代码：（ ）
class person
{ String name,department;
public person(String n)
{ name=n;
}
public person(String n,String d)
{ _______________
department=d;
}
}
下面表达式中，哪个可以加到构造方法中的“”处
A、person(n) B、this(person(n) C、this(n) D、this(n,a);
18、下面程序在fun（）方法运行正常下的输出结果是：（ ）
public void test()
{ try
{ fun();
System.out.print(“情况1”);
}catch(ArrayIndexOutOfBoundsException e)
{ System.out.print(“情况2”);
}
catch(Exception e)
{ System.out.print(“情况3”);
}
finally
{ System.out.print(“finally”);
}
}
A、情况1 B、情况2 C、情况3 D、情况1finally
19、下面程序运行后，正确的显示界面是：（ ）
import java.awt.;
import java.applet.Applet;
public class awt6 extends Applet
{ CardLayout card=new CardLayout();
Button b[]=new Button[5];
public void init()
{ setLayout(card);
for(int i=0;i<=4;i++)
{ b[i]=new Button(“卡片号为：”+i);
add(String.valueOf(i),b[i]);
}
}
}
A、 B、
C、 D、
20、下面程序填空正确的是：（ ）
import java.awt.;
import java.applet.Applet;
import java.awt.event.*;
public class action1 extends Applet _____________
{ Button b1=new Button(“press me”);
Label l1=new Label("提示信息栏 ");
public void init()
{ setLayout(new FlowLayout(FlowLayout.LEFT,5,20));
add(b1);
add(l1);
b1.addActionListener(this);
}
public void actionPerformed(ActionEvent e)
{ l1.setText(“button1 clicked”);}}
A、implements ActionEvent B、implements ActionListener
C、ActionListener D、extends ActionEvent

1、Java有什么特点？
2、什么叫标识符，标识符的规则是什么？
3、什么叫方法的重载？
4、什么叫对象的上转型对象？
5、建立线程有几种方法，是那几种？

1、分析下列程序得出输出结果。
public class E3_2
{ public static void main( String args[] )
{ char c=‘\0’;
for(int i=1;i<=4;i++)
{ switch(i)
{ case 1: c=‘b’;
System.out.print ©;
case 2: c=‘e’;
System.out.print ©;
break;
case 3: c=‘?’;
System.out.print ©;
default: System.out.print (“o”);
}
}
}
}
2、分析下列程序得出输出结果。
class A4_1
{ int x;
public void setX( int x )
{ this.x=x;
}
public int getX()
{ return x;
}
}
class B4_1
{ public void f(A4_1 a)
{ a.setX(100);
}
}
public class E4_1
{ public static void main( String args[] )
{ A4_1 a=new A4_1();
a.setX(8);
System.out.println(a.getX());
B4_1 b=new B4_1();
b.f(a);
System.out.println(a.getX());
}
}
3、分析下列程序得出输出结果。
class A4_3
{ int n;
static int sum=0;
public void setN( int n )
{ this.n=n;
}
public int getSum()
{ for(int i=1;i<=n;i++)
sum=sum+i;
return sum;
}
}
public class E4_3
{ public static void main( String args[] )
{ A4_3 a1=new A4_3(),a2=new A4_3();
a1.setN(3);
a2.setN(5);
int s1=a1.getSum();
int s2=a2.getSum();
System.out.println(s1+s2);
}
}
4、分析下列程序得出输出结果。
class A4_4
{ public int f( int x )
{ return x+1;
}
}
class B4_4 extends A4_4
{ public int f( int x )
{ return x*x;
}
}
public class E4_4
{ public static void main( String args[] )
{ A4_4 a=new B4_4();
int m=a.f(10);
System.out.println(m) ;
}
}
5、阅读程序段，回答问题。
public class ClassA{
public void method1(int i){}
public void method2(int i){}
public static void method3(int i){}
public static void method4(int i){}
}
public class ClassB extends ClassA{
public static void method1(int i){}
public void method2(int i){}
public void method3(int i){}
public static void method4(int i){}
}
ClassB中（method1、method2、method3、method4）四个方法，方法 覆盖了父类方法；方法 隐藏了父类方法。
6、分析下列程序得出输出结果。
class E6_1
{ public static void main(String args[])
{ String s1,s2;
s1=new String(“we are students”);
s2=new String(“we are students”);
System.out.println(s1.equals(s2));
System.out.println(s1s2);
String s3,s4;
s3=“how are you”;
s4=“how are you”;
System.out.println(s3.equals(s4));
System.out.println(s3s4);
}
}

1、根据提示（【代码X】）完成程序填空，代码模板如下：
模板代码：E4_27.java
【代码1】 ShowMessage //声明一个接口
{ void 显示商标(String s);
}
class TV implements ShowMessage
{ 【代码2】//重写TV的"显示商标"输出方法
}
class PC implements ShowMessage
{ public void 显示商标(String s)
{ System.out.println(s);
}
}
public class E4_27
{ public static void main(String args[])
{ ShowMessage sm;
【代码3】//用sm对象来使用TV的"显示商标"方法，输出"长城牌电视机"内容；
【代码4】//用sm对象来使用PC的"显示商标"方法，输出"联想奔月5008PC机"内容；
}
}
2、根据提示（【代码X】）完成程序填空，上转型对象的代码模板如下：
模板代码：HardWork.java
abstract class Employee
{ public abstract double earnings();
}
class YearWorker extends Employee
{ 【代码1】 //重写earnings()方法,返回50000。
}
class MonthWorker extends Employee
{ 【代码2】 //重写earnings()方法,返回12个月每月2000。
}
class WeekWorker extends Employee
{ 【代码3】 //重写earnings()方法,返回52周每周500。
}
class Company
{ Employee[] employee;
double salaries=0;
Company(Employee[] employee)
{ this.employee=employee;
}
public double salariesPay()
{ salaries=0;
【代码4】 //计算salaries。
return salaries;
}
}
public class HardWork
{ public static void main(String args[])
{ Employee[] employee=new Employee[20];
for(int i=0;i<employee.length;i++)
{ if(i%30)
employee[i]=new WeekWorker();
else if(i%31)
employee[i]=new MonthWorker();
else if(i%32)
employee[i]=new YearWorker();
}
Company company=new Company(employee);
System.out.println(“公司年工资总额:”+company.salariesPay());
}
}
3、根据提示（【代码X】）完成程序填空，算术测试的代码模板如下
模板代码：Teacher.java
public class Teacher
{ int numberOne,numberTwo;
String operator=“”;
boolean right;
public int giveNumberOne(int n)
{ numberOne=(int)(Math.random()*n)+1;
return numberOne;
}
public int giveNumberTwo(int n)
{ numberTwo=(int)(Math.random()*n)+1;
return numberTwo;
}
public String giveOperator()
{ double d=Math.random();
if(d>=0.5)
operator=“+”;
else
operator=“-”;
return operator;
}
public boolean getRight(int answer)
{ if(operator.equals(“+”))
{ if(answernumberOne+numberTwo)
right=true;
else
right=false;
}else if(operator.equals(“-”))
{ if(answer==numberOne-numberTwo)
right=true;
else
right=false;
}
return right;
}
}
ComputerFrame.java
import java.awt.;
import java.awt.event.;
public class ComputerFrame extends Frame implements ActionListener
{ TextField textOne,textTwo,textResult;
Button getProblem,giveAnwser;
Label operatorLabel,message;
Teacher teacher;
ComputerFrame(String s)
{ super(s);
teacher=new Teacher();
setLayout(new FlowLayout());
textOne=【代码1】 //创建textOne,其可见字符长是10
textTwo=【代码2】 //创建textTwo,其可见字符长是10
textResult= new TextField(“”,10);
operatorLabel=new Label(“+”);
message=new Label(“你还没有回答呢”);
getProblem=new Button(“获取题目”);
giveAnwser=new Button(“确认答案”);
add(getProblem);
add(textOne);
add(operatorLabel);
add(textTwo);
add(new Label(“=”));
add(textResult);
add(giveAnwser);
add(message);
textResult.requestFocus();
textOne.setEditable(false);
textTwo.setEditable(false);
【代码3】//将当前窗口注册为getProblem的ActionEvent事件监视器
【代码4】//将当前窗口注册为giveAnwser的ActionEvent事件监视器
【代码5】//将当前窗口注册为textResult的ActionEvent事件监视器
setBounds(100,100,450,100);
setVisible(true);
validate();
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{ System.exit(0);
}
}
);
}
public void actionPerformed(ActionEvent e)
{ if(【代码6】) //判断事件源是否是getProblem
{ int number1=teacher.giveNumberOne(100);
int number2=teacher.giveNumberTwo(100);
String operator=teacher.givetOperator();
textOne.setText(“”+number1);
textTwo.setText(“”+number2);
operatorLabel.setText(operator);
message.setText(“请回答”);
textResult.setText(null);
}
if(e.getSource()==giveAnwser)
{ String answer=textResult.getText();
try{ int result=Integer.parseInt(answer);
if(teacher.getRight(result)==true)
{ message.setText(“你回答正确”);
}else
{ message.setText(“你回答错误”);
}
}
catch(NumberFormatException ex)
{ message.setText(“请输入数字字符”);
}
}
textResult.requestFocus();
validate();
}
}
MainClass.java
public class MainClass
{ public static void main(String args[])
{ ComputerFrame frame;
frame=【代码7】//创建窗口，其标题为：算术测试
}
}