Java基础习题大全
目录
- 第一章
- 第二章
- 第三章
- 第四章
- 第五章
- 第六章
- 第七章
- 第八章
- 第九章
- 第十章
- 第十一章
- 第十二章
第一章
下列哪个是JDK提供的编译器?
A.java.exe
B.javac.exe
C.javap.exe
D.javaw.exe
下列哪个是Java应用程序主类中正确的main方法?
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[ ])
下列哪个叙述是正确的?
A.Java源文件是由若干个书写形式互相独立的类组成。
B.Java源文件中只能有一个类。
C.如果源文件中有多个类，那么至少有一个类必须是public类。
D.Java源文件的扩展名是.txt。
对于下列源文件，哪个叙述是正确的？
public class E {
public static void main(String []args) {
System.out.println("ok");
System.out.println("您好");
}
}
class A {
public static void main(String []args) {
System.out.println("ok");
System.out.println("您好");
}
}
A.源文件名字必须是A.java。
B.源文件有错误。
C.源文件必须命名为E.java，编译无错误。有两个主类：E和A。程序可以执行主类E也可以执行主类A。
D.源文件中的E类不是主类。
下列哪个叙述是正确的?
A.Java语言是2005年5月Sun公司推出的编程语言。
B.Java语言是1995年5月IBM司推出的编程语言。
C.Java语言的名字是印度尼西亚一个盛产咖啡的岛名。
D.Java语言的主要贡献者是比尔盖茨。
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
Public class Example //【1】
{
public static void main(String args[]) //【2】
{
System.out.println("ok"); //【3】
System.out.println("hello");
System.out.println("您好"); //【4】
}
}
A.1
B.2
C.3
D.4
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Example //【1】
{
public static void main(string args[]) //【2】
{
System.out.println("ok"); //【3】
System.out.println("hello");
System.out.println("您好"); //【4】
}
}
A.1
B.2
C.3
D.4
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Example //【1】
{
public static void main(String args[]) //【2】
{
System.out.println("ok") //【3】
System.out.println("hello");
System.out.println("您好"); //【4】
}
}
A.1
B.2
C.3
D.4
下列哪个是表明Java应用程序主类的main方法?
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[ ])
下列哪个叙述是正确的?
A.Java源文件是由若干个书写形式互相独立的类组成。
B.Java源文件中只能有一个类。
C.如果源文件中有多个类，那么至少有一个类必须是public类
D.Java源文件的扩展名是.txt
下列哪个叙述是正确的?
A.源文件名字必须是java
B.如果源文件中有多个类，这些类可以都不是public类
C.如果源文件中只有一个类，这个类必须是public类
D.如果源文件中只有一个类，这个类必须是主类.
下列哪个叙述是正确的？
A.JDK的全称是Java Development Kit，
B.可以用Microsoft Word 2010 编写Java源文件,
C.不用NetBean或MyEclipse就无法开发Java程序，
D.为了运行Java程序，必须要安装NetBean或MyEclipse。
java程序运行入口的main方法(即主类的main方法)的返回类型是什么？
A.void
B.static
C.char
D.int
对于下列源文件，哪个叙诉是正确的？
public class Cat {
public void cry() {
System.out.println("maiomaio");
}
}
A.源文件的名字必须是Cat.java。
B.源文件的名字可以是cat.java。
C.源文件的名字可以任意。
D.Cat类是主类。
对于下列源文件，哪个叙诉是错误的？
public class Cat {
public void cry() {
System.out.println("maiomaio");
}
}
class E {
public static void main(String args[]) {
System.out.println("ok");
}
}
A.源文件的名字必须是Cat.java。
B.源文件的名字可以是E.java。
C.编译源文件得到Cat.class和E.class两个字节码文件。
D.E类是主类，java E 来运行程序。
一个源文件中必须要有public类。（x）
Java源文件中只能有一个类。（x）
源文件中如果有多个类，那么至多有一个类可以是public类。（v）
Java源文件中只能有一个类。（x）
源文件中如果有多个类，那么至多有一个类可以是public类。（v）
下列源文件可保存成dog.java。（x）
public class Dog {
public void cry() {
System.out.println("wangwang");
}
}
Java语言是1995年5月Sun公司推出的编程语言。（v）
开发Java应用程序的基本步骤是：
1 编写源文件，2.编译源文件，3.运行程序。（v）
Java源文件是由若干个书写形式互相独立的类组成。（v）
下列源文件Dog.java会出现编译错误（v）
public class Dog {
public void cry() {
System.out.println("wangwang");
}
}
public class Cat {
public void cry() {
System.out.println("maiomiao");
}
}
如果JDK的安装目录为D:\jdk，也可以临时在命令行编辑path,如图1_1。（v）
java编译器位于java安装目录的\bin文件夹中。名字是javac.exe。（v）
java编译器的名字是java.exe。（x）
下列源文件People.java中People是主类。（v）
class Hello {
public void speak() {
System.out.println("wangwang");
}
}
public class People {
public static void main(String args[]) {
System.out.println("你好");
}
}
编译下列源文件的Person.java将得到2个字节码文件：Person.class和Xiti.class。（v）
public class Person {
void speakHello() {
System.out.print("您好，很高兴认识您");
System.out.println(" nice to meet you");
}
}
class Xiti {
public static void main(String args[]) {
Person zhang = new Person();
zhang.speakHello();
}
}
第二章
哪个叙述是错误的?
A.int [] a,b[];是声明了1个int型一维数组a和1个int型二维数组b。
B.float a[20];是正确的数组声明。
C.boolean yes = false;是正确的boolean变量声明。
D.1e2和2.05E2都是double型常量。
哪个叙述是错误的?
A.System是关键字。
B._class可以作为标识符。
C.char型字符在Unicode表中的位置范围是0至65535。
D.对于int a[] = new int[3];a.length的值是3。
下列哪项字符序列可以是标识符？
A.true
B.default
C._int
D.good-class
下列哪一项是正确的float变量的声明？
A.float foo = 1;
B.float foo = 1.0;
C.float foo = 2e1;
D.float foo = 2.02;
以下哪一项是正确的char型变量的声明？
A.char ch = “R”;
B.char ch = ‘\’
C.char ch = ‘ABCD’;
D.char ch = “ABCD”;
哪个叙述是错误的?
A.对于int a[][] = new int[6][4];a.length的值是6。
B.对于int a[][] = new int[2][9];a.length,a[0].length,a[1].length的值都是9。
C.对于int [] a = new int[3];a[0],a[1],a[2]的值都是0。
D.float height = 1e1F;是正确的float变量声明。
对于下列Test.java代码，下列哪个叙述是正确的?
public class Test{
public static void main(String args[]){
int arr[] = new int[10];
System.out.println(arr[1]);
}
}
A.产生编译错误。
B.输出null。
C.编译正确,发生运行异常。
D.输出:0。
挑错题（ABCD注释标注的哪行代码有错误？）
public class Test1{
public static void main(String args[]){
char c =65535; //A
byte b = 127; //B
int height = 100; //C
float f = 3.14; //D
}
}
A.A
B.B
C.C
D.D
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main(String args[]){
char c ='\uabcg'; //【1】
byte b = 127; //【2】
int x = 100; //【3】
float f = 3.14F; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main(String args[]){
char c ='\uabcf'; //【1】
byte b = 127; //【2】
int public = 100; //【3】
float f = 3.14F; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main(String args[]){
char c =65536; //【1】
byte b = 127; //【2】
int height = 100; //【3】
float f = 3.14F; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main(String args[]){
int x = 8;
byte b = 127;
b = x; //【1】
x = 'a'; //【2】
long y= b; //【3】
float z=(int)6.89 ; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main(String args[]){
int m = 'a'; //【1】
char ch = m; //【2】
ch = 97; //【3】
double t = 0.1; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main(String args[]){
char c =65535; //【1】
byte b = 127; //【2】
unsigned int y = 200; //【3】
float f = 3.14f; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列哪个类型声明的变量可以取true或false两个值?
A.byte
B.boolean
C.char
D.double
main是java语言规定的关键字。（x）
float area = 1e1;是错误的float变量声明。（v）
byte amount = 128;是正确的byte型变量声明。（x）
int [] a,b;是声明了2个int型一维数组a和b。（v）
对于 int [][] a ={{1,2,3},{4,5,6,7}};a[0].length的值是3，a[1].length的值是4。（v）
对于int a[][] = new int[2][9];a.length的值是2,a[0].length,a[1].length的值都是9。（v）
boolean yes = TRUE;是正确的boolean变量声明。（x）
标识符的第一个字符可以是数字。（x）
标识符的长度最多为30个字符长度。（x）
*号可以出现在标识符中。（x）
标识符不能是true、false和null（尽管true、false和null不是Java关键字）。（v）
汉字可以出现在标识符中。（v）
3.14是float型常量。（x）
3.14F和0.618f都是float型常量。（v）
哪些叙述是正确的?（多选）
A.char ch = ‘\t’;是正确的char变量声明。
B.char ch =‘你’;是正确的char变量声明。
C.char ch =‘\u000M’;是正确的char变量声明。
D.char ch =‘\0’;是正确的char变量声明。
第三章
下列哪个叙述是正确的？
A.5.0/2+10的结果是double型数据。
B.(int)5.8+1.0的结果是int型数据。
C.‘苹’+ '果’的结果是char型数据。
D.(short)10+'a’的结果是short型数据。
用下列哪个代码替换程序标注的【代码】会导致编译错误？
public class E {
public static void main (String args[ ]) {
int m=10,n=0;
while(【代码】) {
n++;
}
}
}
A.m–>0
B.m++>0
C.m = 0
D.m>100&&true
对于Test.java下列哪个叙述是正确的？
public class Test {
public static void main (String args[ ]) {
boolean boo = false;
if(boo = true){
System.out.print("hello");
System.out.print("你好");
}
else {
System.out.print("ok");
System.out.print("yes");
}
}
}
A.出现编译错误。
B.程序的输出结果是hello你好
C.程序输出的结果是ok
D.程序输出的结果是okyes
对于int n=6789;，表达式的值为7的是哪个？
A.n%10
B.n/10%10
C.n/100%10
D.n/1000%10
下列哪个代码替换程序标注的【代码】会使得程序输出hello。
public class Test {
public static void main (String args[ ]) {
int m = 0;
if(【代码】){
System.out.println("您好");
}
else {
System.out.println("hello");
}
}
}
A.m-- <= 0
B.++m > 0
C.m++ > 0
D.–m < 0
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main (String args[ ]) {
byte b = 'a'; //【1】
int n =100;
char c = 65; //【2】
b = b; //【3】
b = b+1; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main (String args[ ]) {
char ch = '花'; //【1】
byte n = -100;
ch = ch-ch; //【2】
n = n; //【3】
n = 127; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main (String args[ ]) {
byte b = 32; //【1】
int n =100;
char c = 'A'+b; //【2】
b = b; //【3】
int m = b+1; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main (String args[ ]) {
byte b = 32; //【1】
char c = 'A'; //【2】
byte n = (byte)c; //【3】
short m = b+1; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main (String args[ ]) {
int m = 12;
int n = 12;
int number = 100+'w'; //【1】
switch(number) {
case 12: n++; //【2】
case 100:n--; //【3】
break;
case n : m++; //【4】
}
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main (String args[ ]) {
int m = 12;
int n = 12;
long number = 100; //【1】
switch(number) //【2】
{
case 12: n++;
case 100:n--; //【3】
break;
case 12+9 : m++; //【4】
}
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main (String args[ ]) {
int m =100,n =10;
if(100 = m) //【1】
{
System.out.println("No");
}
else if(10 == n ) //【2】
{
System.out.println("逻辑相等常量在前是好习惯");
}
else if(100 == m ) //【3】
{
System.out.println("逻辑相等常量在前是好习惯");
}
else if(m != n) //【4】
{
System.out.println("ok");
}
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main (String args[ ]) {
int a[] = {1,2,3,4};//【1】
for(int n = 0;n < a.length; n++) //【2】
{
System.out.println(a[n]);
}
for(int i:a) //【3】
{
System.out.println(i);
}
int m = 0;
for(m:a) //【4】
{
System.out.println(m);
}
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class Test {
public static void main (String args[ ]) {
byte b =7;
b = 7+120; //【1】
b = b; //【2】
b = b+120; //【3】
b += 120; //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
对于下列Test.java下列哪个叙述是正确的？
public class Test {
public static void main (String args[ ]) {
double m = 0.4;
double n = 0.4F;
if(m == n){
System.out.printf("%s","您好");
}
else {
System.out.printf("%s","hello");
}
}
}
A.出现编译错误。
B.程序的输出结果是您好。
C.程序输出的结果是hello。
D.程序没有输出任何结果。
下列哪个叙述是错误的？
A.while(表达式)…语句中的“表达式”的值必须是boolean型数据。。
B.for(表达式1; 表达式2; 表达式3)…语句中的“表达式2”的值必须是boolean型数据。
C.if(表达式)…语句中的“表达式”的值必须是boolean型数据。
D.switch语句中必须要有default选项。
下列哪个叙述是错误的？
A.逻辑运算符的运算结果是int型数据。
B.关系运算符的运算结果是boolean型数据。
C.逻辑运算符的运算结果是boolean型数据。
D.逻辑运算符的操作元必须是boolean型数据。
用下列哪个代码替换程序标注的【代码】会使得程序输出hello。
public class Test {
public static void main (String args[ ]) {
int m = 0;
if(【代码】){
System.out.println("您好");
}
else {
System.out.println("hello");
}
}
}
A.m-- <= 0
B.++m > 0
C.m++ > 0
D.–m < 0
用下列哪个代码替换程序标注的【代码】会导致编译错误？
public class Test {
public static void main (String args[ ]) {
int m = 0;
if(【代码】){
System.out.println("条件表达式必须是bookean");
}
}
}
A.m-- > 0
B.++m >0
C.m = 0
D.m != 0
对于下列Test.java下列哪个叙述是正确的？
public class Test {
public static void main (String args[ ]) {
int m = 10, n = 20;
if(n>m)
System.out.print("hello");
System.out.print("你好");
else
System.out.print("ok");
System.out.print("yes");
}
}
A.出现编译错误。
B.程序的输出结果是hello你好
C.程序输出的结果是ok
D.程序输出的结果是okyes
关系运算符的运算结果是int型数据。（x）
表达式5/2的结果是2。（v）
表达式2>8&&9>2的结果为false。（v）
while(表达式)…语句中的“表达式”的值必须是boolean型数据。（v）
在while语句的循环体中，执行break语句的效果是结束while语句。（v）
表达式2>8||9>2的结果为1。（v）
12 = 12 是非法的表达式。（v）
for(表达式1; 表达式2; 表达式3)…语句中的“表达式2”的值必须是boolean型数据。（v）
逻辑运算符的运算结果是boolean型数据。（v）
switch语句中必须要有default选项。（x）
第四章
下列哪个叙述是正确的？
A.Java应用程序由若干个类所构成，这些类必须在一个源文件中。
B.Java应用程序由若干个类所构成，这些类可以在一个源文件中，也可以分布在若干个源文件中，其中必须有一个源文件含有主类。
C.Java源文件必须含有主类。
D.Java源文件如果含有主类，主类必须是public类。
下列哪个叙述是正确的？
A.成员变量的名字不可以和局部变量的名字相同。
B.方法的参数的名字可以和方法中声明的局部变量的名字相同。
C.成员变量没有默认值。
D.局部变量没有默认值。
对于下列Hello类，哪个叙述是正确的？
class Hello {
Hello(int m){
}
int Hello() {
return 20;
}
hello() {
}
}
A.Hello类有两个构造方法。
B.Hello类的int Hello()方法是错误的方法。
C.Hello类没有构造方法。
D.Hello无法通过编译，因为其中的hello方法的方法头是错误的（没有类型）。
对于下列Dog类，哪个叙述是错误的？
class Dog {
Dog(int m){
}
Dog(double m){
}
int Dog(int m){
return 23;
}
void Dog(double m){
}
}
A.Dog(int m)与Dog(double m)是互为重载的构造方法
B.int Dog(int m)与void Dog(double m)是互为重载的非构造方法
C.Dog类只有两个构造方法，而且没有无参数的构造方法
D.Dog类有三个构造方法
下列哪个叙述是正确的？
A.成员变量有默认值。
B.this可以出现在static方法中。
C.类中的实例方法可以用类名调用。
D.局部变量也可以用访问修饰符：public,proteced,private修饰。
对于下列Tom类，哪个叙述是正确的？
public class Test {
public static void main(String args[]){
Tom cat = new Tom();
}
}
class Tom {
void Tom(){
System.out.println("ok");
}
Tom(int m){
System.out.println("你好");
}
}
A.程序运行时输出：ok。
B.没有构造方法。
C.有编译错误，因为创建对象cat使用的不是构造方法，java编译器已经不提供默认的构造方法了。
D.程序运行时无任何输出。
类是最重要的“数据类型”，类声明的变量被称为对象变量，简称对象。（v）
构造方法没有类型。（v）
类中的实例变量在用该类创建对象的时候才会被分配内存空间。（v）
类中的实例方法可以用类名直接调用。（x）
局部变量没有默认值。（v）
构造方法的访问权限可以是public，protected，private或友好的。（v）
方法中声明的局部变量不可以用访问修饰符：public,proteced,private修饰。（v）
this可以出现在实例方法和构造方法中。（v）
成员变量的名字不可以和局部变量的相同。（x）
static方法不可以重载。（x）
上机调试题：
说出下列E类中【代码1】~【代码3】的输出结果。
class Fish {
int weight = 1;
}
class Lake {
Fish fish;
void setFish(Fish s){
fish = s;
}
void foodFish(int m) {
fish.weight=fish.weight+m;
}
}
public class Main {
public static void main(String args[]) {
Fish redFish = new Fish();
System.out.println(redFish.weight); //【代码1】
Lake lake = new Lake();
lake.setFish(redFish);
lake.foodFish(120);
System.out.println(redFish.weight); //【代码2】
System.out.println(lake.fish.weight); //【代码3】
}
}
上机调试题
请说出A类中System.out.println的输出结果。
class B {
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 Main {
public static void main(String args[]) {
B b = new B();
b.setX(-100);
b.setY(-200);
System.out.println("sum="+b.getXYSum());
}
}
上机调试题
请说出A类中System.out.println的输出结果。
class B {
int n;
static int sum=0;
void setN(int n) {
this.n=n;
}
int getSum() {
for(int i=1;i<=n;i++)
sum=sum+i;
return sum;
}
}
public class Main {
public static void main(String args[]) {
B b1=new B(),b2=new B();
b1.setN(3);
b2.setN(5);
int s1=b1.getSum();
int s2=b2.getSum();
System.out.println(s1+s2);
}
}
上机调试题
请说出E类中【代码1】和【代码2】的输出结果。
class A {
double f(int x,double y) {
return x+y;
}
int f(int x,int y) {
return x*y;
}
}
public class Main {
public static void main(String args[]) {
A a=new A();
System.out.println(a.f(10,10)); //【代码1】
System.out.println(a.f(10,10.0)); //【代码2】
}
}
上机调试题
上机执行下列程序，了解可变参数。
public class Main {
public static void main(String args[]) {
f(1,2);
f(-1,-2,-3,-4); //给参数传值时，实参的个数很灵活
f(9,7,6) ;
}
public static void f(int ... x){ //x是可变参数的代表，代表若干个int型参数
for(int i=0;i<x.length;i++) {//x.length是x代表的参数的个数
System.out.println(x[i]); //x[i]是x代表的第i个参数(类似数组)
}
}
}
上机调试题
类的字节码进入内存时，类中的静态块会立刻被执行。执行下列程序，了解静态块。
class AAA {
static { //静态块
System.out.println("我是AAA中的静态块!");
}
}
public class Main {
static { //静态块
System.out.println("我是最先被执行的静态块!");
}
public static void main(String args[]) {
AAA a= new AAA(); //AAA的字节码进入内存
System.out.println("我在了解静态(static)块");
}
}
类体中声明成员变量是为了体现对象的属性。（v）
类所声明的变量被称为对象，对象（变量）负责存放引用，以确保对象可以操作分配给该对象的变量以及调用类中的方法。分配给对象的变量被习惯地称做对象的实体。（v）
类体内容中定义的非构造方法是为了体现对象的行为。（v）
构造方法也可以重载。（v）
源文件可以有多条import语句。（v）
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
class Tom {
private int x = 120;
protected int y = 20;
int z = 11;
private void f() {
x = 200;
System.out.println(x);
}
void g() {
x = 200;
System.out.println(x);
}
}
public class E {
public static void main(String args[]) {
Tom tom = new Tom();
tom.x = 22; //【1】
tom.y = 33; //【2】
tom.z = 55; //【3】
tom.g(); //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
class Tom {
private int x = 120;
protected int y = 20;
int z = 11;
private void showX() {
System.out.println(x);
}
public void setX(int x) {
this.x = x;
System.out.println(x);
}
}
public class E {
public static void main(String args[]) {
Tom tom = new Tom();
tom.setX(22); //【1】
tom.y = 33; //【2】
tom.z = 55; //【3】
tom.showX(); //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
class A {
int f(int x,int y){
int x; //【1】
int m = y; //【2】
return m;
}
int A(int m) //【3】
{
return m;
}
}
public class E {
public static void main(String args[]) {
A a = new A(); //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
将下列哪个方法添加到People类会导致编译错误？
class People {
public void f(){
}
}
A.public int f(){
return 100;
}
B.private int f(int x){
return 100+x;
}
C.protected int f(int x,int y){
return x+y;
}
D.double f(double x){
return x;
}
下列哪个叙述是正确的？
A.类体中必须先声明成员变量，然后再定义方法。
B.类体中成员变量的声明和方法的定义可以交叉进行。
C.类体中必须先定义构造方法才可以定义其他方法。
D.类体中必须先定义实例变量，才可以再定义static变量。
将下列哪个方法添加到People类不会导致编译错误？
class People {
public void f(){
}
private int f(int x){
return 100+x;
}
protected int f(int x,int y){
return x+y;
}
}
A.public int f(){
return 100;
}
B.private int f(int m){
return 100+m;
}
C.protected long f(int m,int n){
return m+n;
}
D.double f(double x){
return x;
}
第五章
下列哪个叙述是正确的？
A.子类继承父类的构造方法。
B.abstract类的子类必须是非abstract类。
C.子类继承的方法只能操作子类继承和隐藏的成员变量。
D.子类重写或新增的方法也能直接操作被子类隐藏的成员变量。
下列哪个叙述是正确的？
A.final 类可以有子类。
B.abstract类中只可以有abstract方法。
C.abstract类中可以有非abstract方法，但该方法不可以用final修饰。
D.不可以同时用final和abstract修饰同一个方法。
E.允许使用static修饰abstract方法。
假设C是B的子类，B是A的子类，cat是C类的一个对象，bird是B类的一个对象，下列哪个叙述是错误的？
A.cat instanceof B的值是true。
B.bird instanceof A的值是true。
C.cat instanceof A的值是true。
D.bird instanceof C的值是true。
下列程序中注释的哪个代码（1、2、3、4）是错误的（无法通过编译）？
class A {
static int m;
static void f(){
m = 20 ; //1
}
}
class B extends A {
void f() //2
{ m = 222 ; //3
}
}
class E {
public static void main(String args[]) {
A.f(); // 4
}
}
A.1
B.2
C.3
D.4
下列程序中注释的哪个代码（1、2、3、4）是错误的？
abstract class Takecare {
protected void speakHello() {} //1
public abstract static void cry(); //2
static int f(){ return 0 ;} //3
abstract float g(); //4
}
A.1
B.2
C.3
D.4
下列程序中注释的哪个代码（1、2、3、4）是错误的（无法通过编译）？
abstract class A {
abstract float getFloat (); //1
void f() //2
{ }
}
public class B extends A {
private float m = 1.0f; //3
private float getFloat () //4
{ return m;
}
}
A.1
B.2
C.3
D.4
将下列哪个代码（A、B、C、D）放入程序中标注的【代码】处将导致编译错误？
class A {
public float getNum() {
return 3.0f;
}
}
public class B extends A {
【代码】
}
A.public float getNum(){return 4.0f;}
B.public void getNum(){ }
C.public void getNum(double d){ }
D.public double getNum(float d){return 4.0d;}
对于下列代码，下列哪个叙述是正确的？
class A {
public int i=0;
A(int m) {
i = 1;
}
}
public class B extends A {
B(int m) {
i = 2;
}
public static void main(String args[]){
B b = new B(100);
System.out.println(b.i); //【代码】
}
}
A.程序提示编译错误（原因是A类没有不带参数的构造方法）。
B.编译无错误，【代码】输出结果是0。
C.编译无错误，【代码】输出结果是1。
D.编译无错误，【代码】输出结果是2。
下列程序中注释的哪两个代码（1、2、3、4）是错误的（无法通过编译）？
class Father {
private int money =12;
float height;
int seeMoney(){
return money ; //1
}
}
class Son extends Father {
int height;
int lookMoney() {
int m = seeMoney(); //2
return m;
}
}
class E {
public static void main(String args[]) {
Son erzi = new Son();
erzi.money = 300; //3
erzi.height = 1.78F; //4
}
}
A.1
B.2
C.3
D.4
子类继承父类的构造方法。（x）
子类中想使用被子类隐藏的实例成员变量或实例方法就需要使用关键字super。（v）
可以用final修饰构造方法。（x）
如果在子类的构造方法中，没有显示地写出super关键字来调用父类的某个构造方法，那么编译器默认地有：super();调用父类的无参数的构造方法，如果父类没有这样的构造方法，代码将出现编译错误。（v）
可以同时用final和abstract修饰同一个方法。（x）
子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量。（v）
如果一个类的所有构造方法的访问权限都是private的，意味着这个类不能有子类，理由是：一个类的private方法不能在其他类中被使用，但子类的构造方法中一定会调用父类的某个构造方法）。（v）
子类在方法重写时，不可以把父类的实例方法重写为类（static）方法，也不可以把父类的类（static）方法重写为实例方法。（v）
abstract类中只可以有abstract方法。（x）
子类可以有多个父类。（x）
上机调试题
请说出E类中【代码1】和【代码2】的输出结果。
class A {
double f(double x,double y) {
return x+y;
}
}
class B extends A {
double f(int x,int y) {
return x*y;
}
}
public class Main {
public static void main(String args[]) {
B b=new B();
System.out.println(b.f(3,5)); //【代码1】
System.out.println(b.f(3.0,5.0)); //【代码2】
}
}
上机调试题
请说出B类中【代码1】和【代码2】的输出结果。
class A {
public int getNumber(int a) {
return a+1;
}
}
class B extends A {
public int getNumber (int a) {
return a+100;
}
}
class Main {
public static void main(String args[]) {
A a = new A();
System.out.println(a.getNumber(10)); //【代码1】
a = new B();
System.out.println(a.getNumber(10)); //【代码2】
}
}
上机调试题
请说出E类中【代码1】～【代码4】的输出结果。
class A {
double f(double x,double y) {
return x+y;
}
static int g(int n) {
return n*n;
}
}
class B extends A {
double f(double x,double y) {
double m = super.f(x,y);
return m+x*y;
}
static int g(int n) {
int m = A.g(n);
return m+n;
}
}
public class Main {
public static void main(String args[]) {
B b = new B();
System.out.println(b.f(10.0,8.0)); //【代码1】
System.out.println(b.g(3)); //【代码2】
A a = new B();
System.out.println(a.f(10.0,8.0)); //【代码3】
System.out.println(a.g(3)); //【代码4】
}
}
用户在定义子类时，可以给子类指定多个父类。（x）
一个非final类可以有多个子类。（v）
java.lang包中的Object类是所有其他类的祖先类。（v）
如果子类和父类不在同一个包中，子类不继承父类的友好成员。（v）
所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己定义的任何实例方法操作。（v）
子类不可以声明和父类的成员变量同名的成员变量。（x）
子类不可以定义和父类的方法同名的方法。（x）
多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为（多：子类数目，态：父类某个方法）。（v）
第六章
下列哪个叙述是正确的？
A.一个类最多可以实现两个接口。
B.如果一个抽象类实现某个接口，那么它必须重写接口中的全部方法。
C.如果一个非抽象类实现某个接口，那么它可以只重写接口中的部分方法。
D.允许接口中只有一个抽象方法。
将下列（A、B、C、D）哪个代码替换下列程序中的【代码】不会导致编译错误？
interface Com {
int M = 200;
int f();
}
class ImpCom implements Com {
【代码】
}
A.public int f(){return 100+M;}
B.int f(){return 100;}
C.public double f(){return 2.6;}
D.public abstract int f();
下列接口中标注的（1、2、3、4）中，哪两个是错误的？
interface Takecare {
protected void speakHello(); //1
public abstract static void cry(); //2
int f(); //3
abstract float g(); //4
}
A.1
B.2
C.3
D.4
接口中也能声明变量。（x）
Java8之后，接口中也能定义非抽象的不加default修饰的方法。（x）
Java8之后，接口中可以定义private方法。（v）
接口中的常量可以不指定初值。（x）
可以在接口中只声明常量，不定义任何方法。（v）
一个源文件中既可以定义接口，也可以定义类。（v）
接口中可以有常量，但没有变量。（v）
接口中可以有abstract方法或default修饰的带方法体的方法（JDK8版本）。（v）
接口中 void f();方法声明等价于public abstract void f();即方法默认是public访问权限的abstract方法。（v）
接口中 int x =10等价于 public static final int x = 10,即默认是常量。（v）
接口里也可以定义非abstract的方法（不加default修饰）。（x）
一个接口可以有多个父接口：例如：interface A extends Com1,Com2。（v）
类使用关键字implements 实现一个或多个接口。（v）
如果一个非abstract类实现某个接口，该类必须重写接口中的全部abstract方法。（v）
可以用接口名直接访问接口中的常量。（v）
不能用final修饰接口。（v）
能用public修饰接口。（v）
接口中的方法的访问权限一定都是public（允许省略public）。（v）
类声明class A implements Printable,Addable意思是A类实现Prinabe和Addable两个接口。（v）
一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是抽象类，也就是说抽象类既可以重写接口中的方法也可以直接拥有接口中的方法。（v）
子接口将继承父接口中的全部方法和常量。（x）
接口变量中可以存放实现该接口的类的实例的引用(对象的引用)。（v）
把实现某一接口的类创建的对象的引用赋值给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口方法。（v）
接口中可以有常量，不能有变量。而abstract类中既可以有常量也可以有变量。（v）
接口中的常量必须指定初值。（v）
一个接口可以继承多个接口。（v）
可以用final修饰接口中的方法。（x）
第七章
一个方法使用throw关键字声明要产生的若干个异常。（x）
使用throw关键字抛出异常对象。（v）
非匿名内部类也可以实现接口。（v）
不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象。（v）
匿名子类（和子类有关的匿名类）可以继承父类的方法也可以重写父类的方法。（v）
匿名子类（和子类有关的匿名类）的类体中不可以声明static成员变量和static方法。（v）
接口匿名类（和接口有关的匿名类）的类体中不可以声明static成员变量和static方法。（v）
匿名类一定是内部类。（v）
Java使用throws关键字抛出一个Exception的子类的实例表示异常发生。（x）
try~catch语句可以由几个catch组成，分别处理发生的相应异常。（v）
一个方法在声明时可以使用throws关键字声明要产生的若干个异常。（v）
一个方法在声明时可以使用throw关键字声明要产生的若干个异常。（x）
throw的作用就是抛出异常。throw和throws是两个不同的关键字。（v）
接口匿名类（和接口有关的匿名类）可以是抽象类。（x）
匿名子类（子类有关的匿名类）可以是抽象类。（x）
接口匿名类（和接口有关的匿名类）一定不是抽象类。（v）
匿名类没有构造方法。（x）
匿名类也有构造方法。（v）
匿名类一定是final类。（v）
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
interface Com {
abstract int get();
}
class People {
int computer(Com com){
return com.get();
}
}
class E {
public static void main(String args[]){
People p = new People();
int m = p.computer(new Com() {
int m =100; //【1】
static int n =10; //【2】
public int get() //【3】
{
return 100+m; //【4】
}
});
System.out.println(m);
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
interface Com {
abstract int get();
}
class People {
int computer(Com com){
return com.get();
}
}
class E {
public static void main(String args[]){
People p = new People();
int m = p.computer(new Com() {
int m =100; //【1】
public int get() //【2】
{
return 100+m; //【3】
}
public static void f(){} //【4】
});
System.out.println(m);
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
class E {
public static void main(String args[]){
int n = 0,m = 0,t = 1000;
try{ m = Integer.parseInt("8888");
n = Integer.parseInt("ab89"); //【1】
}
n =100; //【2】
catch(NumberFormatException e) {}
try{ m = Integer.parseInt("aaaa"); //【3】
n = Integer.parseInt("8999"); //【4】
}
catch(NumberFormatException e) {}
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
class E {
public static void main(String args[]){
int n = 0,m = 0,t = 1000;
try{ m = Integer.parseInt("8888"); //【1】
n = Integer.parseInt("ab89"); //【2】
t = Integer.parseInt("1289"); //【3】
}
catch(Exception e) {} //【4】
catch(NumberFormatException e) {}
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
class E {
public static void main(String args[]){
int n = 0,m = 0,t = 1000;
try{ m = 8888; //【1】
throw new java.io.IOException("right"); //【2】
t = 1000; //【3】
}
catch(Exception e) {} //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
哪个叙述是正确的？
A.和接口有关的匿名类可以是抽象类。
B.和类有关的匿名类还可以额外地实现某个指定的接口。
C.和类有关的匿名类一定是该类的一个非抽象子类。
D.和接口有关的匿名类的类体中可以有static成员变量。
下列哪个叙述是错误？
A.try~catch语句可以由几个catch组成，分别处理发生的相应异常。
B.一个方法在声明时可以使用throws关键字声明要产生的若干个异常。
C.一个方法在声明时可以使用throw关键字声明要产生的若干个异常。
D.throw的作用就是抛出异常.throw和throws是两个不同的关键字。
下列哪个叙述是错误的？
A.接口匿名类（和接口有关的匿名类）可以是抽象类。
B.匿名子类（子类有关的匿名类）一定是final类。
C.匿名子类（子类有关的匿名类）一定不是抽象类。
D.接口匿名类（和接口有关的匿名类）一定是final类。
下列哪些叙述是正确的？（多选）
A.匿名子类（和子类有关的匿名类）的类体中不可以声明static成员变量和static方法。
B.接口匿名类（和接口有关的匿名类）的类体中不可以声明static成员变量和static方法。
C.匿名类一定是内部类。
D.Java使用throws关键字抛出一个Exception的子类的实例表示异常发生。
下列哪些叙述是正确的？（多选）
A.接口匿名类（和接口有关的匿名类）可以是抽象类。
B.匿名子类（子类有关的匿名类）一定是final类。
C.匿名子类（子类有关的匿名类）一定不是抽象类。
D.接口匿名类（和接口有关的匿名类）一定是final类。
下列哪些叙述是错误的？（多选）
A.匿名类没有构造方法。
B.一个方法在声明时可以使用throws关键字声明要产生的若干个异常。
C.匿名类一定是final类。
D.匿名子类（和子类有关的匿名类）的类体中可以定义static方法。
第八章
下列哪个叙述是正确的？
A.String 类是final 类，不可以有子类。
B.String 类在java.util包中。
C.“abc”=="abc"的值是false。
D.“abc”.equals(“Abc”)的值是true。
下列哪个表达式是正确的（无编译错误）？
A.int m =Float.parseFloat(“567”);
B.int m =Short.parseShort(“567”)
C.byte m =Integer.parseInt(“2”);
D.float m=Float.parseDouble(“2.9”)
对于如下代码，下列哪个叙述是正确的？
public class E{
public static void main(String[] args){
String strOne="bird";
String strTwo=strOne;
strOne="fly";
System.out.println(strTwo); //【代码】
}
}
A.程序编译出现错误。
B.程序标注的【代码】的输出结果是bird。
C.程序标注的【代码】的输出结果是fly。
D.程序标注的【代码】的输出结果是null。
下列哪个叙述是错误的？
A.“9dog”.matches(“\ddog”)的值是true。
B.“12hello567”.replaceAll(“[123456789]+”,“@”)返回的字符串是@hello@。
C.new Date(1000)对象含有的时间是公元后1000小时的时间。
D."\hello\n"是正确的字符串常量。
“\natural"是正确的String常量。（v）
“\hello"是正确的String常量。（x）
表达式"89762.34”.matches(”[0-9.]+“)的值是true。（v）
表达式 new String(“abc”)== “abc"的值是true。（x）
表达式new String(“abc”) == new String(“abc”)的值是false。（v）
表达式"3.1415926”.matches(”[0-9]+[.]{1}[0-9]+“)的值是true。（v）
表达式java88_hello_99”.matches(“[a-zA-Z|0-9|_]+”)的值是true。（v）
Random对象的nextInt(int n)方法随机返回[0，n）之间的一个整数。（v）
表达式"RedBird".indexOf(“Bird”)的值是4。（x）
表达式"\t\nABC".length()的值是5。（v）
表达式"java".equals(“java”)的值是true。（v）
表达式"Hello".equals(“hello”)的值时true。（x）
表达式"Bird".compareTo(“Bird fly”)的值是负数。（v）
表达式"I love this game".contains(“love”)的值是true。（v）
表达式"RedBird".indexOf(“Bird”)的值是3。（v）
Integer.parseInt(“12.9”);会触发NumberFormatException异常。（v）
表达式"89762.34".startsWith(“89”)的值是true。（v）
表达式"89762.34".endsWith(“34”)的值是true。（v）
StringTokenizer对象的nextToken()方法返回一个String对象。（v）
String对象的字符序列是不可修改的。（v）
StringBuffer对象的字符序列是可修改的。（v）
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class E {
public static void main (String[]args) {
String str = new String("ABCABC");
int index = str.indexof("BC"); //【1】
index = str.lastIndexOf("BC"); //【2】
int m = str.length(); //【3】
boolean boo= str.startsWith("Java"); //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
表达式new String(“abc”).equals (“abc”)的值是true。（v）
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class E {
public static void main (String[]args) {
String str1 = new String(""); //【1】
int [] a = {97,98,99};
String str2 = new String (a); //【2】
char [] c = {'a','b','c'};
String str3 = new String (c); //【3】
String str4 = new String(); //【4】
System.out.println(str4.equals(""));
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class E {
public static void main (String[]args) {
String str = new String("ABCABC");
int index = str.indexOf("BC"); //【1】
index = str.lastIndexOf("BC"); //【2】
int m = str.length(); //【3】
boolean boo= str.startWith("Java"); //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
public class E {
public static void main (String[]args) {
String str = new String("ABCABC");
char c = str.charAt(2); //【1】
byte [] b = str.getBytes(); //【2】
String s = str.subString(0,3); //【3】
boolean boo= str.contains("Java"); //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
第九章
（1）下列哪个叙述是不正确的？
A.一个应用程序中最多只能有一个窗口。
B.JFrame创建的窗口默认是不可见的。
C.不可以向JFrame窗口中添加JFame窗口。
D.窗口可以调用setTitle(String s)方法设置窗口的标题。
（2）下列哪个叙述是不正确的？
A.JButton对象可以使用addActionLister（ActionListener l）方法将没有实现ActionListener接口的类的实例注册为自己的监视器。
B.对于有监视器的JTextField文本框，如果该文本框处于活动状态（有输入焦点）时，用户即使不输入文本，只要按回车（Enter）键也可以触发ActionEvent 事件。
C.监视KeyEvent事件的监视器必须实现KeyListener接口。
D.监视WindowEvent事件的监视器必须实现WindowListener接口。
（3）下列哪个叙述是不正确的？
A.使用FlowLayout布局的容器最多可以添加5个组件。
B.使用BorderLayout布局的容器被划分成5个区域。
C.JPanel的默认布局是FlowLayout布局。
D.JDialog的默认布局是BorderLayout布局。
javax.swing包中JComponent类是java.awt包中Container类的子类。（v）
java.awt包中Container类是java.awt包中Component类的子类。（v）
Container类提供了一个public方法：add(Component com)，一个容器可以调用这个方法将组件com添加到该容器中。（v）
Java提供的JFrame类的实例是一个底层容器，即通常所称的窗口。（v）
窗口默认地被系统添加到显示器屏幕上，因此不允许将一个窗口添加到另一个容器中。（v）
容器也可以添加JFrame的实例到该容器中。（x）
JTextField文本框允许用户在文本框中输入单行文本。（v）
JTextField文本框允许用户在文本框中输入多行文本。（x）
JFrame类的对象的默认布局是BorderLayout布局。（v）
JTextField可以触发ActionEvent事件。（v）
一个应用程序中最多只能有一个窗口。（x）
JFrame创建的窗口默认是不可见的。（v）
窗口（JFrame）可以调用setTitle(String s)方法设置窗口的标题。（v）
JButton对象可以使用使用addActionLister(ActionListener l)方法将没有实现ActionListener接口的类的实例注册为自己的监视器。（x）
对于有监视器的JTextField文本框，如果该文本框处于活动状态（有输入焦点）时，用户即使不输入文本，只要按回车（Enter）键也可以触发ActionEvent事件。（v）
使用FlowLayout布局的容器最多可以添加5个组件。（x）
使用BorderLayout布局的容器被划分成5个区域。（v）
JPanel的默认布局是FlowLayout布局。（v）
在Java中能触发事件的组件，都用方法：
addXXXListener(XXXListener listener)将某个对象注册为自己的监视器，方法中的参数是一个接口，listener可以引用任何实现了该接口的类所创建的对象，当事件源发生事件时，接口listener立刻回调被类实现的接口中的某个方法。（v）
MVC是：
模型(model) 用于存储数据的对象。
视图(view) 为模型提供数据显示的对象。
控制器(controller) 处理用户的交互操作，对于用户的操作作出响应，让模型和视图进行必要的交互。（v）
一个容器可以调用setLayout(LayoutManager mgr)方法更改自己的布局。（v）
能触发ActionEvent事件的组件调用addActionListener（ActionListener listen）方法为自己注册一个监视器。（v）
创建监视ActionEvent事件的监视器的类必须实现KeyListener接口。（x）
以下哪个布局是JPanel容器的默认布局？
A.GridLayout
B.BorderLayout
C.CardLayout
D.FlowLayout
为了给JButton按钮b注册ActionEvent事件的监视器listen，下列哪个是正确的？
A.b.addActionListener(listen);
B.b.addItemListener(listen);
C.b.addKeyListener(listen);
D.b.addWindowListener(listen);
假设容器con的布局是BorderLayout，下列哪个将组建com添加到了con的北面。
A.con.add(com,BorderLayout.NORTH)。
B.con.add(com,BorderLayout.SOUTH)。
C.con.add(com,BorderLayout.EAST)。
D.con.add(com,BorderLayout.WEST)。
监视器listen为了监视JTextField文本框触发的ActionEvent事件，下列哪个是正确的？
A.创建监视器listen的类需要实现ActionListener接口。
B.创建监视器listen的类需要实现ItemListener接口。
C.创建监视器listen的类需要实现DocumentListener接口。
D.创建监视器listen的类需要实现KeyListener接口。
第十章
下列哪个叙述是正确的？
A.创建File对象可能发生异常。
B.BufferedRead流可以指向FileInputStream流。
C.BufferedWrite流可以指向FileWrite流。
D.RandomAccessFile流一旦指向文件，就会刷新该文件。
File类在java.io包中。（v）
输入流的指向称为流的源。（v）
输出流的指向称为流的目的地。（v）
程序如果需要读取程序"外部"的数据，可以创建指向外部的输入流。（v）
程序如果需要 将程序中数据，写入到程序"外部"，可以创建指向外部的输出流。（v）
如果程序要读取一个文件，可以创建指向文件的FileInputStream输入流。（v）
如果程序要读取一个文件，可以创建指向文件的FileOutputStream输出流。（x）
FileInputStream输入流按字节(byte)读取文件的内容。（v）
如果程序要读取一个文件，可以创建指向文件的FileReader输入流。（v）
如果程序要读取一个文件，可以创建指向文件的FileWriter输出流。（x）
FileOutputStream输出流按字节(byte)写出数据。（v）
下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？
import java.io.*;
public class E {
public static void main(String args[]){
File file = new File("hello.txt"); //【1】
long m = file.length(); //【2】
FileReader in = new FileReader(file); //【3】
try{
FileWriter out = new FileWriter(file); //【4】
}
catch(IOException exp){}
}
}
A.【1】
B.【2】
C.【3】
D.【4】
创建File对象f时：File f = new File(“perrty.txt”)，要求磁盘上必须有真实有perrty.txt文件。（x）
File类的long length()返回文件的长度（单位是字节）。（v）
FileOutputStream流顺序地写文件，只要不关闭流，每次调用write方法就顺序地向目的地写入内容，直到流被关闭。（v）
FileInputStream流顺序地读取文件，只要不关闭流，每次调用read方法就顺序地读取源中其余的内容，直到源的末尾或流被关闭。（v）
FileInputStream流的int read(byte b[]) 方法从源中试图读取b.length个字节到字节数组b中，返回实际读取的字节数目。如果到达文件的末尾，则返回-1。（v）
FileNotFoundException类是IOException类的子类。（v）
创建FileInputStream 对象，即文件字节输入流可能触发FileNotFoundException异常。（v）
FileWriter输出流按字符(char)写出数据。（v）
FileReader输入流按字符(char)读取文件的内容。（v）
假设hello.txt文件的内容是:ABCDEF，下列哪个是正确的？
import java.io.*;
public class E {
public static void main(String args[]){
File file = new File("hello.txt");
try {
FileInputStream in = new FileInputStream(file);
int c = in.read();
c = in.read();
System.out.println((char)c);
}
catch(IOException exp){}
}
}
A.下列程序编译出现错误。
B.下列程序在输出台输出字符 B。
C.下列程序在输出台输出字符 A。
D.下列程序在输出台输出 -1。
假设hello.txt文件的内容是:ABCDEF,下列哪个是正确的？
A.下列程序编译出现错误。
B.下列程序在输出台输出 AB。
C.下列程序在输出台输出字符 ABC。
D.下列程序在输出台输出 ABCDEF。
import java.io.*;
public class E {
public static void main(String args[]){
File file = new File("hello.txt");
byte [] b = new byte[(int)file.length()];
try {
FileInputStream in = new FileInputStream(file);
in.read(b);
System.out.println(new String(b));
}
catch(IOException exp){}
}
}
下列哪个是错误的？
A.File类的long length()方法返回文件的长度（单位是字节）。
B.BufferedWriter的目的地必须是字符输出流。
C.FileOutputStream输出流按字符(char)写出数据。
D.File类在java.io包中。
下列哪个是错误的？
A.程序如果需要读取程序"外部"的数据，可以创建指向外部的输入流。
B.程序如果需要将程序中数据，写入到程序"外部"，可以创建指向外部的输出流。
C.如果程序要读取一个文件，可以创建指向文件的FileInputStream输入流。
D.如果程序要读取一个文件，可以创建指向文件的FileOutputStream输出流。
下列哪个是错误的？
A.FileReader输入流按字符(char)读取文件的内容。
B.FileWriter输出流按字符(char)写出数据。
C.如果程序要读取一个文件，可以创建指向文件的FileReader输入流。
D.如果程序要读取一个文件，可以创建指向文件的FileWriter输出流。
下列哪个是错误的？
A.只要不关闭流，FileInputStream流每次调用read方法就从文件的头开始读取文件。
B.创建FileInputStream 对象，即文件字节输入流可能触发FileNotFoundException异常。
C.FileNotFoundException类是IOException类的子类。
D.FileInputStream流的int read(byte b[]) 方法从源中试图读取b.length个字节到字节数组b中，返回实际读取的字节数目。如果到达文件的末尾，则返回-1。
下列哪些是正确的？（多选）
A.只要不关闭流，FileInputStream流每次调用read方法就从文件的头开始读取文件。
B.创建FileInputStream 对象，即文件字节输入流可能触发FileNotFoundException异常。
C.FileNotFoundException类是IOException类的子类。
D.FileInputStream流的int read(byte b[]) 方法从源中试图读取b.length个字节到字节数组b中，返回实际读取的字节数目。如果到达文件的末尾，则返回-1。
如果磁盘上没有perrty.txt文件，创建File对象f时：File f = new File(“perrty.txt”)，就会在磁盘上创建perrty.txt。（x）
第十一章
Win10操作系统，然后键入：net start mysql（Win7 键 入mysqld），回车确认，启动MySQL数据库服务器。（v）
在MySQL安装目录的bin子目录下键入mysql 启动MySQL数据库服务器。（x）
MySQL服务器默认占用的端口是3306 。（v）
MySQL服务器的默认用户是root，对Win10 系统，root的初始密码是随机的，对于Win7系统，root 初始是无密码。（v）
Navicat for MySQL是一款MySQL客户端管理工具 。（v）
对于 MySQL8.0，Class.forName(“com.mysql.cj.jdbc.Driver”)是加载的JDBC-MySQL数据库驱动。（v）
ResultSet对象和数据库连接对象（Connection对象）实现了紧密的绑定，一旦连接对象被关闭，ResultSet对象中的数据立刻消失。（v）
ResultSet对象一次只能看到一个数据行，使用next()方法移到下一个数据行，next()方法最初的查询位置，即游标位置，位于第一行的前面。（v）
SQL语句：select * from mess where height>1.6 and height<=1.8
是查询mess表中字段（列）height值在1.6和1.8之间的记录（记录的各个列值都要）。（v）
SQL语句 select * from mess where name like ‘%林%’
是查询mess表中字段（列）name值包含有“林”的记录（记录的各个列值都要）。（v）
SQL语句 update mess set height =1.77 where name=‘张三’
是将mess表中name字段（列）值是张三的记录(行)的height的值更新为1.77。（v）
SQL语句 insert into mess values
(‘R1008’,‘将林’,‘2010-12-20’,1.66),(‘R1008’,‘秦仁’,‘2010-12-20’,1.66)
是向表mess里添加了两条记录（两行）。（v）
SQL语句delete from mess where number = ‘R1002’
是删除了mess表中字段number值是R1002的记录。（v）
事务由一组SQL语句组成，所谓事务处理是指：应用程序保证事务中的SQL语句要么全部都执行，要么一个都不执行。（v）
PreparedStatement对象被习惯地称作预处理语句对象。（v）
程序使用PreparedStatement对象不仅减轻了数据库的负担，而且也提高了访问数据库的速度。（v）
连接对象调用prepareStatement(String sql)方法对参数sql指定的SQL语句进行预编译处理，并返回一个PreparedStatement对象。（v）
下列【1】【2】【3】【4】注释标注的哪行代码有错误？
import java.sql.*;
public class E {
public static void main(String args[]) {
Connection con=null; //【1】
Statement sql; //【2】
ResultSet rs; //【3】
Class.forName("com.mysql.cj.jdbc.Driver"); //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
下列【1】【2】【3】【4】注释标注的哪行代码有错误？
import java.sql.*;
public class E {
public static void main(String args[]) {
Connection con=null;
Statement sql;
ResultSet rs;
try{ Class.forName("com.mysql.cj.jdbc.Driver"); //【1】
}
catch(Exception e){}
String uri ="jdbc:mysql://localhost:3306/students?"+
"useSSL=true&serverTimezone=CST";; //【2】
String user ="root";
String password ="";
try{
con = DriverManager.getConnection(uri,user,password); //【3】
}
catch(SQLException e){ }
sql=con.createStatement(); //【4】
}
}
A.【1】
B.【2】
C.【3】
D.【4】
对于MySQL8.0，下列哪个是加载JDBC-MySQL数据库驱动（连接器）
A.try{ Class.forName(“com.mysql.cj.jdbc.Driver”);
}
catch(Exception e){}
B.try{ Class.forName(“oracle.jdbc.driver.oracleDriver”);
}
catch(Exception e){}
C.try{ Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);
}
catch(Exception e){}
D.try{ Class.forName(“org.apache.derby.jdbc.EmbeddedDriver”);
}
catch(Exception e){}
下列哪个是加载JDBC-SQLServer数据库驱动（连接器）
A.try{ Class.forName(“com.mysql.jdbc.Driver”);
}
catch(Exception e){}
B.try{ Class.forName(“oracle.jdbc.driver.oracleDriver”);
}
catch(Exception e){}
C.try{ Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);
}
catch(Exception e){}
D.try{ Class.forName(“org.apache.derby.jdbc.EmbeddedDriver”);
}
catch(Exception e){}
下列哪个是加载JDBC-Oracle数据库驱动（连接器）
A.try{ Class.forName(“com.mysql.jdbc.Driver”);
}
catch(Exception e){}
B.try{ Class.forName(“oracle.jdbc.driver.oracleDriver”);
}
catch(Exception e){}
C.try{ Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);
}
catch(Exception e){}
D.try{ Class.forName(“org.apache.derby.jdbc.EmbeddedDriver”);
}
catch(Exception e){}
下列哪个是加载JDBC-Derby数据库驱动（连接器）
A.try{ Class.forName(“com.mysql.jdbc.Driver”);
}
catch(Exception e){}
B.try{ Class.forName(“oracle.jdbc.driver.oracleDriver”);
}
catch(Exception e){}
C.try{ Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);
}
catch(Exception e){}
D.try{ Class.forName(“org.apache.derby.jdbc.EmbeddedDriver”);
}
catch(Exception e){}
下列哪个是错误的？
A.Win10操作系统，然后键入：net start mysql（Win7 键 入mysqld），回车确认，启动MySQL数据库服务器。
B.在MySQL安装目录的bin子目录下键入mysql 启动MySQL数据库服务器。
C.MySQL服务器默认占用的端口是3306 。
D.MySQL服务器的默认用户是root，对于Win10 ，初始密码是随机的，对于Win7密码为空(没有密码)。
下列哪个是错误的？
A.SQL语句：select * from mess where height>1.6 and height<=1.8
是查询mess表中字段（列）height值在1.6和1.8之间的记录（记录的各个列值都要）。"
B.SQL语句 select * from mess where name like ‘%林%’ 是查询mess表中字段（列）name值等于“林”的记录（记录的各个列值都要）。"
C.SQL语句 update mess set height =1.77 where name=‘张三’
是将mess表中name字段（列）值是张三的记录(行)的height的值更新为1.77。
D.SQL语句 insert into mess values
(‘R1008’,‘将林’,‘2010-12-20’,1.66),(‘R1008’,‘秦仁’,‘2010-12-20’,1.66)
是向表mess里添加了两条记录（两行）。
下列哪个是错误的？
A.程序使用PreparedStatement对象不仅减轻了数据库的负担，而且也提高了访问数据库的速度。
B.连接对象调用prepareStatement(String sql)方法对参数sql指定的SQL语句进行预编译处理，并返回一个PreparedStatement对象。
C.结果集rs执行rs.getString(1)按字符串返回结果集当前行第1列的值。
D."jdbc:mysql://localhost:3306/students?useSSL=true"中的"mysql"是用户数据库的名字。
下列哪个是正确的？（多选）
A.Win10操作系统，然后键入：net start mysql（Win7 键 入mysqld），回车确认，启动MySQL数据库服务器。
B.在MySQL安装目录的bin子目录下键入mysql 启动MySQL数据库服务器。
C.MySQL服务器默认占用的端口是3306 。
D.MySQL服务器的默认用户是root，密码为空(没有密码)。
下列哪些是正确的？（多选）
A.SQL语句：select * from mess where height>1.6 and height<=1.8
是查询mess表中字段（列）height值在1.6和1.8之间的记录（记录的各个列值都要）。
B.SQL语句 select * from mess where name like '%林%'是查询mess表中字段（列）name值等于“林”的记录（记录的各个列值都要）。
C.SQL语句 update mess set height =1.77 where name=‘张三’
是将mess表中name字段（列）值是张三的记录(行)的height的值更新为1.77。
D.SQL语句 insert into mess values
(‘R1008’,‘将林’,‘2010-12-20’,1.66),(‘R1008’,‘秦仁’,‘2010-12-20’,1.66)
是向表mess里添加了两条记录（两行）。
下列哪个是错误的？
A.程序使用PreparedStatement对象会加重数据库的负担。
B.连接对象调用prepareStatement(String sql)方法对参数sql指定的SQL语句进行预编译处理，
并返回一个PreparedStatement对象。
C.结果集rs执行rs.getString(1)按字符串返回结果集当前行第1列的值。
D."jdbc:mysql://localhost:3306/students?useSSL=true"中的"students"是用户数据库的名字。
第十二章
下列哪个叙述是错误的？
A.线程新建后，不调用start方法也有机会获得CPU资源。
B.如果两个线程需要调用同一个同步方法，那么一个线程调用该同步方法时，另一个线程必须等待。
C.目标对象中的run方法可能不启动多次。
D.默认情况下，所有线程的优先级都是5级。
对于下列程序，哪个叙述是正确的？
A.JVM认为这个应用程序共有两个线程。
B.JVM认为这个应用程序只有一个主线程。
C.JVM认为这个应用程序只有一个thread线程。
D.thread的优先级是10级。
public class E {
public static void main(String args[]) {
Target target =new Target();
Thread thread =new Thread(target);
thread.start();
}
}
class Target implements Runnable{
public void run(){
System.out.println("ok");
}
}
对于下列程序，哪个叙述是正确的？
A.JVM认为这个应用程序共有两个线程。
B.JVM认为这个应用程序只有一个主线程。
C.JVM认为这个应用程序只有一个thread线程。
D.程序有编译错误，无法运行。
public class E {
public static void main(String args[]) {
Target target =new Target();
Thread thread =new Thread(target);
target.run();
}
}
class Target implements Runnable{
public void run(){
System.out.println("ok");
}
}
线程不是进程，但其行为很象进程，线程是比进程更小的执行单位。（v）
一个进程在其执行过程中，可以产生多个线程。（v）
一个进程在其执行过程中，至多可以产生1个线程。（x）
Java应用程序总是从主类的main方法开始执行，JVM加载代码，发现main方法之后，就会启动一个线程，这个线程称为“主线程”（main线程），该线程负责执行main方法。（v）
线程在它的一个完整的生命周期中通常要经历如下的四种状态:1.新建, 2．运行 ,3中断,4．死亡。（v）
可以使用Thread类或其子类创建（新建）线程。（v）
线程调用start方法将启动线程，使之从新建状态进入就绪队列排队。（v）
一旦轮到它来享用CPU资源时，就可以脱离创建它的线程独立开始自己的生命周期了。（v）
线程不调用start方法，JVM就不会把它当作一个线程来对待，仅仅当作一个普通的对象而已。（v）
线程处于“新建”状态时（在调用start方法之前），线程调用isAlive()方法返回的值是false。（v）
currentThread()方法是Thread类中的static方法，该方法返回当前正在使用CPU资源的线程.（v）
线程调用interrupt()方法将使得处于speep方法或wait方法中断的该线程触发InterruptedException异常。（v）
当一个线程调用synchronized方法时，其他线程想调用这个synchronized方法时就必须等待，直到线程A调用完该synchronized方法。（v）
wait()、notify()和notifyAll()都是Object类中的final方法，被所有的类继承、且不允许重写的方法。（v）
一个线程在执行同步方法时，如果执行wait()方法，使本线程进入中断，就允许其它线程使用这个同步方法。（v）
一个因执行wait方法进入中断状态的线程，需要其他线程执行notify()或notifyAll()通知它结束中断状态。（v）
线程在执行完run()方法之前，如果再次让线程执行start方法，就会发生ILLegalThreadStateException 异常。（v）
javax.swing.Timer类称为计时器线程，计时器的监视器必须是组件类的子类的实例，否则计时器无法启动。（v）
必须在synchronized方法中使用wait()方法、notify()及notifyAll()方法。（v）
线程的默认级别是10级。（x）
Java中的线程不可以共享数据。（x）
进入运行状态的线程，调用isAlive()方法返回的值是true。（v）
一个线程调用synchronized方法期间，执行sleep方法进入中断后，其他线程就能成功调用这个synchronized方法。（x）
下列哪个是正确的?
A.线程被创建，在JVM管理的线程队列立刻就有这个线程。
B.当一个线程进入中断状态后，它被放在JVM管理的线程队列中的最前面排队等待CPU资源，以便从中断处继续运行。
C.一个线程从死亡状态可以再回到中断状态。
D.线程调用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。
下列哪个叙述是正确的？
A.run()方法是Runnable接口中的方法。
B.start()方法是Runnable接口中的方法。
C.sleep()方法是Runnable接口中的方法。
D.interrupt()方法是Runnable接口中的方法。
下列哪个叙述是正确的?
A.多线程需要多个CPU才可以。
B.多线程需要多个进程来实现。
C.一个进程可以产生多线程。
D.线程之间无法实现数据共享。
下列哪个方法可以让新建的线程进入JVM管理的线程列队中？
A.start()。
B.run()。
C.init()。
D.isAlive()。
哪个叙述是错误的？
A.线程不是进程，但其行为很象进程，线程是比进程更小的执行单位。
B.一个进程在其执行过程中，可以产生多个线程。
C.一个进程在其执行过程中，至多可以产生1个线程。
D.JVM加载代码，发现主类的main方法之后，就会启动一个线程，这个线程称为“主线程”（main线程），该线程负责执行main方法。