以下对File类的public boolean isFile()方法的描述正确的是? ( )
A、在当前目录下生成指定的目录 B、返回文件的最后修改时间
C、判断该File对象所对应的是否为目录 D、判断该File对象所对应的是否是文件
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2015-12-16 [ 在线测试 ]
试题2：File类的方法delete()返回的数据类型为？（ ） A、Integer B、int
C、boolean D、String
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题3：
下列不支持中文字符的编码表为? ( )
A、GBK
B、ISO8859-1 C、GB2312 D、UTF-8
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题4：File类中以字符串形式返回文件绝对路径的方法是？ （ ） A、getPath()
B、getAbsolutePath() C、getName() D、getParant()
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2015-12-16 [ 在线测试 ]
试题5：
以下选项中，哪个是FileOutputStream的父类？ ( )
A、OutputStream B、File
C、FileOutput D、InputStream
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题1：下列选项中，哪些是标准输入流? ( ) A、OutputStream B、System.out
C、System.in D、InputStream
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题2：
获取单列集合中元素的个数可以使用以下哪个方法？ （ ）
A、length()
B、get(int index) C、add(Object obj) D、size()
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题3：Java语言中，集合类都位于哪个包中？ （ ） A、java.collections B、java.array C、java.util D、java.io
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题4：在以下哪种情况下，线程进入就绪状态？（ ） A、线程调用了notify()方法时 B、线程调用了yield()方法时 C、线程调用了join()方法时 D、线程调用了sleep()方法时
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2015-11-29 [ 在线测试 ]
试题5：
线程调用sleep()方法后，该线程将进入以下哪种状态？（ ）
A、就绪状态 B、死亡状态 C、阻塞状态 D、运行状态
试题1：Thread类位于下列那个包中？（ ） A、java.lang B、java.io C、java.awt D、java.util
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2015-11-29 [ 在线测试 ]
试题2：System类位于以下那个包中？（ ） A、java.util B、java.lang C、java.awt D、java.io
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2015-11-8 [ 在线测试 ]
试题3：Outer类中定义了一个成员内部类Inner，需要在main()方法中创建Inner类实例对象，以下四种方式哪一种是正确的（ ） A、Inner in = new Inner();
B、Outer.Inner in = new Outer.Inner() C、Inner in = new Outer.Inner();
D、Outer.Inner in = new Outer().new Inner()
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2015-10-25 [ 在线测试 ]
试题4：下面对于单例模式的描述，不正确的是（ ）。 A、类中定义一个无参的构造方法，并且声明为私有 B、定义静态方法返回该类实例
C、在内部创建一个该类的实例对象，使用静态变量引用该实例对象 D、必须使用private修饰静态变量，禁止外界直接访问
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2015-10-25 [ 在线测试 ]
试题5：在以下什么情况下，构造方法会被调用（ ） A、使用对象的变量时 B、类定义时
C、调用对象方法时 D、创建对象时
下面哪种类型的文件可以在Java虚拟机中运行。（ ）
A、.java B、.class C、.jre D、.exe
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2015-9-29 [ 在线测试 ]
试题2：在Java图形用户界面编程中，若显示一些不需要修改的文本信息，一般是使用的组件是（ ）。
A、JButton B、JTextArea C、JTextField D、JLabel
试题3：JFrame默认的布局管理器是（ ）
A、CardLayout B、BorderLayout C、GridLayout D、FlowLayout
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-5-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-5-29 [ 在线测试 ]
试题4：JPanel默认的布局管理器是（ ）
A、BorderLayout B、FlowLayout C、CardLayout D、GridLayout
试题5：在Java中，一般菜单格式包含下列对象（ ）
A、JMenuBar B、JMenuItem C、JMenu
D、JMenuBar、JMenu、JMenuItem
试题1：Swing与AWt的区别不包括（ ）
A、Swing是由纯Java实现的轻量级构件； B、Swing没有本地代码；
C、Swing支持图形用户界面； D、Swing不依赖操作系统的支持； 试题2：下列数组定义正确的是（ ） A、int[] a； B、 int[][] a； C、int[] a[]； D、int a[]；
试题3：执行完代码\"int[]x=new int[25];\"后以下说明正确的是（ ） A、x[0]为空 B、x[24]未定义 C、x[25]为0 D、x[24]为0
试题4：如定义对象 StringBuffer ch = new StringBuffer(\"Shanghai\") 则ch.length()的值为( )
A、8 B、7 C、23 D、9
试题5：下列语句会造成数组new int[10]越界是（ ） A、a[9]=10;
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-5-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-5-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
B、for(int i=0;i<=10;i++) a[i]++; C、a[0]+=9; D、--a[9]
试题1：关于数组作为方法的参数时，向方法传递的是（ ） A、数组的元素 B、数组自身 C、数组的引用 D、.数组的栈地址
试题2：关于数组默认值，错误的是（ ） A、float--0.0f B、Boolean--true C、char--'u0000' D、int-- 0
试题3：当访问无效的数组下标时，会发生（ ） A、系统崩溃 B、中止程序 C、抛出异常 D、直接跳过
试题4：数组a的第三个元素表示为（ ） A、a[3] B、a(3) C、a(2) D、a[2]
试题5：下面不是创建数组的正确语句是（ ） A、float f[]=new float[6]; B、float [][]f=new float[6][]; C、float f[][]=new float[][6]; D、float f[][]=new float[6][6];
试题1：下列初始化字符数组的语句中，正确的是（ ） A、 char str[5]={\"hi\ B、char str[5]=\"hello\";
C、char str[]={'h','e','l','l','o','\\0'}; D、char str[100]=\"\";
试题2：定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为( )。
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-29 [ 在线测试 ]
A、17 B、 18 C、24 D、25
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-29 [ 在线测试 ]
试题3：下面的二维数组初始化语句中，正确的是（ ）
A、 float b[2][2]={0.1,0.2,0.3,0.4}; B、int a[][2]={{1,2},{3,4}}; C、float a[2][2]={0};
D、 int a[2][]= {{1,2},{3,4}};
试题4：定义了一维int型数组a[10]后，下面错误的引用是（ ）
A、a[0]=5*2; B、a[0]=1; C、a[10]=2;
D、a[1]=a[2]*a[0];
试题5：下面错误的初始化语句是( )。 A、char str[100]=\"hello\"; B、char str[]={'hello'};
C、char str[]={'h','e','l','l','o'}; D、char str[]=\"hello\";
试题1：给出下列代码，则数组初始化中下列选项中不正确的是（ ） byte［］ array1,array2［］; byte array3［］［］; byte ［］［］ array4;
A、array2 = array1 B、array2=array4 C、array3=array4 D、array2=array3
试题2：使用流式套接字编程时，为了向对方发送数据，则需要使用哪个方法（ ） A、getInputStream() B、getInetAddress() C、getOutputStream() D、getLocalPort()
试题3：当使用客户端套接字Socket创建对象时，需要指定（ ） A、服务器地址和文件
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
B、服务器端口和文件 C、服务器名称和文件 D、服务器主机名称和端口
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
试题4：ServerSocket的监听方法accept()的返回值类型是（ ） A、Socket
B、DatagramSocket C、void D、Object
试题5：java程序中，使用TCP套接字编写服务端程序的套接字类是（ ） A、DatagramSocket B、Socket
C、ServerSocket D、DatagramPacket
试题1：为了获取远程主机的文件内容，当创建URL对象后，需要使用哪个方法获取信息（ ） A、getHost B、getPort()
C、openStream() D、openConnection()
试题2：InetAddress类中哪个方法可实现正向名称解析？（ ） A、getHostAddress() B、isReachable() C、getByName() D、getHosstName()
试题3：Java提供的类进行有关Internet地址的操作类型是( ) . A、Socket
B、ServerSocket C、DatagramSocket D、InetAddress
试题4：在客户/服务器通信模式中，客户与服务器程序的主要任务是什么？（ ）
A、服务器程序接收并处理客户请求，然后向客户发送响应结果 B、客户程序发送请求，并接收服务器的响应
C、如果客户程序和服务器都会保证发送的数据不会在传输途中丢失 D、客户程序在网络上找到一条到达服务器的路由
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-4-28 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
试题5：一个服务器进程执行以下代码：
ServerSocket serverSocket=new ServerSocket(80); Socket socket=serverSocket.accept(); int port=socket.getPort();
以下哪些说法正确？（ ）
A、socket.getPort()方法返回服务器进程占用的本地端口，此处返回值是80 B、socket.getPort()方法返回客户端套节字占用的本地端口 C、服务器进程占用80端口
D、当serverSocket.accept()方法成功返回，就表明服务器进程接收到了一个客户连接请求
试题1：Java网络程序位于TCP/IP参考模型的哪一层？（ ） A、主机-网络层 B、应用层
C、传输层网络 D、网络层互联层
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
试题2：下列有关线程的叙述中正确的一项是（ ）
A、使用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行 B、一旦一个线程被创建，它就立即开始运行
C、一个线程可能因为不同的原因而终止并进入终止状态
D、当一个线程因为抢占机制而停止运行时，它被放在可运行队列的前面
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
试题3：下列说法中错误的一项是（ ） A、所有的对共享数据的访问都是临界区
B、共享数据的所有访问都必须使用synchronized加锁 C、临界区必须使用syschronized标识
D、共享数据的访问不一定全部使用synchronized加锁
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2014-4-28 [ 在线测试 ]
试题4：下列说法中错误的一项是（ ）
A、java的线程体由Thread类的run()方法定义 B、java中每一个线程都有自己的名字
C、在程序中通过调用 Thread类的run()方法创建线程对象 D、线程创建时已经确定了提供线程体的对象
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
试题5：下列说法中错误的一项是（ ）
A、private数据访问权限能够数据不被串行化 B、对象串行化使用java语言提供的默认机制 C、可串行化的类必须实现Serializable接口 D、可串行化的类中的静态变量可以不被串行化
试题1：下列关于Thread类提供的线程控制方法的说法中，错误的一项是（ ） A、currentThread()方法返回当前线程的引用
B、在线程A中执行线程B的join()方法，则线程A等待直到B执行完成 C、若线程A调用方法isAlive()返回值为true，则说明A正在执行中 D、线程A通过调用interrupt()方法来中断其阻塞状态 试题2：下列说法中错误的一项是（ ） A、一个线程是一个Thread类的实例 B、线程操作的数据来自Runnable实例
C、新建的线程调用start()方法就能立即进入运行状态 D、线程从传递给Runnable实例run()方法开始执行 试题3：下列说法中错误的一项是（ ） A、线程只能在其创建时设置所属的线程组
B、线程创建之后，可以从一个线程组转移到另一个线程组 C、Java中的第一个线程都属于某个线程组
D、新建的线程默认情况下属于其父线程所属的线程组 试题4：下列哪一个不属于java线程模型的组成部分（ ） A、.虚拟CPU执行的代码 B、虚拟的CPU
C、代码所操作的数据 D、执行流
试题5：下列哪个方法可以使线程从运行状态进入其他阻塞状态（ ）
A、yield B、start C、wait D、sleep
试题1：下列说法中错误的一项是（ ） A、多线程用于实现并发
B、多线程是指一个程序的多个执行流 C、线程就是程序
D、线程是一个程序的单个执行流
试题2：当要将一文本文件当作一个数据库访问，读完一个纪录后，跳到另一个纪录，它们在文件的不同地方时，一般使用（ ）类访问。 A、FileOutputStream B、PipedOutputStream C、BufferedOutputStream D、RandomAccessFile
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2014-4-28 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2014-4-28 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-3-25 [ 在线测试 ]
试题3：当把一个程序、线程或代码段的输出连接到另一个程序、线程或代码段的输入时,应使用的流是（ ）
A、DataOutputStream B、FileOutputStream C、PipedOutputStream D、BufferedOutputStream
试题4：当处理的数据量很多，或向文件输出很多次小数据，一般使用的流是（ ）
A、DataOutputStream B、FileOutputStream C、PipedOutputStream D、 BufferedOutputStream
试题5：下列不属于FileInputStream输入流的read()成员函数的是（ )
A、int read(int line) B、int read(byte b[]) C、int read()
D、int read(byte b[],intoffset,int len)
试题1：下列属于能操作文件输入输出类的是（ ）
A、PipedInputStream和PipedOutputStream B、全部都是
C、FileInputStream和FileOutputStream
D、BufferInputStream和BufferOutputStream 试题2：获取一个不包含路径的文件名的方式为（ ）
A、String getParent() B、String getPath() C、String getName()
D、String getAbslutePath()
试题3：凡是从处理器流向外部设备的数据流称为（ ）
A、字符流 B、输入流 C、文件流 D、输出流
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2014-3-25 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-3-25 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-3-25 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-3-25 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-3-25 [ 在线测试 ]
试题4：下列不是Java的输入输出流的是（ ）
A、文本流 B、文件流 C、字节流 D、字符流
试题5：流的传递方式是（ ) A、无正确选项 B、并行的 C、串行的
D、并行的和串行的
试题1：哪个关键字可以抛出异常？（ ）
A、finally B、throws C、throw D、try
试题2：当方法遇到异常又不知如何处理时，下列哪种说法是正确的( ) A、抛出异常 B、嵌套异常 C、捕获异常 D、声明异常 试题3：
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-3-25 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-3-19 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-3-19 [ 在线测试 ]
在异常处理中，如释放资源、关闭文件、关闭数据库等由( )来完成
A、throw子句 B、try子句 C、catch子句 D、finally子句
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-3-19 [ 在线测试 ]
试题4：对于catch子句的排列，下列哪种是正确的( ) A、父类在先，子类在后
B、先有子类，其他如何排列都无关 C、子类在先，父类在后
D、有继承关系的异常不能在同一个try程序段内 试题5：
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-3-19 [ 在线测试 ]
下列程序的执行，说法正确的是（ ）
A、程序将输出第8行和第19行的异常信息 B、程序将不输出异常信息
C、程序只输出第19行的异常信息 D、程序只输出第8行的异常信息
试题1：
下列程序的执行，说法错误的是（ ）
A、程序将输出第10行的异常信息 B、程序将输出“b=42”
C、程序将输出第10和12行的异常信息 D、程序第5行出错
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2014-3-19 [ 在线测试 ]
试题2：所有异常类的父类（ ） A、Exception B、AWTError C、Error
D、Throwable
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-3-19 [ 在线测试 ]
试题3：java语言中异常处理的出口是下列哪一子句 ( ) A、catch{}子句 B、没有正确选项 C、try{}子句 D、finally{}子句
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-3-19 [ 在线测试 ]
试题4：关于异常，下列说法正确的是 ( )
A、为了保证程序运行速度，要尽量避免异常控制 B、异常是一种对象 C、没有正确答案
D、一旦程序运行，异常将被创建
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-3-19 [ 在线测试 ]
试题5：java中用来抛出异常的关键字是 ( ) A、finally B、throw C、catch D、try
试题1：已知变量定义： int i = 10;
String s = null;
下列代码哪些项会抛出空指针异常：（ ） A、if( i>0 | s.length() ==0 ){ … } B、if( i>0 && s.length() ==0 ){ … } C、if( i>0 & s.length() ==0 ){ … } D、if( i>0 || s.length() ==0 ){ … }
试题2：下述4行代码组成的小程序总共创建String对象的个数为：（ ） String s1 = \"abc\";
String s2 = new String(\"abc\"); String s3 = \"abc\";
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-1-11 [ 在线测试 ]
String s4 = new String(\"abc\"); A、3 B、4 C、2 D、1
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2014-1-11 [ 在线测试 ]
试题3：下列哪些项有编译错误：（ ） A、float f = 1.0 B、long int = 100 C、Integer i = 1000; D、byte b = 200 E、char c = 100000
试题4：下列哪几项可以作为有效的Java标示符：（ ） A、2Name B、$change C、identifier D、_sys_val E、room# 试题5：
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-1-11 [ 在线测试 ]
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-1-11 [ 在线测试 ]
下面关于布局管理器说法正确的是（ ）
A、使用布局管理器可以使JAVA生成的图形用户界面具有平台无关性 B、布局管理器用来管理组件放置在容器中的位置和大小
C、布局管理器LayoutManager本身是一个接口，通常使用的是实现了该接口的类 D、每个容器都有一个布局管理器
试题1：已知变量定义： int i = 10;
String s = null;
下列代码哪些项会抛出空指针异常：（ ） A、if( i>0 | s.length() ==0 ){ … } B、if( i>0 && s.length() ==0 ){ … } C、if( i>0 & s.length() ==0 ){ … } D、if( i>0 || s.length() ==0 ){ … }
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2014-1-11 [ 在线测试 ]
试题2：下述4行代码组成的小程序总共创建String对象的个数为：（ ） String s1 = \"abc\";
String s2 = new String(\"abc\"); String s3 = \"abc\";
String s4 = new String(\"abc\"); A、3
B、4 C、2 D、1
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2014-1-11 [ 在线测试 ]
试题3：下列哪些项有编译错误：（ ） A、float f = 1.0 B、long int = 100 C、Integer i = 1000; D、byte b = 200 E、char c = 100000
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-1-11 [ 在线测试 ]
试题4：下列哪几项可以作为有效的Java标示符：（ ） A、2Name B、$change C、identifier D、_sys_val E、room#
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2014-1-11 [ 在线测试 ]
试题5：
下面关于布局管理器说法正确的是（ ）
A、使用布局管理器可以使JAVA生成的图形用户界面具有平台无关性 B、布局管理器用来管理组件放置在容器中的位置和大小
C、布局管理器LayoutManager本身是一个接口，通常使用的是实现了该接口的类 D、每个容器都有一个布局管理器
试题1：
Java兼容给定是强类型语言，它对变量类型的检查非常严格，同时也提供了一些赋值兼容原则，赋值兼容原则规定（ ）
A、在继承树种不允许向下赋值，既父类实例不允许赋值给子类变量 B、在继承树种不允许向下赋值，既子类实例不允许赋值给父类变量
C、在继承树中允许向上赋值，既父类实例可以赋值给同类变量，还可以赋值给其子类的变量
D、在继承树中允许向上赋值，既子类实例可以赋值给同类变量，还可以赋值给其祖先类的变量
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-23 [ 在线测试 ]
试题2：
关于类继承的描述，正确的描述有（ ）
A、没有直接使用extends关键字说明父类，其直接父类是Object B、子类中通过使用super调用父对象的属性和方法
C、子类可以继承父类的成员，还可以增加自己的属性和方法 D、继承的定义使用关键字extends说明
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-23 [ 在线测试 ]
试题3：
类定义中可以定义构造方法，它是一类特殊的方法，定义类的构造方法应该满足（ ）
A、参数列表必须为空 B、没有返回值
C、名字应该与类名相同 D、必须有参数列表
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-23 [ 在线测试 ]
试题4：
访问权限修饰符有public、private、protected和默认修饰符（没有写任何修饰符），他们既可以用来修饰类，也可以用来修饰类中的成员，使用public修饰符的成员可见情况有（ ）
A、同一包中的非子类 B、同一包中的子类 C、同一类
D、不同包中的子类 E、不同包中的非子类
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-23 [ 在线测试 ]
试题5：
访问权限修饰符有public、private、protected和默认修饰符（没有写任何修饰符），他们既可以用来修饰类，也可以用来修饰类中的成员，使用protected修饰符的成员可见情况有（ ）
A、不同包中的非子类 B、同一包中的子类 C、同一类
D、不同包中的子类 E、同一包中的非子类
试题1：
访问权限修饰符有public、private、protected和默认修饰符（没有写任何修饰符），他们既可以用来修饰类，也可以用来修饰类中的成员，使用无修饰符的成员可见情况有（ ）
A、不同包中的子类 B、同一类
C、不同包中的非子类
D、同一包中的子类 E、同一包中的非子类
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题2：
下列关于类的定义，描述正确的有（ ）
A、类名是用户为该类所起的名字，要遵循标识符的语法要求，并尽量遵循命名约定 B、class前的修饰符可以有多个，用来说明并限定所定义的类的使用方式 C、要将该类定义成一个类的子类，使用关键字extends和implements D、定义一个类使用关键字class
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题3：
break语句可以使用的情况有( )
A、switch语句块 B、函数体语句 C、块语句
D、for、while和do while等循环语句
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题4：
引用数据类型变量具有基本属性为（ ）
A、变量名 B、存储单元 C、变量值 D、数据类型
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题5：
Java提供类型转换机制有（ ）
A、强制类型转换 B、自动类型转换 C、不同类型转换 D、相同类型的换
试题1：
下列是复合数据类型的类型有（ ）
A、数组 B、类
C、接口类型 D、字符串
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题2：
Java的数据类型共分为两大类型，他们是（ ）
A、基本数据类型 B、数组类型
C、复合数据类型 D、自定义数据类型
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-23 [ 在线测试 ]
试题3：
命名规范的主要内容有（ ）
A、变量名一般建议使用名词或名词性词组，变量名的首写字母一般是小写字母，中间单词的首字母大写
B、包的名称通常全部采用小写字母
C、常量名一般全部采用大写字母，如果一个常量由多个单词组成，则单词之间一般用下划线“_”分隔
D、类名或接口名或枚举名一般建议使用名词或名词性词组
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-23 [ 在线测试 ]
试题4：
制定程序编写规范的目标是（ ）
A、提高程序的运行效率
B、缩短程序编写和维护的时间 C、尽量使程序代码的风格一致 D、增强程序的可读性
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题5：
面向对象技术的特性是（ ）
A、多态性 B、封装性 C、有效性 D、继承性
试题1：
下列关于命名习惯正确的做法是（ ）
A、命名常量名中均使用大写形式
B、由于方法及变量名的标识符，首字符小写，而其他各字的首字母大写，非首字符小写
C、用于类及接口名的标识符，名字的首写字母都大写，其他字符都小写
D、尽量不要在方法名和变量名中使用下画线，还要避免使用美元符合，因为该字母对内部类有特殊含义
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题2：
下面关于Java语言说法正确的是（ ）
A、Java语言具有可移植性，是与平台无关的编程语言 B、Java语言是面向对象的、解释执行的网络编程语言 C、Java语言可对内存垃圾自动收集
D、 Java语言编写的程序虽然是“一次编译，到处运行”，但必须要有Java的运行环境
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-23 [ 在线测试 ]
试题3：
编译运行下面的代码会发生什么情况为（ ） public class Bground extends Thread{ public static void main(String argv[]) {
Bground b = new Bground(); b.run(); }
public void start() {
for (int i = 0; i <10; i++){
System.out.println(\"Value of i = \" + i); } } }
A、运行时错误，Thread类中的run方法没有定义 B、编译无错，不打印任何值 C、编译无错，打印0到9
D、编译错误，Thread类中的run方法没有定义
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题4：
关于下面一段代码，描述正确的是（ ） public class Agg {
public static void main(String argv[]) { Agg a = new Agg(); a.go();
}
public void go() {
DSRoss ds1 = new DSRoss(\"one\"); ds1.start(); } }
class DSRoss extends Thread { private String sTname = \"\";
DSRoss(String s) { sTname = s; }
public void run() { notwait();
System.out.println(\"finished\"); }
public void notwait() { while (true) { try {
System.out.println(\"waiting\"); wait();
} catch (InterruptedException ie) { }
System.out.println(sTname); notifyAll(); } } }
A、能够编译, 输出“waiting\"，紧接着输出\"finish\" B、运行时错误，会抛异常 C、能够编译，输出“waiting\" D、编译错误
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-23 [ 在线测试 ]
试题5：
编译运行下面的代码会发生什么( ) public class Test extends Thread { private String sThreadName;
public static void main(String argv[]) {
Test h = new Test(); h.go(); }
Test() { }
Test(String s) {
sThreadName = s; }
public String getThreadName() { return sThreadName; }
public void go() {
Test first = new Test(\"first\"); first.start();
Test second = new Test(\"second\"); second.start(); }
public void start() {
for (int i = 0; i < 2; i++) {
System.out.println(getThreadName() + i); try {
Thread.sleep(100);
} catch (InterruptedException e) {
System.out.println(e.getMessage()); } } } }
A、输出first0, first1, second0, second1. B、运行时错误
C、输出first0, second0, first1, second1 D、编译错误
试题1：
编译运行下面的代码会发生什么( ) public class Test {
public static void main(String argv[]) {
Pmcraven pm1 = new Pmcraven(\"one\"); pm1.run();
Pmcraven pm2 = new Pmcraven(\"two\"); pm2.run(); } }
class Pmcraven extends Thread { private String sTname = \"\";
Pmcraven(String s) { sTname = s; }
public void run() {
for (int i = 0; i < 2; i++) { try {
sleep(1000);
} catch (InterruptedException e) { }
yield();
System.out.println(sTname); } } }
A、输出Two Two One One B、输出One One Two Two C、输出One Two One Two D、编译错误
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题2：
在Java中不存在的布局方式是( )
A、流布局（FlowLayout） B、布局（CenterLayout） C、网络布局（GridLayout） D、边界布局（BorderLayout）
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-23 [ 在线测试 ]
试题3：
下面关于事件监听的说明，哪一个语句是正确的？（ ）
A、机制允许按照我们的需要，任意调用addXxxxListener 方法多次，而且没有次序区别
B、如果多个加在一个组件上，那么事件只会触发一个
C、所有组件，都不允许附加多个 D、组件不允许附加多个
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-23 [ 在线测试 ]
试题4：
下列Java常见事件类中哪个是鼠标事件类？（ ）
A、InputEvent B、WindowEvent C、MouseEvent D、KeyEvent
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-23 [ 在线测试 ]
试题5：
假设你正在为应用系统设计一个Java图形用户界面（GUI），需要能输入多行文本信息，下列组件中最能满足这个要求的是( )
A、Label B、TextArea C、Checkbox D、TextField
试题1：
阅读下列程序
import java.awt.Button; import java.awt.GridLayout; import java.awt.Panel; import javax.swing.*;
public class X extends JFrame{ public X(){
setLayout(new GridLayout(2,2)); JPanel p1=new JPanel(); add(p1);
JButton b1=new JButton(\"One\"); p1.add(b1);
JPanel p2=new JPanel(); add(p2);
JButton b2=new JButton(\"Two\"); p2.add(b2);
JButton b3=new JButton(\"Three\"); p2.add(b3);
JButton b4=new JButton(\"Four\"); add(b4); }
public static void main(String[] args){
X x=new X(); x.pack();
x.setVisible(true); } }
当frame改变大小时，下面正确的描述为（ ）
A、Button \"Three\" 改变宽度 B、Button \"One\" 改变高度 C、Button \"Two\"改变高度
D、Button \"Four\"改变高度和宽度
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-23 [ 在线测试 ]
试题2：
关于以下程序段的说法，类包含不考虑情况下，正确的是（ ） 1．class MyListener implements
2． ActionListener，ItemListener{
3． public void actionPerformed（ActionEvent ae）{ 4． System.out.println(\"Action\");}
5． public void itemStateChanged(ItemEvent ie){ 6． System.out.println(\"Item\"); 7． } 8．}
A、第5行产生编译错误 B、可通过编译
C、第3行产生编译错误 D、第2行产生编译错误
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-23 [ 在线测试 ]
试题3：
以下说法哪项是正确的（ ） 1．class MyListener
2．extends MouseAdapter implements MouseListener{ 3． public void mouseEntered（MouseEvent mev） 4． { System.out.println(\"Mouse entered.\"); } 5． }
A、不能通过编译，因为类头定义不能分行
B、不能通过编译，因为没有实现MouseListener接口中的所有方法
C、能通过编译，若组件用该类作为Mouse的监听者并且接收了mouse-exited事件，则在执行过程中会抛出异常 D、以上代码可通过编译
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-23 [ 在线测试 ]
试题4：
下列哪个布局管理器中的按钮位置有可能会根据JFrame的大小改变而改变？（ ）
A、FlowLayout B、BorderLayout C、CardLayout D、GridLayout
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-23 [ 在线测试 ]
试题5：
下列哪个是不属于容器的组件？（ ）
A、JFrame B、JPanel C、JButton D、JApplet
试题1：
关于以下的组件的接口，正确的是（ ）
A、Choice组件可实现的接口是ActionListener B、以上都不对
C、TextArea组件可实现的接口是ActionListener
D、List组件可实现的接口，除了ItemListener，还可以是ActionListener
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题2：
监听事件和处理事件（ ）
A、由Listener和构件分别完成 B、都由Listener完成
C、都由相应事件Listener处登记过的构件完成 D、由Listener和窗口分别完成
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题3：
Character流与Byte流的区别是（ ）
A、每次读入的字节数不同
B、前者是块读写，后者是字节读写 C、前者带有缓冲，后者没有 D、二者没有区别，可以互换使用
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-23 [ 在线测试 ]
试题4：在代码中使用catch(Exception e)的好处是( ) A、执行一些程序 B、忽略一些异常
C、捕获try块中产生的所有类型的异常 D、只会捕获个别类型的异常
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题5：
下列常见的系统定义的异常中，哪个是输入、输出异常?（ ）
A、ClassNotFoundException B、FileNotFoundException C、UnknownHostException D、IOException
试题1：
异常包含下列哪些内容？（ ）
A、程序事先定义好的可能出现的意外情况 B、程序的编译错误
C、程序执行过程中遇到的事先没有预料到的情况 D、程序中的语法错误
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-23 [ 在线测试 ]
试题2：
下面的程序段执行后输出的结果是（ ）。
StringBuffer buf=new StringBuffer(\"China2008\"); buf.insert(5,\"@\");
System.out.println(buf.toString（ ）);
A、@China2008 B、China2008@ C、China#2008 D、 China@2008
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题3：
String或StringBuffer类的对象在调用以下哪个方法时其自身会发生更改？（ ）
A、StringBuffer类的reverse ()方法 B、String类的toUpperCase()方法 C、StringBuffer类的length ()方法 D、String类的replace()方法 E、String类的charAt()方法
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-23 [ 在线测试 ]
试题4：
下列数组初始化形式正确的是( )
A、int t3[3][2]={1,2,3,4,5,6}; B、int t1[][]={{1,2},{3,4},{5,6}}; C、 int t4[][]; t4={1,2,3,4,5,6}; D、 int t2[][]={1,2,3,4,5,6};
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
有整型数组：int[] x={2,33,88,5,10};, 则调用方法 Arrays.sort(x) 后，数组x中的元素值依次是（ ）
A、88102335 B、25103388 C、 53321088 D、88331052
试题1：
执行完以下代码int [ ] x = new int[10]；后，以下哪项说明是正确的（ ）
A、x[0]为空 B、 x[9]未定义 C、x[10]为0 D、 x[9]为0
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
编译下列源程序会得到哪些文件?（ ） class A1{ }
class A2{ }
public class B{
public static void main(String args[]){ } }
A、只有B.class B、编译不成功
C、有A1.class、A2.class和B.class文件 D、只有A1.class和 A2.class文件
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
下列哪一项说法最好地描述了Java中的对象？（ ）
A、对象是通过import命令引入到程序中的所有事情 B、对象是一种数据结构，它具有操作数据的方法 C、对象是一组具有共同的结构和行为的类
D、对象是方法的集合，这些方法在小程序窗口或应用程序窗口中产生图形元素，或者计算和返回值
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
类Test1、Test2定义如下： 1． public class Test1
2．{ public float aMethod（float a，float b） throws 3． IOException { } 4． }
5． public class Test2 extends Test1{ 6． 7．}
将以下哪种方法插入行6是不合法的。（ ）
A、public int aMethod（int a，int b）throws IOException{ } B、 public float aMethod（float p，float q）{ }
C、public int aMethod（int a，int b）throws Exception{ } D、float aMethod（float a，float b）{ }
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
下列哪种说法是正确的？（ ）
A、私有方法不能被子类覆盖
B、子类可以覆盖超类中的任何方法
C、覆盖方法中的参数清单必须是被覆盖方法参数清单的子集 D、覆盖方法可以声明自己抛出的异常多于那个被覆盖的方法
试题1：
关于类继承的说法，正确的是（ ）
A、接口和类都允许多继承 B、Java接口允许多继承 C、接口和类都不允许多继承 D、Java 类允许多重继承
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
使用以下哪个保留字可以使只有在定义该类的包中的其他类才能访问该类？（ ）
A、protected B、不使用保留字 C、private D、abstract
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
为了区分重载多态中同名的不同方法，要求( )
A、返回值类型不同
B、调用时用类名或对象名做前缀 C、采用不同的参数列表 D、参数名不同
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
下列关于构造方法的叙述中，错误的是（ ）
A、Java语言规定构造方法没有返回值，但不用void声明 B、Java语言规定构造方法不可以重载
C、Java语言规定构造方法只能通过new自动调用 D、Java语言规定构造方法名与类名必须相同
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
如果str表示一个String对象“73”，那么以下哪些表达式将会把这个字符串转换为int值73？请选出正确答案。（ ）
A、Integer.getInt(str)
B、(new Integer(str)).intValue() C、Integer.intValue(str) D、((int) str)
试题1：
下列哪个类的声明是正确的？（ ）
A、protected private number B、abstract final class HI{} C、public abstract class Car{} D、abstract private move(){}
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
以下声明合法的是（ ）
A、abstract final double hyperbolicCosine( ) B、default String C、abstract double d
D、 public final static native int w( )
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
类Test1定义如下： 1．public class Test1{
2． public float aMethod（float a，float b）{ } 3． 4．}
将以下哪种方法插入行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）{ }
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
下面是Example.java文件的完整代码，请找出会产生编译错误的行（ ）。 1. class BaseClass { 2. public String str;
3. public BaseClass（ ）{ 4. System.out.println(“ok”);} 5. public BaseClass(String s){ 6. str=s;}}
7. class SubClass extends BaseClass{ 8. }
9. public class Example{
10. public void method（ ）{
11. SubClass s=new SubClass(“hello”); 12. BaseClass b=new BaseClass(“world”); 13. } 14. }
A、11 B、12 C、10 D、7
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
下面关于类的说法错误的是（ ）
A、类是对所有具有一定共性的对象的抽象 B、Java语言的类支持单继承和多继承 C、类是Java语言中的一种复合数据类型 D、类中包含数据变量和方法
试题1：
下列关于变量的叙述哪个是错的？（ ）
A、在方法中定义的局部变量在该方法被执行时创建 B、实例变量是类的成员变量 C、实例变量用关键字static声明 D、局部变量在使用前必须被初始化
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
已知A类被打包在packageA , B类被打包在packageB ，且B类被声明为public ，且有一个成员变量x被声明为protected控制方式。C类也位于packageA包，且继承了B类。则以下说法正确的是（ ）
A、C类的实例可以访问到B类一个实例的x成员 B、 C类的实例不能访问到B类的实例
C、A类的实例能够访问到B类一个实例的x成员 D、A类的实例不能访问到B类的实例
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
下面关于Java语言中实例方法和类方法的说法，哪项是对的？（ ）
A、类方法可以操作实例变量也可以操作类变量 B、类方法可以直接通过类名调用
C、实例方法可以操作实例变量也可以操作类变量 D、实例方法可以直接通过类名调用
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
下列说法正确的是( )
A、abstract可修饰类、属性、方法 B、final 可修饰类、属性、方法
C、用final修饰的变量，在程序中可对这个变量的值进行更改 D、定义抽象方法需有方法的返回类型、名称、参数列表和方法体
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
Java语言的类间的继承关系是( )
A、线程的 B、多重的 C、不能继承 D、单重的
试题1：
下列有关子类继承父类构造函数的描述正确的是( )
A、子类无法继承父类的构造函数
B、子类必须通过super关键字调用父类的构造函数 C、子类无条件地继承父类不含参数的构造函数
D、创建子类的对象时，先调用子类自己的构造函数，然后调用父类的构造函数
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
关于以下application的说明，正确的是（ ） 1． class StaticStuff 2． {
3． static int x=10； 4． static { x+=5；}
5． public static void main（String args[ ]） 6． {
7． System.out.println(“x=” + x); 8． }
9． static { x/=3;} 10. }
A、4行与9行不能通过编译，因为缺少方法名和返回类型 B、编译通过，执行结果为：x=5 C、编译通过，执行结果为：x=3
D、9行不能通过编译，因为只能有一个静态初始化器
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
以下关于abstract的说法，正确的是（ ）
A、abstarct方法所在的类必须用abstract修饰 B、 abstract只能修饰类 C、abstract只能修饰方法
D、abstract类中必须有abstract方法
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
关于以下程序代码的说明正确的是（ ） 1．class HasStatic{
2． private static int x=100；
3． public static void main(String args[ ]){ 4． HasStatic hs1=new HasStatic( ); 5． hs1.x++;
6． HasStatic hs2=new HasStatic( ); 7． hs2.x++;
8． hs1=new HasStatic( ); 9． hs1.x++;
10． HasStatic.x- -;
11． System.out.println(“x=”+x); 12． } 13． }
A、程序通过编译，输出结果为：x=102 B、程序通过编译，输出结果为：x=103
C、10行不能通过编译，因为x是私有静态变量 D、5行不能通过编译，因为引用了私有静态变量
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
下面哪个关键字不是用来控制对类成员的访问的？（ ）
A、protected B、public C、private D、default
试题1：
下列哪个命题为真？（ ）
A、构造函数必须有返回值
B、所有类都必须定义一个构造函数 C、构造函数可以访问类的非静态成员 D、构造函数必须初始化类的所有数据成员
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
下列关于构造方法使用的描述正确的是（ ）
A、程序员可以在程序中调用对象的构造方法 B、以上都不对
C、在对象消除时，调用构造方法
D、构造方法仅供虚拟机调用，当系统完成对象的创建后，自动调用相应的构造方法
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
在Java语言中，当定义一个变量为基本数据类型时，Java的JVM就为该变量分配内存，并给该变量赋初值，当定义一个复合数据类型变量时，该变量代表该类型对象的引用名，Java的JVM并不为对象创建内存空间，该变量引用的值为null，要创建对象实例，需要使用的关键字为（ ）
A、new B、 this C、public D、super
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：访问权限修饰符有public、private、protected和默认修饰符（没有写任何修饰符），他们既可以用来修饰类，也可以用来修饰类中的成员，使用private修饰符的成员可见情况有（ ）
A、同一包中的非子类 B、不同包中的子类 C、同一包中的子类 D、同一类
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
下面是Java的Boolean对象的值为（ ）
A、false B、true
C、new Boolean(true) D、Boolean
试题1：
关于以下程序段，正确的说法是（ ） 1． String s1=”abc”+”def”;
2． String s2=new String（s1）； 3． if（s1= =s2）
4． System.out.println(“= = succeeded”); 5． if (s1.equals(s2))
6． System.out.println(“.equals() succeeded”);
A、行4执行，行6不执行 B、行6执行，行4不执行 C、行4与行6都将执行 D、行4、行6都不执行
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
java程序运行时，用于判定一个对象实例的类型运算符是（ ）
A、equal B、以上都对 C、instanceof D、 ==
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
结构化程序设计所规定的三种基本控制结构是（ ）
A、主程序、子程序、函数 B、顺序、选择、循环 C、输入、处理、输出 D、树形、网形、环形
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
下列程序代码段运行后,变量x的结果是( ) int x=0; int y=3; switch(y){ case 1:x++; case 2:x++;x++; case 3:x++;x++;x++; case 4:x+=4; }
A、10 B、3 C、 7 D、 6
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
下列程序段运行后，变量temp的值是（ ） int temp = 2 ; temp++; temp*=5; temp/=2；
A、7 B、15
C、2 D、7.5
试题1：
下列程序段运行后，变量x,y,z的值描述正确的是（ ） int x=1;
int y=(x++)*2; int z=(--y)*3;
A、x的值是1，y的值是1，z的值是6 B、x的值是2，y的值是1，z的值是6 C、x的值是2，y的值是1，z的值是3 D、x的值是1，y的值是2，z的值是3
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
编译运行以下程序后，关于输出结果的说明正确的是（ ） 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 9 B、输出结果为：value is 9.0 C、输出结果为：value is 99.99 D、编译错误
类别：[ 选择类 ] 难度：[ 较难 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
以下程序的运行结果是：（ ） public class Increment{
public static void main(String args[]){ int c; c = 2;
System.out.print(c); System.out.print(c++); System.out.println(c); } }
A、2 3 3 B、2 2 3
C、 2 2 2 D、3 4 4
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
Java语言正确的常量修饰符应该是（ ）
A、static
B、static final
C、public static final D、final
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
阅读以下代码： import java.io.*; import java.util.*; public class foo{
public static void main (String[] args){ String s;
System.out.println(\"s=\" + s); } }
输出结果应该是（ ）
A、由于String s没有初始化，代码不能编译通过 B、代码得到编译，并输出“s=null”
C、代码得到编译，但捕获到 NullPointException异常 D、代码得到编译，并输出“s=”
试题1：
下列选项中哪一个是表达式1 + 2 + \"aa\" + 3的值（ ）
A、\"12aa3\" B、\"aa3\" C、\"3aa3\" D、\"12aa\"
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
在switch（expression）语句中，expression的数据类型不能是( )
A、double B、char
C、byte D、short
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
下列哪一项不是Java保留字？（ ）
A、super B、sizeof C、break D、abstract
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
下面不属于Java关键字的是（ ）
A、sealed B、 transient C、new D、private
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
下列整型数据类型中，需要内存空间最少的是（ ）
A、long B、int C、byte D、short
试题1：
当在命令行输入：java myprog good morning 运行以下代码，输出结果是（ ） public class myprog{
public static void main(String argv[]) {
System.out.println(argv[2]); } }
A、Exception raised: \"java.lang.ArrayIndexOutOfBoundsException: 2\" B、myprog C、good D、morning
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
下列描述中，错误的是（ ）
A、Java内含多线程机制
B、Java的安全性体现在多个层次上 C、Java要求编程者管理内存
D、Applet要求在支持Java的浏览器上运行
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
Java应用程序的入口方法是（ ）
A、start（) B、init（） C、main（） D、paint（）
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
一个可以运行的Java应用程序( )
A、可以有一个或多个main方法 B、可以有一个或零个main方法 C、最多只能有两个main方法 D、只能有一个main方法
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：
在Java中，关于CLASSPATH环境变量的说法不正确的是（ ）
A、编译器用它来搜索各自的类文件 B、CLASSPATH是一个目录列表 C、解释器用它来搜索各自的类文件
D、CLASSPATH设置之后不可修改，但可以将目录添加到该环境变量中
试题1：
Java的JVM是指（ ）
A、Java源代码的编译器
B、运行Java 所需的硬件设备
C、由Java操作的家用设备（通常是一个漂亮的小烤箱） D、Java字节代码的解释程序
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题2：
运行jar文件中class文件需要在java命令后面加的参数为（ )
A、cp B、-g
C、-verbose D、-d
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题3：
Java JDK中编译的命令是（ )
A、jdb B、 java C、javah D、 javac
类别：[ 选择类 ] 难度：[ 容易 ] 入库时间：2013-12-22 [ 在线测试 ]
试题4：
Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点？（ ）
A、安全性 B、可移植 C、跨平台 D、多线性
类别：[ 选择类 ] 难度：[ 中等 ] 入库时间：2013-12-22 [ 在线测试 ]
试题5：下列关于Java语言的特点，描述错误的是（ ） A、Java支持分布式计算 B、Java是跨平台的编程语言 C、Java是面向过程的编程语言 D、Java支持多线程
试题1：BufferedWriter的方法newLine()可以写入一个 。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-12-16
试题2：Java中一个字符占用两个字符，所有字符采用的都是 编码表。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-12-16
试题3：
在Java流操作中，可以用于将字节输入流转换为字符输入流的类是 。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-12-16
试题4：
在Java中， 类用于操作磁盘中的文件和目录。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-12-16
试题5：
java.util包中提供了一个专门用来操作集合的工具类，这个类是 ，还提供了一个专门操作数组的工具类，这个类是 。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-12-16
试题6：集合按照存储结果的不同可分为单列集合和双列集合，单列集合的根接口是 ，双列集合的根接口是 。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-12-16
试题7：
使用Iterator遍历集合时，首先需要调用 方法判断是否存在下一个元素，如果存在下一个元素，则调用 方法取出该元素。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-12-16
试题8：
要将某个线程设置为后台线程，需要调用该线程的 方法，该方法必须在该线程启动之前调用。
类别：[ 填空类 ] 难度：[ 较难 ] 入库时间：2015-11-29
试题9：在Thread类中，提供了一个start()方法，该方法用于开启一个新线程，当新线程启动后，系统会自动调用 方法。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-11-29
试题10：线程的优先级用1~10之间的整数来表示，其中 代表优先级最高。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-11-29
试题1：
线程类型中的yield()方法只能让相同优先级或者更高优先级、处于 状态的线程获得运行机会。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-11-29
试题2：
一个应用程序中有多条并发执行的线索，每条线索都被称作一个 ，他们会交替执行，彼此间可以进行 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-11-27
试题3：
在Java语言中，所有的类都直接或间接继承自 类。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-11-8
试题4：
如果子类想使用父类中的成员，可以通过关键字 引用父类中的成员。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-11-8
试题5：
定义一个Java类时，如果前面使用 关键字修饰，那么该类不可以被继承。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-11-8
试题6：在程序开发中，要想将一个包中的类导入到当前程序中，可以使用 关键字。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-11-8
试题7：一个类如果实现一个接口，那么它需要实现接口中的全部 ，否则该类就必须定义为 。
类别：[ 填空类 ] 难度：[ 较难 ] 入库时间：2015-11-8
试题8：
在Java语言中，允许使用已存在的类作为基础创建新的类，这种技术称为 。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-11-8
试题9：
当一个对象被当成垃圾从内存中释放时，它的 方法会被自动调用。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-10-25
试题10：在非静态成员方法中，可以使用关键字 访问类的其他非静态成员。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-10-25
试题1：
在Java语言中，可以使用关键字 来创建类的实例对象。 类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-10-25 试题2：Java中的变量可以分为两种数据类型，分别是 和 。 类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2015-9-29 试题3：Java中的注释可分为三种类型，分别是 、 、 。 类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-9-29 试题4： javac.exe和java.exe两个可执行程序存放在JDK安装目录的 目录下。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-9-29
试题5：
Java程序的运行环境简称为 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-9-29
试题6： Java的三大技术平台分别是 、 、 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2015-9-29
试题7：JPanel的默认布局管理器是 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-5-29
试题8：Swing的事件处理机制包括 、事件和事件处理者。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2014-5-29
试题9：对象型数组的默认值是 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-4-29
试题10：浮点型数组的默认值是 。
试题1：向方法传递数组参数时，传递的是数组的 。 试题2：如果把二维数组看成一维数组，那么数组的元素
是 数组。
试题3： 矩阵或表格一般用 维数组表示。
试题4：数组复制时，\"=\"将一个数组的 传递给另一个数组。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2014-4-29
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2014-4-29
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-4-29
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-4-29
试题5：数组的元素通过 来访问，数组Array的长度为 。
试题6：在操作系统中，被称做轻型的进程是 。 试题7：Java语言中为了类的对象支持序列化，该类的定义中必须实现 。 试题8：
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-4-29
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-4-28
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-4-4
下列程序实现从当前目录的date.ser文件中读取文件内容并显示出来.请将程序补充完整. import java.io.*;
import java.util.Date;
public class UnSerializeDate { UnSerializeDate() { Date d=null; try { FileInputStream f=new _________(“date.ser”); ObjectInputStream s=new ObjectInputStream(________); d=(Date) s.readObject(); f.close(); } catch(Exception e) { e.printStackTrace(); } System.out.println(“Unserialized Date object from date.set”); System.out.println(“Date:”+d); } public static void main(String args[]) { new UnSerializeDate(); } }
类别：[ 填空类 ] 难度：[ 较难 ] 入库时间：2014-3-25
试题9：下列程序实现从控制台输入并读取输出字符串.请将程序补充完整 import java.io.*;
public class CharInput {
public static void main(String args[]) throws java.io.IOException{ String s;
InputStreamReader ir; BufferedReader in;
ir=new____________(System.in); in=new____________(ir);
while ((s=in._________)!=null) {
System.out.println(“Read;”+s); } } }
类别：[ 填空类 ] 难度：[ 较难 ] 入库时间：2014-3-25
试题10：java.io中的一个重要的非流类,里面封装了对文件系统进行操作的功能,这样的类是 .。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-3-25
试题1：DataOutputStream数据流向文件里写数据的方法为__________
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-3-25
试题2：Java中的字符输出流都是抽象类________的子类.
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-3-25
试题3：java对I/O访问还提供了同步处理机制,保证某时刻只有一个线程访问一个I/O流,这就是_______.
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2014-3-25
试题4：Java中的非字符输出流都是_________抽象类的子类。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2014-3-25
试题5：Java的输入输出流包括__________、字符流、文件流、对象流以及多线程之间通信的管道。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-3-25
试题6：Throwable类有两个子类：_________类和Exception类。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2014-3-19
试题7：java语言的类库中提供了一个__________类，所有的异常都必须是它的实例 或它子类的实例。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2014-3-19
试题8：捕获异常的统一出口通过_________语句实现。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-3-19
试题9：抛出异常、生成异常对象都可以通过_________语句实现。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2014-3-19
试题10：抛出异常的程序代码可以是______或者是JDK中的某个类，还可以是JVM.
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-3-19
试题1：java语言认为那些可预料和不可预料的出错称为_________。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-3-19
试题2：捕获异常要求在程序的方法中预先声明，在调用方法时用try-catch-______语句捕获并处理。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2014-3-19
试题3：catch子句都带一个参数，该参数是某个异常的类及其变量名，catch用该参数去与 ___________对象的类进行匹配。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2014-3-19
试题4：接口的所有成员域都具有public、static和 属性。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2013-12-24
试题5：java默认导入的包是 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题6：java中导入类使用的关键字是 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题7：
以下程序的运行结果是 。 public class ChangeStrDemo {
public static void changestr(String str){ str=\"welcome\"; }
public static void main(String[] args) { String str=\"1234\"; changestr(str);
System.out.println(str); } }
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2013-12-24
试题8：以下程序的运行结果是 。 class First{ public First(){ aMethod(); }
public void aMethod(){
System.out.println(“in First class”);} }
public class Second extends First{ public void aMethod(){
System.out.println(“in Second class”);} public static void main(String[ ] args){ new Second( ); } }
类别：[ 填空类 ] 难度：[ 较难 ] 入库时间：2013-12-24
试题9：
以下程序的运行结果是 。 public class FooDemo{ static boolean foo(char c) { System.out.print(c); return true;
}
public static void main(String[] args ) { int i =0;
for ( foo(’a’); foo(’b’)&&(i<2); foo(’c’)){ i++ ; foo(’d’); } } }
类别：[ 填空类 ] 难度：[ 较难 ] 入库时间：2013-12-24
试题10：
下程序的运行结果为 。 class OverloadDemo{
void testOverload( int i ){ System.out.println(“int”); }
void testOverload(String s){ System.out.println(“String”); }
public static void main(String args[ ]){
OverloadDemo a=new OverloadDemo ( ); char ch=’x’;
a.testOverload(ch); } }
试题1：在Java中，一切都是对象，类中包含两个部分，分别是变量和方法。类中定义的方法称为 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题2：int x=300;byte y=(byte)x;y的值大小是 。
类别：[ 填空类 ] 难度：[ 较难 ] 入库时间：2013-12-24
试题3：int x=300;char y=(char)x;y的值大小是 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题4：强制类型转换发生在占用内存位数多的类型向占用内存少的类型转换过程中，程序员在设置转换的格式为：将希望得到的数据类型放到 内，置于要转换的值的前面。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题5：Java程序中当两个操作数为float或double时，其运算结果的类型为 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题6：Java程序中当两个操作数为int或float时，其运算结果的类型为 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题7：Java程序中当两个操作数为byte或short时，其运算结果的类型为 。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2013-12-24
试题8：
Java是强类型语言，当不同类型量共同参与运算时，需要先统一他们的类型，然后才能进行运算，类型转换的原则是：让两个占位大小不同的操作数 ，然后进行运算。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2013-12-24
试题9：程序int x = 16; int y= x<100?x*100:x*10; 变量y值是 。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2013-12-24
试题10：程序int x = 16; int y= 32; 表达式 (x>3*y)|| (y>x)的值是 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题1：++是一元算术运算符，a ++表示先使用a的值，然后a的值再加1，而++a则表示 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题2：++是一元算术运算符，a++表示 ，而++a则表示先让a加1，然后再使用a的值。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题3：每个运算符都要带一个或多个操作数，带一个操作数的运算符习惯称为一元运算符，带二个操作数的运算符习惯称为 运算符，带三个操作数的运算符习惯称为三元运算符。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题4：
表达式中仅含有逻辑运算符的表达式称为逻辑表达式，逻辑表达式的运算结果是一个 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题5：表达式中仅含有关系运算符的表达式称为关系表达式，关系表达式的运算结果是一个 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题6：表达式中仅含有算术运算符的表达式称为算术表达式，算术表达式的运算结果是一个 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题7：程序中的表达式是有操作数及运算符组成，其中运算符依据其操作的性质分为算术运算符、关系运算符及 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题8：程序中的表达式是有操作数及运算符组成，其中运算符依据其操作的性质分为算术运算符、 及逻辑运算符。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题9：程序中的表达式是有操作数及运算符组成，其中运算符依据其操作的性质分为 、关系运算符及逻辑运算符。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题10：Java定义的变量要求赋初值，如果没有显式赋值，整型变量获得的值是0,实型变量的值是0.0，布尔类型数据的量是false,复合数据变量的值是 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题1：Java定义的变量要求赋初值，如果没有显式赋值，整型变量获得的值是0,实型变量的值是0.0，布尔类型数据的量是 ,复合数据变量的值是分null。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题2：Java定义的变量要求赋初值，如果没有显式赋值，整型变量获得的值是0,实型变量的值是 ，布尔类型数据的量是false,复合数据变量的值是分null。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题3：Java定义的变量要求赋初值，如果没有显式赋值，整型变量获得的值是 ,实型变量的值是0.0，布尔类型数据的量是false,复合数据变量的值是分null
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题4：使用关键字 修饰的量是常量，这种量必须赋初值。
类别：[ 填空类 ] 难度：[ 中等 ] 入库时间：2013-12-24
试题5：程序中用到字符型常量，常量值必须用一对 括起来。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题6：逻辑类型也称为布尔类型，它的值只有两个，即“真”和“假”，它在内存中只占 个字节。他的字的常量值为true和false。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题7：逻辑类型也称为布尔类型，它的值只有两个，即“真”和“假”，它在内存中只占1个字节。他的常量值为 。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题8：浮点数也有常量形式，如果一个数值中包含小数点、指数部分（字符E）、或其后跟有字符F或字符 ，则这个常数就是浮点数。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题9：Java提供了两种实型量，一种是 ，用float关键字说明，另一种是 ，用double关键字说明，他们都是有符合数。float数在内存占4字节数，double型的量在内存中占8个字节数。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题10：
Java中预定义的数据类型中都有对应的常量，对于整型直接数，他的形式又有多种，以1-9开头的正负整数为十进制，以0开头的正负整数为八进制数，以0x或者0X开头的正负整数为 数。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题1：
Java中预定义的数据类型中都有对应的常量，对于整型直接数，他的形式又有多种，以1-9开头的正负整数为十进制，以0开头的正负整数为 数，以0x或者0X开头的正负整数为十六进制数。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题2：Java中预定义的数据类型中都有对应的常量，对于整型直接数，他的形式又有多种，以1-9开头的正负整数为 ，以0开头的正负整数为八进制数，以0x或者0X开头的正负整数为十六进制数。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题3：整数类型是用来表示整数的数据类型，Java提供了4种整型量，分别是byte、short、int 和 ，他们在内存总占用的字节数依次从小到大，分别为1个、2个、4个和 个。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题4：整数类型是用来表示整数的数据类型，Java提供了4种整型量，分别是byte、 、int 和long，他们在内存总占用的字节数依次从小到大，分别为1个、 个、4个和8个。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题5：整数类型是用来表示整数的数据类型，Java提供了4种整型量，分别是 、short、int 和long，他们在内存总占用的字节数依次从小到大，分别为 个、2个、4个和8个。
类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24
试题6：
Java程序可以分为 和 两种。 类别：[ 填空类 ] 难度：[ 容易 ] 入库时间：2013-12-24 试题7：在Java程序设计中，程序员创建 文件，然
试题1：一般来说，把字符转换成计算机识别的字节序列称为解码，而把字节序列转换为普通人能看懂的明文字符称为编码。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题2： InputStream类的close()方法是用于关闭并释放流所占的系统资源。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题3：如果一个File对象表示的目录下有文件者有子目录，调用delete()方法也可以将其删除。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题4：使用Iterator迭代集合元素时，可以调用集合对象的方法增删元素。（ ）
类别：[ 判断类 ] 难度：[ 较难 ] 入库时间：2015-12-16 [ 在线测试 ]
试题5：集合中不能存储基本数据类型，而只能存储引用数据类型。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-12-16 [ 在线测试 ]
试题6：线程结束等待或者阻塞状态后，会进入运行状态。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2015-11-29 [ 在线测试 ]
试题7：静态方法不能使用synchronized关键字来修饰。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2015-11-29 [ 在线测试 ]
试题8：同步代码块中的锁对象可以是任意类型的对象。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2015-11-29 [ 在线测试 ]
试题9：如果前台线程全部死亡，后台线程也会自动死亡。（ ）
类别：[ 判断类 ] 难度：[ 较难 ] 入库时间：2015-11-29 [ 在线测试 ]
试题10：当创建一个线程对象时，该对象表示的线程就立即开始运行。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-11-29 [ 在线测试 ]
试题1：接口中只能定义常量和抽象方法。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2015-11-8 [ 在线测试 ]
试题2： package声明语句应该为Java源文件中的第一条语句。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-11-8 [ 在线测试 ]
试题3： Java中被final关键字修饰的变量，不能被重新赋值。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-11-8 [ 在线测试 ]
试题4： 抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2015-11-8 [ 在线测试 ]
试题5：声明构造方法时，不能使用private关键字修饰。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2015-10-25 [ 在线测试 ]
试题6：
Java中的每个类都至少有一个构造方法，一个类中如果没有定义构造方法，系统会自动为这个类创建一个默认的无参构造方法。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-10-25 [ 在线测试 ]
试题7： 0xC5表示的是一个十六进制整数。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-9-29 [ 在线测试 ]
试题8： Java语言不区分大小写。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2015-9-29 [ 在线测试 ]
试题9：每一时刻，一个容器只能有一个布局管理器。
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2014-5-29 [ 在线测试 ]
试题10：在Swing中用重量级的组件替代了AWT中的轻量级的组件。
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-5-29 [ 在线测试 ]
试题1：Java的图形用户界面的最基本组件部分就是组件(Compnent)。
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-5-29 [ 在线测试 ]
试题2：容器java.awt.Container是Compnent的子类，一个容器可以容纳多个组件，并使他们成为一个整体。
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-5-29 [ 在线测试 ]
试题3：java.awt包是Java语言用来构建图形用户界面GUI的类库。
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-5-29 [ 在线测试 ]
试题4：用任何方式创建数组时，都必须指定数组的长度。( )
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2014-4-29 [ 在线测试 ]
试题5：数组一旦创建，其大小不能再改变。( )
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2014-4-29 [ 在线测试 ]
试题6：声明数组时，要指定数组长度，以便为数组分配内存。( )
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
试题7：设有整型数组的定义：int a[]=new int[8]; ，则a.length的值为7。( )
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
试题8：Java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。( )
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
试题9：将一个数组传递给一个方法，必须在数组名后加方括号。( )
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2014-4-29 [ 在线测试 ]
试题10：数组可以声明为任何数据类型。( )
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-4-29 [ 在线测试 ]
试题1：一个进程可以包含多个线程。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-4-28 [ 在线测试 ]
试题2：线程的优先级是在Thread类的常数MIN_PRIORITY 和 MAX_PRIORITY 之间的一个值。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-4-28 [ 在线测试 ]
试题3：进程是一人内核级的实体，而线程是一个用户级的实体。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
试题4：多个线程并发执行时，各个线程中语句的执行顺序是确定的，但是线程之间的相对执行顺序也是确定的。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2014-4-28 [ 在线测试 ]
试题5：在Java程序中，run()方法的实现有两种方式有实现Runnable接口和继承Thread类。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-4-28 [ 在线测试 ]
试题6：多线程程序设计的含义是可以将一个程序任务分成几个并行的任务。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-4-28 [ 在线测试 ]
试题7：所有Java对象都可以被序列化。
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-4-4 [ 在线测试 ]
试题8： 如果异常发生时，没有捕获异常的代码，程序会正常执行。
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2014-3-19 [ 在线测试 ]
试题9： java语言中的所有异常类都是java.lang.Throwable的子类。
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-3-19 [ 在线测试 ]
试题10： 异常类对象代表当前出现的一个具体异常。
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-3-19 [ 在线测试 ]
试题1： 一个异常处理中 finally语句块只能有一个或者可以没有。
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-3-19 [ 在线测试 ]
试题2： 程序中抛出异常时(throw)，只能抛出自己定义的异常对象。
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2014-3-19 [ 在线测试 ]
试题3： 包的名称通常全部采用小写字母，如果包名包含多个单词，则在单词之间用”.”分隔，常常在包名前加个前缀，它是单位网站域名的逆序。( )
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题4： Java应用程序处理异常的方式有捕捉异常方式和转移异常方式。 ( )
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题5： Java中允许程序员在一个类中定义另外类，这样定义的类称为内部类。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题6： 内部类的方法中可以直接使用它的外部类中定义的成员变量和成员方法（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2013-12-24 [ 在线测试 ]
试题7： Java中规定，java是单继承，既直接的父类只能有一个。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题8： 如果方法的参数是对象类型，则直接将实参对象的引用值传递给方法体，方法内对形参的任何修改，不会改变实参的原来值。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2013-12-24 [ 在线测试 ]
试题9： 如果方法的参数是对象类型，则直接将实参对象的引用值传递给方法体，方法内对形参的任何修改，会改变实参的原来值。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2013-12-24 [ 在线测试 ]
试题10： 如果方法的参数是基本数据类型，则直接将实参的值传递给方法体，方法内对形参的任何修改，不会改变实参的原来值。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2013-12-24 [ 在线测试 ]
试题1： 如果方法的参数是基本数据类型，则直接将实参的值传递给方法体，方法内对形参的任何修改，会改变实参的原来值。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2013-12-24 [ 在线测试 ]
试题2： 定义类的方法时，参数列表是传送给方法的参数表，参数列表中的参数称为形式参数，简称形参，实际调用对象的方法时给定的值称为实参。（ ）
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2013-12-24 [ 在线测试 ]
试题3： 定义类的方法时，必须定义方法的返回数据类型，如果方法不返回任何值，返回类型定义为void 。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题4： 定义类的方法时，必须定义方法的返回数据类型，如果方法不返回任何值，返回类型可以不写。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题5： 如果程序员没有在定义类的时候定义构造方法，那么在编译该类时候，编译器会自动添加一个无参数的构造方法。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题6： 如果程序员没有在定义类的时候定义构造方法，那么该类就没有构造方法。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题7： 每个类都有构造方法，并允许构造方法的重载。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题8： 在Java语言中，当定义一个变量为基本数据类型时，Java的JVM就为该变量分配内存，并给该变量赋初值，当定义一个复合数据类型变量时，该变量代表该类型对象的引用名，Java的JVM并不为对象创建内存空间，该变量引用的值为null。( )
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2013-12-24 [ 在线测试 ]
试题9：在定义一个类中，如果所定义的类需要从多个接口派生而来，那么父类的名字应该写在implements之后，Java中允许接口的多继承，多个接口之间使用逗号分开。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题10： 在类的定义中，如果所定义的类是从某一个父类派生而来，那么父类的名字应写在extends之后，Java中只允许单重继承，既父类只能有一个。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题1：在Java中，一切都是对象，类中包含两个部分，分别是变量和方法。类中定义的变量称为数据成员或成员变量，类中定义的方法称为成员方法或成员函数。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题2：
当continue语句单独使用时，如果是在一个循环语句中，则表示不再执行本次循环余下的语句，而再次执行条件表达式语句，再来判断是否循环。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题3： 当continue语句使用时，如果是在一个循环语句中，则表示不再执行余下的循环语句，也就是放弃执行当前循环。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题4： 当continue语句单独使用时，如果是在一个语句块中，则表示跳过本块余下的所有语句，转到块尾，执行其后的语句。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题5： 当break语句单独使用时，如果是在一个循环语句中，则表示不再执行余下的循环语句，也就是放弃执行当前循环。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题6： 当break语句单独使用时，如果是在一个语句块中，则表示跳过本块余下的所有语句，转到块尾，执行其后的语句。（ ）
类别：[ 判断类 ] 难度：[ 容易 ] 入库时间：2013-12-24 [ 在线测试 ]
试题7： for 语句中的逻辑表达式必须返回一个逻辑值,该部分也是可选的,当逻辑表达式为空时,默认规定为恒真.( )
类别：[ 判断类 ] 难度：[ 中等 ] 入库时间：2013-12-24 [ 在线测试 ]
试题1：线程的调度方法sleep()和wait()方法有什么区别？
类别：[ 简答类 ] 难度：[ 较难 ] 入库时间：2015-11-29
试题2：
在java中创建线程有哪几种方式？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2015-11-29
试题3：什么是多态？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2015-11-10
试题4：抽象类与接口的区别有哪些？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2015-11-10
试题5：什么是方法重载？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2015-9-29
试题6：
简述JRE与JDK的区别？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2015-9-29
试题7：简述Java类的构造方法特点？如何定义构造方法？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2015-5-7
试题8：给方法传递数组参数与传递基本数据类型变量的值有何不同？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2014-4-29
试题9：简述线程的基本概念、线程的基本状态。
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2014-4-28
试题10：启动一个线程是用 run() 还是 start()? 为什么?
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2014-4-28
试题1：线程的控制方法sleep()和wait()有什么区别 ?
类别：[ 简答类 ] 难度：[ 较难 ] 入库时间：2014-4-28
试题2：Java 中有几种方法可以实现一个线程？用什么关键字修饰同步方法 ?
类别：[ 简答类 ] 难度：[ 容易 ] 入库时间：2014-4-28
试题3：File类有哪些构造函数和常用方法？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2014-3-26
试题4：Java流被分为字节流和字符流，两者有什么区别？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2014-3-26
试题5：什么是流？流式输入输出有什么特点？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2014-3-26
试题6：异常没有被捕获将会发生什么？
类别：[ 简答类 ] 难度：[ 容易 ] 入库时间：2014-3-26
试题7：简述Java语言的异常处理机制的优点？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2014-3-26
试题8：简述基于Java技术实现TCP网络通信的基本步骤。
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2014-1-11
试题9：举例说明方法重载和重写的区别？
类别：[ 简答类 ] 难度：[ 较难 ] 入库时间：2013-12-30
试题10：Thread和Runnable有什么不同？
试题1：String和StringBuffer类的区别？
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2013-12-24
试题2：float和Float的区别是什么？
试题3：Java线程编程中，run()方法的作用与start()方法的作用有什么不同? 试题4：简要叙述int和Integer的区别。
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2013-12-24
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2013-12-24
类别：[ 简答类 ] 难度：[ 中等 ] 入库时间：2013-12-24
试题1：
下面程序抛出了一个“异常”并捕捉了它。请将横线处填入适当内容确保程序正确。 class TrowsDemo {
static void procedure() throws IllegalAccessExcepton { System.out.println(“inside procedure”);
throw _______ IllegalAccessException(“demo”); }
public static void main(String args[]) { try {
procedure();
} __________________ {
System.out.println(“捕获：”+e); } }
试题1：
以下是使用FileInputStream类和FileOutputStream类实现复制文件的功能。请你阅读以下代码，并将空白处的缺失代码填写完整。 import java.io.*; class Test2 {
public static void main(String[] args) {
String file1,file2; int ch=0;
file1=\"readme.txt\";
file2=\"readme.bak\"; try{
FileInputStream fis=new （1） ;
（2） fos=new FileOutputStream(file2); int size= （3） ;
System.out.println(\"字节有效数:\"+size); while((ch=fis.read()) 1=-1）{ System.out.write(ch); fos.write(ch); }
fis.close(); fos.close();
}catch( （4） e){
System.out.println(e.toString()); } } }
类别：[ 分析类 ] 难度：[ 中等 ] 入库时间：2015-12-16
试题2：
设计一个Shape接口和他的两个实现类Square和Circle，要求如下： （1）Shape接口定义一个方法area(),方法接收一个double类型的参数，返回一个double类型的结果。
（2）Square和Circle中实现Shape接口，分别求正方形和圆形的面积。 在测试类中完成创建Square和Circle对象，计算边长为2的正方形面积和半径为3的圆形面积，圆周率使用Math类中的PI值。
类别：[ 分析类 ] 难度：[ 中等 ] 入库时间：2015-11-10
试题3：
设计一个复数类，复数类的定义要求如下： public class Complex {
Complex(){ } //无参构造方法
Complex(double x,double y){ //带参构造方法 }
Complex add(Complex c){ //两复数相加 }
Complex minus(Complex c){ //两复数相减 }
Complex multi(Complex c){ //两复数相乘 }
Complex divide(Complex c){ //两复数相除 }
void print(){ //输出复数的a+bi形式
} }
完成其加、减、乘、除等运算。并测试输出3-49i与8+91i的加、减、乘、除等运算结果。
提示：两个复数的乘除运算结果见下图.
类别：[ 分析类 ] 难度：[ 中等 ] 入库时间：2015-9-22
试题4：
编写一个Java GUI应用程序，窗口标题为“GridLayout”，窗口布局如下图A所示，在图A窗口中单击任意一个Button，网格的划分方式会变化为图B；在图B窗口中单击任意一个Button，网格的划分方式会变化为图A。
图
A 图B
类别：[ 分析类 ] 难度：[ 中等 ] 入库时间：2014-5-29
试题5：编写一个学生类 Student ，要求： (1) 学生类 Student 属性有： id : long型，代表学号
name : String类对象，代表姓名 age : int型，代表年龄
sex : boolen型，代表性别（其中：true表示男，false表示女） phone : String类对象，代表联系电话 (2) 学生类 Student的方法有：
Student(long i , String n , int a , boolean s ,String p) :有参构造函数，形参表中的参数分别初始化学号、姓名、年龄、性别和联系电话。 int getAge() ( ) : 获取年龄作为方法的返回值。
boolean getSex( ) ( ) : 获取性别作为方法的返回值。 String getPhone ( ) : 获取联系电话作为方法的返回值。
public String toString( ) : 以姓名：联系电话的形式作为方法的返回值。
类别：[ 分析类 ] 难度：[ 中等 ] 入库时间：2014-3-26
试题6：
在定义变量类型的基础上赋值，分析以下执行语句可能产生的异常： int a,b,n,m; String s=null; int[] arr=null;
a=a/b;
arr=new int[n]; a= arr[m];
b=Integer.parseInt(s );
请上机调试，写出可能产生的异常对象类型，并说明每种异常产生的条件？
类别：[ 分析类 ] 难度：[ 中等 ] 入库时间：2014-3-20
试题7：
有文件Main.java代码如下： //源文件名为Main.java public class Main {
public static void main(String[] args) {
Person p = new Student( ); p.work(); p.work(100); } }
//类Person定义 class Person{ protected int age; public Base(int age){ this.age = age; }
public void work( ){
System.out.println(\"Person working…\"); }
}
//类Student定义
class Student extends Person{ private static float var1 = 10; private static float var2 = 20; void work( ){
System.out.println(\"Student studying…\"); }
void work(String subject){
System.out.println(\"Student studying\"+subject); }
static void f1(String s){ this.var1 = super.age; try{
var2 = Integer.parseInt(s); }catch(RuntimeException e){ e.printStackTrace( );
}catch(NumberFormatException e){ e.printStackTrace( ); } } }
请你上机调试分析代码，指出代码中主要错误，并修改过来，不要修改Main类中的代码，仅修改Person和Student的定义代码。
试题1：字符串处理问题
Java语言中使用字符串对象String封装，String对象提供了丰富的处理方法，在Java的API文档中对String类型的主要常用方法摘要如下： char charAt(int index) 返回指定索引处的 char 值。
int compareTo(String anotherString) 按字典顺序比较两个字符串。
int compareToIgnoreCase(String str) 不考虑大小写，按字典顺序比较两个字符串。 String concat(String str) 将指定字符串联到此字符串的结尾。
static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的字符串。 boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
byte[] getBytes() 使用平台默认的字符集将此 String 解码为字节序列，并将结果存储到一个新的字节数组中。
byte[] getBytes(String charsetName) 使用指定的字符集将此 String 解码为字节序列，并将结果存储到一个新的字节数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 int indexOf(int ch, int fromIndex) 从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引。
int indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。
int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。
int lastIndexOf(int ch) 返回最后一次出现的指定字符在此字符串中的索引。
int lastIndexOf(int ch, int fromIndex) 从指定的索引处开始进行后向搜索，返回最后一次出现的指定字符在此字符串中的索引。
int lastIndexOf(String str) 返回在此字符串中最右边出现的指定子字符串的索引。
int lastIndexOf(String str, int fromIndex) 从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。 int length() 返回此字符串的长度。
String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 而生成的。
String replace(CharSequence target, CharSequence replacement) 使用指定的字面值替换序列替换此字符串匹配字面值目标序列的每个子字符串。
String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。 String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
char[] toCharArray() 将此字符串转换为一个新的字符数组。
String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 String toString() 返回此对象本身（它已经是一个字符串！）。
String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 String toUpperCase(Locale locale) 使用给定的 Locale 规则将此 String 中的所有字符都转换为大写。
String trim() 返回字符串的副本，忽略前导空白和尾部空白。
给你的问题是：请你利用字符串处理函数完成将标准输入的一行字符串中的数字字符提出来，你可以使用如下代码读入一行字符串: String line=null;
Scanner in = new Scanner(System.in); while(in.hasNextLine()){ line = in.next(); } 输入：
标准输入，每行输入不超过255个字符；
输出：
标准输出，将每行字符串中的数字字符使用一行连续输出。 测试用例输入：
adfafdafdaf[o,903243adsfaf235asdf5 asd23fawet5gart0ringalr4dgjeo5ardsafa 测试用例输出： 9032432355 235045
类别：[ 程序类 ] 难度：[ 中等 ] 入库时间：2015-3-19 [ 在线测试 ]
试题2：数组排序 描述
给定一组n个正整数，根据各位数字之和从小到大进行排序。 输入
输入数据有多组，每组数据占一行，每行的第一个数正整数n，表示整数个数，后面接n个正整数。当n为0时，不作任何处理，输入结束。 输出
输出每组要求下原始数据排序的结果。 样例输入 2 1 2
3 121 10 111 0
样例输出 1 2
10 111 121
试题1：矩阵的鞍点
描述：
矩阵的鞍点是指一个N(N<=30)阶方阵的某元素，该元素为所在行的最大，并为所在列的最小，请你设计程序找出所给方阵的所有鞍点。
输入：
标准输入，第1行需要你计算用例的个数n，接下来n个测试用例的输入，每个用例的第一行为方阵的阶数N，接下来的N行，每行有N个正整数。 输出：
标准输出，输出你找到的鞍点的元素的位置（行数,列数），如果有多个鞍点，以先行后列的次序输出，鞍点之间使用一个“;”隔开；如果没有，输出”NO;”。每个测试用例使用一行输出。
测试用例输入： 2 2 1 3 3 4 3 1 2 3
4 4 4 2 2 3
测试用例输出 1,2; 1,3;3,3;
类别：[ 程序类 ] 难度：[ 中等 ] 入库时间：2014-4-29 [ 在线测试 ]
试题2：异常处理设计问题
我们能够通过海式计算已知一个三角形三边长度的三角形面积，如果三角形的三边长为a,b,c,三角形的面积计算公式描述如下：
要求你完成MyMath对象中的trianglearea法的实现，如果参数a,b,c的值不能构成一个三角形，使用异常进行处理，产生无效三角形异常，如果a,b,c中有负数，产生参数无效异常，根据题目要求请你完成异常类型和MyMath类型的设计。MyMath设计代码如下： import java.util.*; public class MyMath {
public static double trianglearea(double a,double b,double c) throws NotTriAngleException,NegativeArgementsException{ //判定a,b,c是否全为正数 //判定a,b,c是否能构成三角形 //计算三角形面积 double s; }
public static void main(String[] args) {
double a,b,c; int N;
Scanner sc= new Scanner(System.in); N = sc.nextInt(); for(int i=0;i } class NotTriAngleException extends Exception { } class NegativeArgementsException extends Exception { } 输入： 输入的第一行为一个正整数N(N>0)，表示以下有N行数据，每行为一个三角形边的输入信息，原则上是由空格隔开的三个浮点数，但也可能由于输入错误产生非正常情况。 输出： 如果某行三角形边数据能读入三个浮点数，输出方法trianglearea计算结果，保留2位小数，如果发生异常直接输出异常信息；每个三角形计算信息使用一行输出；如果某行三角形边数据读入出现问题，直接退出程序的运行。 测试1输入： 3 3 4 5.0 1 1 2 -2 4.0 3 测试1输出： 6.00 Not TriAngle Negative Argements 测试2输入： 3 3 4 5.0 1a 1 2 -2 4.0 3 测试2输出： 6.00 类别：[ 程序类 ] 难度：[ 较难 ] 入库时间：2014-3-20 [ 在线测试 ] 试题1：计算坐标平面上两点距离 题目描述 在平面直角坐标系中求两点的距离。 输入 输入有若干行，每行四个数，分别代表两个坐标点（a，b）和（c，d），当每行四个数为0时，结束输入，本用例不用计算。 输出 对应输出这两点之间的距离。结果保留两位小数。请注意行尾输出换行。 样例输入 0 0 4 3 1.1 -2.3 0 1 0 0 0 0 样例输出 5.00 3.48 类别：[ 程序类 ] 难度：[ 中等 ] 入库时间：2014-3-4 [ 在线测试 ] 试题2：出租汽车计费器的编程 题目描述 有一个城市出租汽车的计费规则是3公里（含3公里）基本费6元，超过3公里，每一公里1.4元。现在请你输入具体的公里数x（0 输出x公里所需的费用。请注意行尾输出换行。 样例输入 0.002 2.6 4 样例输出 6.00 6.00 7.40 试题1：求课程成绩的总分和平均分 题目描述 一个学生考了数学、英语、语文三门，求总分和平均分。 输入 输入三个整数，中间空格隔开，分别表示数学、英语、语文三门成绩。 输出 输出两行，第一行输出总分，第二行输出平均分，其中平均分保留两位小数。请注意行尾输出换行。 样例输入 90 85 90 样例输出 265 88.33 类别：[ 程序类 ] 难度：[ 容易 ] 入库时间：2014-3-4 [ 在线测试 ] 试题2：短信中提取号码 Description 提取一条短信里所有的电话号码，电话号码之间换行打印，短信的内容由用户输入。 Input 第一行有个整数n(1≤n≤1000)表示测试用例的个数。其后的每一行中有一条短信，每一 条短信中只包含字母、数字、空格、标点符号，没有回车换行符，短信的长度不超过400个英文字符。 Output 将每条短信中的电话号码提取出来。每个号码占一行。如果该短信中没有电话号码，请输出“no phone numbers!” 每个测试用例的输出之间用一个空行隔开。 (提示：利用数据输入读取一行信息，然后利用String的方法将字符串转换成一个字符数组，再提出数字，连续的数都可以认为是电话号码) Sample Input 2 Mr Zhang's home phone is 073112345678, and his office phone is 876321, his mobile phone is 13812345678 Sorry, I don't have his any phone numbers! Sample Output 073112345678 876321 13812345678 no phone numbers! 试题1：球的相关计算问题 球的相关计算涉及到球的体积和球的表面积以及过直径的截面积等，我们知道，以上计算仅需要知道球的半径就可以利用计算公式计算出来，计算中用到的圆周率使用3.14进行计算。 输入： 标准输入一个浮点数r(r>0)，代表需要计算的球的半径. 输出： 标准输出，根据输入的球半径r,依次输出球表面积、圆球体积和直径的侧面积大小，数据间由一个空格隔开，结果保留2位有效数字。 测试用例输入： 3 测试用例输出： 113.04 113.04 28.26 类别：[ 程序类 ] 难度：[ 容易 ] 入库时间：2014-2-27 [ 在线测试 ] 试题2：矩阵的转置变换 请你编程将给定的一个N阶矩阵变换为它的转置矩阵，即将源矩阵的第一行变成第一列，第二行变成第二列，…，第N行变成第N列。 输入： 第一行输入一个正整数N(n<100)，接下来的N行，每行有N个整数。 输出： 使用N行输出，第一行输出转置矩阵的第一行数据，第二行输出转置矩阵的第二行数据，…，第N行输出转置矩阵的第N行数据，每个数使用一个空格隔开。 样例： 输入： 3 1 2 3 4 5 6 7 8 9 输出： 1 4 7 2 5 8 3 6 9 试题1：多关键字排序 学生考试成绩的统计利用计算机软件将变得十份简单的事，由于你很勤奋，并且刚学习了面向对象程序 设计Java,在Java中提供了面向对象程序设计方法，并提供了大量有用的工具类，解决该问题你将成为能手，我们知道只要利用容器 Collections.sort()方法，很方便解决对象的排序问题，如果一个年级的学生参加了有语文、数学和英语三科目的考试，需要计算出每个学生的总分和平均成绩，并且要按照总分排序，如果总分相同，则依照语文、数学再英语的成绩排序，即排序关键词依次为总分、语文、数学、英语。请你设计一个程序解决该问题。 提示：利用输入数据的每行创建一个Student对象，将所有学生对象存储到一个List
Copyright © 2019- huatuo6.com 版权所有 湘ICP备2023023988号-11
违法及侵权请联系：TEL:199 1889 7713 E-MAIL:2724546146@qq.com
本站由北京市万商天勤律师事务所王兴未律师提供法律服务