A．a1
B．$1
C．_1
D．11
答案：D
A．a1.java
B．a1.class
C．a1
D．都对
答案：A
A．short
B．long
C．int
D．byte
答案：D
A．类型定义机制
B．数据封装机制
C．类型定义机制和数据封装机制
D．上述都不对
答案：C
A．先声明对象，然后才能使用对象
B．先声明对象，为对象分配内存空间，然后才能使用对象
C．先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象
D．上述说法都对
答案：C
A．用基本数据类型作为参数
B．用对象作为参数
C．A和B都对
D．A和B都不对
答案：B
A．一个子类可以有多个父类，一个父类也可以有多个子类
B．一个子类可以有多个父类，但一个父类只可以有一个子类
C．一个子类可以有一个父类，但一个父类可以有多个子类
D．上述说法都不对
答案：C
A．安全性
B．多线性
C．跨平台
D．可移植
答案：B
A．每次读入的字节数相同
B．前者带有缓冲，后者没有
C．前者是字符读写，后者是字节读写
D．二者没有区别，可以互换使用
答案：C
A．default String s;
B．public final static native int w( ){};
C．abstract double d;
D．abstract final double hyperbolicCosine( );
答案：D
class StaticStuff {
static int x = 10;
static {x += 5;}
public static void main(String args[]) {
System.out.println("x=" + x);
}
static {x /= 3;}
}
A．4行与9行不能通过编译，因为缺少方法名和返回类型
B．9行不能通过编译，因为只能有一个静态初始化器
C．编译通过，执行结果为：x=5
D．编译通过，执行结果为：x=3
答案：C
A．while (int i<7)
{ i++;
System.out.println(“i is “+i);
}
B．int j=3;
while(j) {
System.out.println(“ j is “+j);
}
C．int j=0;
for(int k=0; j + k !=10; j++,k++) {
System.out.println(“ j is “+ j + “k is”+ k);
}
D．int j=0;
do{
System.out.println( “j is “+j++);
if (j = = 3) {continue loop;}
}while (j<10);
答案：C
类Test1定义如下：
public class Test1{
public float aMethod（float a，float b）{ }
//第3行
}
A．public float aMethod(float a， float b，float c){ }
B．public float aMethod(float c，float d){ }
C．public int aMethod(int a， int b){ }
D．private float aMethod(int a，int b，int c){ }
答案：B
类Test1、Test2定义如下：
public class Test1 {
public float aMethod(float a, float b) throws IOException {}
}
public class Test2 extends Test1 {}
A．float aMethod（float a，float b）{ }
B．public int aMethod（int a，int b）throws Exception{ }
C．public float aMethod（float p，float q）{ }
D．public int aMethod（int a，int b）throws IOException{ }
答案：A
String s1=”abc”+”def”;
String s2=new String（s1）；
if（s1= =s2）
System.out.println(“= = succeeded”);
if (s1.equals(s2))
System.out.println(“.equals() succeeded”);
A．行4与行6都将执行
B．行4执行，行6不执行
C．行6执行，行4不执行
D．行4、行6都不执行
答案：C
A．int
B．float
C．double
D．void
答案：D
A．start()
B．init()
C．run()
D．synchronized()
答案：C
A．const
B．$double
C．hello
D．BigMeaninglessName
答案：A
A．transient
B．static
C．serialize
D．synchronized
答案：D
A．隐藏
B．覆盖
C．重载
D．Java不支持此特性
答案：C
A．构造函数的返回类型只能是void型。
B．构造函数是类的一种特殊函数，它的方法名必须与类名相同。
C．构造函数的主要作用是完成对类的对象的初始化工作。
D．一般在创建新对象时，系统会自动调用构造函数。
答案：A
A．程序员必须创建一个线程来释放内存
B．内存回收程序负责释放无用内存
C．内存回收程序允许程序员直接释放内存
D．内存回收程序可以在指定的时间释放内存对象
答案：B
A．static
B．package
C．private
D．public
答案：A
ReturnType method(byte x, double y) {
return (short)x/y*2;
}
A．byte
B．short
C．int
D．double
答案：D
//第1行
public class Interesting{
//do sth
}
A．import java.awt.*;
B．package mypackage;
C．class OtherClass{ }
D．public class MyClass{ }
答案：D
A．interface B{ void print() { } ; }
B．abstract interface B{ void print() ;}
C．abstract interface B extendsA．1,A2 { abstract void print(){ };}//A1、A2为已定义的接口
D．interface B { void print();}
答案：D
A．void aMethod( ){...}
B．public int aMethod(){...}
C．public void aMethod ( ){...}
D．public int aMethod ( int m){...}
答案：D
Class A
{ int i;
static String s;
void method1() { }
static void method2() { }
}
A．System.out.println(a.i)；
B．a.method1();
C．A.method1();
D．A.method2()
答案：C
//此为第1行
{
if(unsafe()){ //do something…}
else if(safe()){ //do the other…}
}
A．public IOException methodName()
B．public void methodName()
C．public void methodName() throw IOException
D．public void methodName() throws IOException
答案：D
A．8
B．16
C．32
D．64
答案：B
A．在Java中类只允许单一继承
B．在Java中一个类只能实现一个接口
C．在Java中一个类不能同时继承一个类和实现一个接口
D．在Java中接口只允许单一继承
答案：A
public class Person{
static int arr[] = new int[5];
public static void main(String a[]) {
System.out.println(arr[0]);}
}
}
A．编译时将产生错误
B．编译时正确，运行时将产生错误
C．输出零
D．输出空
答案：C
A．private
B．protected
C．private protected
D．public
答案：D
class A{
protected boolean equals(){
return super.equals();
}
}
A．编译通过运行无异常
B．编译通过但运行时出错
C．行2出错，不能成功编译
D．不能成功编译，行3出错
答案：D
A．int i=s.length();
B．s>>>=3;
C．String ts=s.trim();
D．String t=s+"!";
答案：B
A．Java是跨平台的编程语言
B．Java支持分布式计算
C．Java是面向过程的编程语言
D．Java支持多线程
答案：C
A．对象、消息
B．继承、多态
C．类、封装
D．过程调用
答案：D
A．输入、处理、输出
B．树形、网形、环形
C．顺序、选择、循环
D．主程序、子程序、函数
答案：C
A．Java语言规定构造方法名与类名必须相同
B．Java语言规定构造方法没有返回值，但不用void声明
C．Java语言规定构造方法不可以重载
D．Java语言规定构造方法只能通过new自动调用
答案：C
A．abstract final class HI{}
B．abstract private move(){}
C．protected private number;
D．public abstract class Car{}
答案：D
A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B．可以被两种类访问和引用：该类本身、该类的所有子类
C．只能被该类自身所访问和修改
D．只能被同一个包中的类访问
答案：C
A．while循环能实现的操作，for循环也都能实现
B．while循环判断条件一般是程序结果，for循环判断条件一般是非程序结果
C．两种循环任何时候都可替换
D．两种循环结构中都必须有循环体，循环体不能为空
答案：B
import java.io.*;
import java.util.*;
public class foo{
public static void main (String[] args){
String s;
System.out.println("s=" + s);
}
}
A．代码得到编译，并输出“s=”
B．代码得到编译，并输出“s=null”
C．由于String s没有初始化，代码不能编译通过
D．代码得到编译，但捕获到 NullPointException异常
答案：C
public class Conditional{
public static void main(String args[ ]){
int x=4;
System.out.println(“value is “+ ((x>4) ? 99.9:9));
}
}
A．输出结果为：value is 99.9
B．输出结果为：value is 9
C．输出结果为：value is 9.0
D．编译错误
答案：C
A．x[9]为0
B．x[9]未定义
C．x[10]为0
D．x[0]为空
答案：A
String s1=“a”+“b”;
String s2=new String（s1）；
if（s1= =s2）
System.out.println(“= = is succeeded”);
if (s1.equals(s2))
System.out.println(“.equals() is succeeded”);
A．行4与行6都将执行
B．行4执行，行6不执行
C．行6执行，行4不执行
D．行4、行6都不执行
答案：C
A．extends
B．implements
C．abstract
D．interface
答案：B
if ( a>0 )
if ( a>3 ) c = 2;
else c = 3;
else c = 4;
A．1
B．2
C．3
D．4
答案：C
A．&&
B．||
C．!
D．( )
答案：D
A．void mmm()
B．void mmm(int i)
C．void mmm(String s)
D．int mmm()
答案：D
A．appletviewer
B．javac
C．java
D．javadoc
答案：B
A．.byte
B．.class
C．.html
D．.exe
答案：B
A．1与1
B．2与1
C．1与2
D．2与2
答案：D
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[] ）
答案：B
A．面向对象
B．高安全性
C．平台无关
D．面向过程
答案：D
A．Tree&Glasses
B．FirstJavaApplet
C．*theLastOne
D．273.5
答案：B
A．启动
B．刹车
C．减速
D．速度
答案：D
A．for (int k = 0; k < 0; k++)
B．for (int k = 10; k > 0; k--)
C．for (int k = 0; k < 10; k--)
D．for (int k = 0; k > 0; k++)
答案：C
int a = b = 5;
String s1 = "祝你今天考出好成绩！";
String s2 = s1;
A．true与true
B．false与true
C．true与false
D．false与false
答案：A
A．static
B．final
C．private
D．void
答案：A
A．接口方法
B．最终方法
C．抽象方法
D．空方法
答案：C
int total = 0;
for ( int i = 0; i < 4; i++ ){
if ( i == 1) continue;
if ( i == 2) break;
total += i;
}
A．0
B．1
C．3
D．6
答案：A
A．private
B．protected
C．private protected
D．public
答案：A
A．int
B．String
C．Integer
D．Number
答案：B
A．52
B．7
C．2
D．5
答案：A
A．static void method( )
B．public void method( )
C．final void method( )
D．abstract void method( )
答案：A
A．int a[ ];
B．int[ ] a;
C．int[3][ ] a;
D．int[ ][3] a;
答案：D
A．int
B．long
C．double
D．char
答案：C
A．ArrayList myList=new Object（）；
B．List myList=new ArrayList（）；
C．ArrayList myList=new List（）；
D．List myList=new List（）；
答案：B
A．byte=128;
B．Boolean=null;
C．long l=0xfffL;
D．double=0.9239d;
答案：C
public class X extends Thread implements Runnable{
public void run(){
System.out.println("this is run()");
}
public static void main(String args[]) {
Thread t=new Thread(new X());
t.start();
}
}
A．第一行会产生编译错误
B．第六行会产生编译错误
C．第六行会产生运行错误
D．程序会运行和启动
答案：D
A．java.sys包
B．java.lang包
C．java.util包
D．以上都不是
答案：B
A．float f=3.14;
B．char c=”c”;
C．Boolean b=null;
D．int i=10.0;
答案：C
A．2ofUS
B．giveMes
C．whataQuiz
D．$d2000_
答案：A
A．int[] ages = [100];
B．int ages = new int[100];
C．int[] ages = new int[100];
D．int() ages = new int(100);
答案：C
A．一个子类的对象可以接收父类对象能接收的消息；
B．当子类对象和父类对象能接收同样的消息时，它们针对消息产生的行为可能不同；
C．父类比它的子类的方法更多；
D．子类在构造函数中可以使用super( )来调用父类的构造函数；
答案：C
public class Test {
int n = 0;int m = 0;
public Test(int a){ m=a;}
public static void main(String arg[]) {
Test t1,t2;
int j,k;j=3;k=5;
t1=new Test();t2=new Test(k);
}
}
A．行1
B．行4
C．行6
D．行9
答案：D
A．JavaScript
B．Applet
C．Servlet
D．Java Swing
答案：A
A．同一类
B．同一包中的子类
C．同一包中的非子类
D．不同包中的子类
答案：D
A．NullPointerException
B．ClassCastException
C．FileNotFoundException
D．IndexOutOfBoundsException
答案：C
A．BufferedWriter
B．FileInputStream
C．ObjectInputStream
D．InputStreamReader
答案：D
A．int a1[]={3,4,5};
B．String a2[]={"string1","string1","string1"};
C．String a3[]=new String(3);
D．int[][] a4=new int[3][3];
答案：C
A．public int method(int i)
B．protected method(int i)
C．public static method(String s)
D．protected static void method(Integer i)
答案：D
public int getValue(int i) {
int result = 0;
switch (i) {
case 1: result = result + i;
case 2: result = result + i * 2;
case 3: result = result + i * 3;
}
return result;
}
A．0
B．2
C．4
D．10
答案：D
public void getCustomerInfo() {
try {
// do something that may cause an Exception
} catch (java.io.FileNotFoundException ex) {
System.out.print("FileNotFoundException!");
} catch (java.io.IOException ex) {
System.out.print("IOException!");
} catch (java.lang.Exception ex) {
System.out.print("Exception!");
}
}
A．IOException!
B．IOException!Exception!
C．FileNotFoundException!IOException!
D．FileNotFoundException!IOException!Exception!
答案：A
A．new BufferedWriter(new FileWriter("A．txt"));
B．new BufferedReader(new FileInputStream("A．dat"));
C．new GZIPOutputStream(new FileOutputStream("A．zip"));
D．new ObjectInputStream(new FileInputStream("A．dat"));
答案：B
A．int size()
B．boolean containsAll(Collection coll)
C．compareTo(Object obj)
D．boolean remove(Object obj)
答案：C
A．死亡状态
B．阻塞状态（对象lock池内）
C．阻塞状态（对象wait池内）
D．就绪状态
答案：D
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() {
}
}
A．public abstract void method(int A );
B．value = value + 5;
C．public int method();
D．public abstract void anotherMethod() {}
答案：A
File file = new File("C:\\test.dat");
if (file.exists()) {
file.delete();
}
A．创建C:\test.dat。
B．删除C:\test.dat。
C．打开C:\test.dat文件输出流。
D．移动C:\test.dat
答案：B
class Shape {
public String name;
}
class Circle extends Shape implements Serializable{
private float radius;
transient int color;
public static String type = "Circle";
}
A．name
B．radius
C．color
D．type
答案：B
A．public class Line {
int length;
Class Point {//内部类代码}
}
B．public class Line {
public Point getPoint() {
return new Point(){//内部类代码};
}
}
C．public class Line {
//外部类代码
}
class Point {//内部类代码}
D．public class Line {
public int calcLength() {
class Point {//内部类代码}
}
}
答案：C
Iterator it = list.iterator();
int index = 0;
while (it.hasNext()){
Object obj = it.next();
if (needDelete(obj)) { //needDelete返回boolean，决定是否要删除
//todo delete
}
index ++;
}
A．list.remove(obj);
B．list.remove(index);
C．list.remove(it.next());
D．it.remove();
答案：D
A．Ada
B．C++
C．Pasacal
D．BASIC
答案：B
A．Java程序经编译后会产生machine code
B．Java程序经编译后会产生byte code
C．Java程序经编译后会产生DLL
D．以上都不正确
答案：B
A．class中的构造函数不可省略
B．构造函数必须与class同名，但方法不能与class同名
C．构造函数在一个对象被new时执行
D．一个class只能定义一个构造函数
答案：C
A．java.sql
B．java.awt
C．java.lang
D．java.swing
答案：A
A．&&
B．<>
C．if
D．:=
答案：A
int a = 0;int c = 0;
do {
--c;
a = a - 1;
} while (a > 0);
A．0
B．1
C．-1
D．死循环
答案：C
A．abstract修饰符可修饰字段、方法和类
B．抽象方法的body部分必须用一对大括号{ }包住
C．声明抽象方法，大括号可有可无
D．声明抽象方法不可写出大括号
答案：D
A．形式参数可被视为local variable
B．形式参数可被字段修饰符修饰
C．形式参数为方法被调用时，真正被传递的参数
D．形式参数不可以是对象
答案：A
A．实例方法可直接调用超类的实例方法
B．实例方法可直接调用超类的类方法
C．实例方法可直接调用其他类的实例方法
D．实例方法可直接调用本类的类方法
答案：D
A．paint()
B．setSize()
C．getSize()
D．repaint()
答案：B
A．MouseEvent
B．WindowEvent
C．ActionEvent
D．KeyEvent
答案：C
A．for(;;){}
B．for(int i=0;i＜10000;T++){}
C．while(false){}
D．do{}while(false)
答案：A
A．"abc"+"efg"
B．"abc"+'efg'
C．'a'+'b'
D．3+"4"
答案：C
A．double
B．char
C．byte
D．short
答案：A
A．a[0]
B．a[1]
C．a[99]
D．a[100]
答案：D
A．super
B．This
C．Super
D．this
答案：D
public class VariableUse {
public static void main(String[] args) {
int a;
if (a == 8) {
int b = 9;
System.out.println("a=" + a);
System.out.println("b=" + b);
}
System.out.println("a=" + a);
System.out.println("b=" + b);
}
}
该程序在编译时的结果是（ ）。
A．变量a未赋值
B．第二个System.out.println("b="+b)语句中，变量b作用域有错
C．第二个System.out.println("a="+a)语句中，变量a作用域有错
D．第一个System.out.println("b="+b)语句中，变量b作用域有错
答案：B
A．JButton
B．JLabel
C．JFrame
D．JPane
答案：D
A．MouseListener
B．WindowListener
C．ActionListener
D．KeyListener
答案：A
public class Person {
static int arr[] = new int[10];
public static void main(String args) {
System.out.println(arr[9]);
}
}
该代码的运行结果是（ ）。
A．编译时将产生错误
B．编译时正确，运行时将产生错误
C．输出零
D．输出空
答案：C
A．toLowerCase()
B．valueOf()
C．charAt()
D．append()
答案：D
A．-128～+127
B．-2147483648～+2147483647
C．-32768～+32767
D．-1000～+1000
答案：C
ByteArrayOutputStream bout=new ByteArrayOutputStream();
ObjectOutputStream out=new ObjectOutputStream(hout);
out.writeObject(this);
out.close();
以上代码段的作用是（ ）。
A．将对象写入内存
B．将对象写入硬盘
C．将对象写入光盘
D．将对象写入文件
答案：A
A．String s[]={"how","are");
B．byte b=255;
C．String s="one"+"two";
D．int i=2+2000;
答案：B
public class Test{
public static void main(String args[]){
System.out.println((2＜0)? 10:8);
}
}
其运行结果是（ ）。
A．2
B．0
C．10
D．8
答案：D
A．java.io.FileOutputstream
B．java.io.ByteArrayOutputStream
C．java.io.BufferedOutputstream
D．java.io.DataOutputStream
答案：C
class Test implements Runnable {
public int run() {
int i = 0;
while (true) {
i++;
System.out.println("i=" + i);
}
}
}
上述代码的编译结果是（ ）。
A．程序通过编译并且run()方法可以正常输出递增的i值
B．程序通过编译，调用run()方法将不显示任何输出
C．程序不能通过编泽，因为while的循环控制条件不能为“true”
D．程序不能通过编译，因为run()方法的返回值类型不是void
答案：D
①扩展java.lang.Thread类。如果线程是使用独立的Runnable运行对象构造的，则调用该Runnable对象的run方法；否则，该方法不执行任何操作并返回。
②实现java.lang.Runncable接口。实现接口Runnable的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的run方法。方法run的常规协定是，它可能执行任何所需的操作。本题应该选择D。
A．一个线程一旦被创建，就立即开始运行
B．使用start()方法可以使一个线程成为可运行状态，但是它不一定立即开始运行
C．当运行状态的线程因为调用了yield()方法而停止运行，它一定被放在可运行线程队列的前面
D．当因等待对象锁而被阻塞的线程获得锁后，将直接进入运行状态
答案：B
public class Test implements Runnable {
public void run(Thread t) {
System.out.println("Running.");
}
public static void main(String[] args) {
Thread tt = new Thread(new Test());
tt.start();
}
}
代码运行结果是（ ）。
A．将抛出一个异常
B．没有输出并正常结束
C．输出"Running"并正常结束
D．程序第2行将出现一个编译错误
答案：D
A．static boolean matches()
B．boolean matcher.find()
C．int matcher.start()
D．int matcher.end()
答案：A
public class Test{
String s="One World One Dream";
public static void main(String args[]){
System.out.println(s);
}
}
其运行结果是（ ）。
A．args
B．One World One Dream
C．s
D．编译时出错
答案：D
A．paint()
B．setSize()
C．getSize()
D．repaint()
答案：B
[解析] 考点范围：JAVA简介
A．int
B．float
C．double
D．void
答案：D
[解析] 考点范围：JAVA简介
A．Java文档生成器
B．Java解释器
C．Java编译器
D．Java类分解器
答案：B
[解析] 考点范围：JAVA简介
A．垃圾回收器
B．虚拟机
C．编译器
D．多线程机制
答案：B
[解析] 考点范围：JAVA简介
A．Java语言的标识符是区分大小写的
B．源文件名与public类名可以不相同
C．源文件名其拓展名为.jar
D．源文件中public类的数目不限
答案：A
[解析] 考点范围：JAVA简介
A．BigOlLon$223
B．utfint
C．$12s
D．3d
答案：D
[解析] 考点范围：JAVA语言基础
int x=3；int y=8；System.out.println(y%x);
A．0
B．1
C．2
D．3
答案：C
[解析] 考点范围：JAVA语言基础
A．String x=”Sky”;int y=5; x+=y;
B．String x=”Sky”;int y=5; if(x==y){}
C．String x=”Sky”;int y=5;x=x+y;
D．String x=null ; int y=(x!=null)&&(x.length()>0)?x.length:0
答案：B
[解析] 考点范围：JAVA语言基础
A．TRUE
B．const
C．super
D．void
答案：A
[解析] 考点范围：JAVA语言基础
i += i-1；
A．10
B．121
C．11
D．100
答案：C
[解析] 考点范围：JAVA语言基础
A．switch
B．while
C．for
D．if/else
答案：D
[解析] 考点范围：程序流程控制
int a = 3；
int b = 1；
if（a=b）
System.out.println(“a = ”+ a);
A．a = 1
B．a = 3
C．编译错误，没有输出
D．正常运行，但没有输出
答案：C
[解析] 考点范围：程序流程控制
A．for语句
B．while语句
C．switch语句
D．do-while语句
答案：C
[解析] 考点范围：程序流程控制
int m= 3,n = 6,k = 0;
while( ( m ++ ) < ( -- n ) )
++k;
A．0
B．1
C．2
D．3
答案：B
[解析] 考点范围：程序流程控制
Int x = 2;
Do{
x+ = x;
}while ( x < 17 );
A．4
B．16
C．32
D．256
答案：C
[解析] 考点范围：程序流程控制
A．x[ 4 ]为0
B．x[ 4 ]未定义
C．x[ 5 ]为0
D．x[ 0 ]为空
答案：A
[解析] 考点范围：数组
A．x[ 5-3 ]
B．x[ k ]
C．x[ k+5 ]
D．x[ 0 ]
答案：C
[解析] 考点范围：数组
A．Array[ 1 ]
B．Array[ 0 ]
C．Array[]
D．Array
答案：B
[解析] 考点范围：数组
public class StaticStuff {
static int x = 15;
static {
x *= 3;
}
public static void main(String args[]) {
System.out.println("x = " + x);
}
static {
x /= 3;
}
}
A．3号行与7号行不能通过编译，因为缺少方法名和返回类型。
B．7号行不能通过编译，因为只能有一个静态初始化器。
C．编译通过，执行结果为：x = 15。
D．编译通过，执行结果为：x = 3。
答案：C
[解析] 考点范围：类和对象
public class Text1 {
public float aMethod (float a, float b) { }
* * *
}
将以下（ ）方法插入行 * * * 是不合法的。
A．public float aMethod ( float a,float b, float c ){ }
B．public float aMethod ( float c, float d ){ }
C．public int aMethod ( int a,int b ){ }
D．public int aMethod ( int a,int b,int c ){ }
答案：B
[解析] 考点范围：类和对象
A．构造方法的返回类型只能是void型
B．构造方法是类的一种特殊方法，它的方法名必须与类名相同
C．构造方法的主要作用是完成对类的对象的初始化工作
D．一般在创建新对象时，系统会自动调用构造方法
答案：A
[解析] 考点范围：类和对象
A．隐藏
B．覆盖
C．重载
D．java不支持此特性
答案：C
[解析] 考点范围：类和对象
class A {
int i ;
static String s;
void method1 { }
static void method2(){ }
}
A．System.out.printLn ( a.i );
B．a.method1 ( );
C．A.method1 ( );
D．A.method2 ( );
答案：C
A．static x x1;
B．public x x1=new x (int 123 );
C．y x1;
D．x x1 = x ();
答案：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;
答案：A
A．说明类方法使用关键字 static
B．类方法和实例方法一样均占用对象的内存空间
C．类方法能用实例和类名调用
D．类方法只能处理类变量或调用类方法
答案：B
[解析] 考点范围：类和对象的扩展
A．包是若干对象的集合
B．使用package语句创建包
C．使用import语句引入包
D．包分为有名包和无名包两种
答案：A
[解析] 考点范围：类和对象的扩展
A．当子类中出现成员方法头与父类方法头相同的方法时，子类成员方法覆盖父类中的成员方法
B．方法重载是变编译时处理的，而方法覆盖是在运行时处理的
C．子类中继承父类中的所有成员都可以访问
D．子类中定义有与父类同名变量时，在子类继承父类的操作中，使用继承父类的变量；子类执行自己的操作中，使自己的定义变量
答案：C
[解析] 考点范围：类和对象的扩展
A．一个类可以同时生成多个子类
B．子类继承了父类中除私有的成员以为的其他成员
C．Java支持单继承和多重继承
D．Java通过接口可使子类使用多个父类成员
答案：C
[解析] 考点范围：类和对象的扩展
A．抽象类是用修饰符abstract说明的
B．抽象类是不可以定义对象的
C．抽象类是不可以有构造方法的
D．抽象类通常有他的子类
答案：C
[解析] 考点范围：类和对象的扩展
A．ArrayList myList=new Object();
B．ArrayList myList=new List
C．List myList=new ArrayList();
D．List myList=new List();
答案：C
[解析] 考点范围：常用的系统类
public class Example {
String str = new String("good");
char[] ch = { 'a', 'b', 'c' };
public static void main(String[] srgs) {
Example ex = new Example();
ex.change(ex.str, ex.ch);
System.out.println(ex.str + "and");
System.out.println(ex.ch);
}
public void change(String str, char ch[]) {
str = "test ok";
ch[0] = 'g';
}
}
A．good and abc
B．good and gbc
C．test and abc
D．test ok and gbc
答案：B
[解析] 考点范围：常用的系统类
A．s.append(“a”);
B．s.concat(s);
C．s.substring(3);
D．以上语句都不对。
答案：D
[解析] 考点范围：常用的系统类
String s1 = “ac” + “def”;
String s2 = new String(s1);
if(s1.equals(s2))
System.out.println(“==succeeded”);
if(s1 == s2)
System.out.println(“ .equala() succeeded”);
A．行4与行6都将执行
B．行6执行，行4不执行
C．行4执行，行6不执行
D．行4、行6都不执行
答案：C
[解析] 考点范围：常用的系统类
String s = “abcde”;
StringBuffer s1 = new StringBuffer(“abcde”);
if(s.equals(s1))
s1 = null;
if(s1.equals(s))
s = null;
A．第一行编译错误，Sting的构造方法必须明确调用
B．第三行编译错误，因为s1与s2有不同的类型
C．编译成功，但执行时在第五行有异常抛出
D．编译成功，执行过程中也没有异常抛出
答案：D
[解析] 考点范围：常用的系统类
A．int I = s.length();
B．String ts = s.trim();
C．s>>>3
D．String t = s+”!”
答案：C
[解析] 考点范围：常用的系统类
A．InputStream与OutputStream类可以用来处理字节流，也就是二进制文件
B．Reader与Writer类是用来处理字符流的，也就是文本文件
C．Java中的I/O流的处理通常分为输入和输出两个部分
D．File类是输入/输出流类的子类
答案：D
[解析] 考点范围：JAVA输入输出系统
A．FileInputStream
B．FileOutputStream
C．RandomaccessFile
D．File
答案：D
[解析] 考点范围：JAVA输入输出系统
A．getParent()
B．getName()
C．getDirectory()
D．getPath()
答案：A
[解析] 考点范围：JAVA输入输出系统
A．FileReader
B．Writer
C．FileInputStream
D．FileOutputStream
答案：BA
[解析] 考点范围：JAVA输入输出系统
A．FileInputStream in = new FileInputStream("file.dat");Int c=in.read();
B．RandomAccessFile in = new RandomAccessFile("file.dat");in.skip(9);int c=in.readByte();
C．FileInputStream in =new FileInputStream("file.dat");in.skip(9);int c=in.read();
D．FileInputStream in=new FileInputStream("file.dat");in.skip(10);int c=in.read();
答案：C
[解析]B错误，如果把skip改为seek，则正确。即RandomAccessFile in = new RandomAccessFile("a.txt","rw");in.seek(9);int c=in.readByte();
A．import java. awt. * ;
B．import java.applet.Applet;
C．import java.io. * ；
D．import java.awt.Graphics;
答案：C
[解析] 考点范围：JAVA输入输出系统
A．InputStreamReader
B．BufferedReader
C．FileterReader
D．FileInputStream
答案：D
[解析] 考点范围：JAVA输入输出系统
A．前者带有缓冲，后者没有
B．前者是块读写，后者是字节读写
C．二者没有区别，可以互换使用
D．每次读写的字节数不同
答案：D
[解析] 考点范围：JAVA输入输出系统
A．容器是由若干个组件和容器组成
B．容器是对图形界面中界面元素的一种管理
C．容器是由一种指定宽和高的矩形范围
D．容器都是可以独立的窗口
答案：D
[解析] 考点范围：图形用户界面
A．List
B．JFrame
C．JDialog
D．JPanel
答案：A
[解析] 考点范围：图形用户界面
A．放在容器中的组件首先要定义，接着要初始化
B．放在容器中的多个组件是要进行布局的，默认布局策略是FlowLayout
C．容器中所有组件都是事件组件，都可产生事件对象
D．事件处理是由监听者定义的方法来实现的
答案：B
[解析] 考点范围：图形用户界面
A．组件类中包含文本组件类（TextComponent）和菜单组件类（JMenuComponent）
B．标签（JLabel）和按钮(JButton)是组件类(JComponrnt)的子类
C．面板(JPanel)和窗口(JWindow)是容器类(Contairner)的子类
D．文本框(JTextField)和文本区(JTextAre)是文本组类(TextComponent)的子类
答案：A
[解析] 考点范围：图形用户界面
but.addActionListener(this);
A．but是某种事件对象，如按钮事件对象
B．this表示当前容器
C．ActionListener是动作事件的监听者
D．该语句的功能是将but对象注册为this对象的监听者
答案：D
[解析] 考点范围：图形用户界面
A．ActionEvent
B．AwtEvent
C．KeyEvent
D．MouseEvent
答案：B
[解析] 考点范围：图形用户界面
A．JButton
B．List
C．Component
D．Container
答案：C
[解析] 考点范围：图形用户界面
A．FlowLayout
B．JDialog
C．BorderLayout
D．GridLayout
答案：C
[解析] 考点范围：图形用户界面
A．JWindow
B．JDialog
C．JFrame
D．JPanel
答案：D
[解析] 考点范围：图形用户界面
A．JFrame容器是可以容纳菜单组件的容器。
B．菜单条中可包含若干个菜单，菜单中又可包含若干菜单项，菜单项中还可包含菜单子项。
C．对话框与JFrame一样都可作为程序的最外层容器。
D．对话框内不含有菜单条，它是由JFrame弹出。
答案：BD
[解析] 考点范围：图形用户界面
try{
sleep(100);
}catch(InterruptedException e) {}
假设线程没有被中断正确的是 （ ）
A．代码不会被编译，因为异常不会在线程的run()方法中捕获
B．在代码的第2行，线程将停止运行，至多100ms后恢复执行,
C．在代码的第2行，线程将停止运行，恰好在100ms后恢复执行,
D．在代码的第2行，线程将停止运行，恰好在100ms后的某个时间恢复执行
答案：C
[解析] 考点范围：线程
public class MyThread implements Runnable {
String myString = "Yes";
public void run() {
this.myString = "No";
}
public static void main(String[] args) {
MyThread t = new MyThread();
new Thread(t).start();
for (int i = 0; i < 10; i++)
System.out.print(t.myString);
}
}
A．输出：Yes Yes Yes Yes Yes Yes Yes Yes Yes Yes
B．输出：No No No No No No No No No No
C．输出：Yes No No No No No No No No No
D．输出不确定
答案：D
[解析] 考点范围：线程
A．线程的优先级是不能改变的
B．线程的优先级是在创建线程时设置的
C．在创建线程后的任何时候都可以设置
D．B和C
答案：D
[解析] 考点范围：线程
A．run()
B．start()
C．sleep()
D．suspend()
答案：B
[解析] 考点范围：线程