单选题
（1）public static void main(String[] args){
int a = 7;
System.out.println(a%3);
}（D）。
A．2.0 B．2 C．1.0 D．1
（2）使用javac命令编译源程序文件将产生字节码文件，这些字节码文件的扩展名为(B)。
A．.java B．.class C．.html D．.exe
（3）关于方法main（C）的说法哪个正确？
A．方法main（）只能放在公共类中
B．main()的头定义可以根据情况任意更改
C．一个类中可以没有main()方法
D．所有对象的创建都必须放在main()方法中
（4）java程序中，main方法的格式正确的是（D）。
A．static void main（String[] args）
B．public void main（String[] args）
C．public static void main（String args）
D．public static void main（String[] args）
（5）下列关于Java语言的特点，描述错误的是（C）。
A．Java是跨平台的编程语言
B．Java支持分布式计算
C．Java是面向过程的编程语言
D．Java支持多线程
（6）下列哪项不是Java核心API中的接口（D）。
A．Set B．Collenction C．Map D．Collections
（7）下列说法正确的是（A）。
A．JAVA程序的main方法必须写在类里面
B．JAVA程序中可以有多个main方法
C．JAVA程序中类名必须与文件名一样
D．JAVA程序的main 方法中如果只有一条语句，可以不用H(大括号)括起来
（8）JAVA所定义的版本中不包括(D)。
A．JAVA2 EE B．JAVA2 Card C．JAVA2 ME D．JAVA2 HE E．JAVA2 SE
多选题
（1）下面能输出字符串“SoutTest.main”的Java语句有（ABCD）。
A．System.out.print("SoutTest.main");
B．System.out.println("SoutTest.main");
C．System.out.printf("SoutTest.main");
D．System.out.printf("%s","SoutTest.main");
判断题
（1）在一个Java源程序文件中，可以有多个public类。（F）
（2）Java语言是SUN公司开发的一种结构化程序设计语言。（F）
（3）在Java程序中如果没有定义main()方法，则程序不能运行。（T）
（4）Java源文件“一次编译，处处运行”，指的是Java的可移植性。（T）
（5）Java语言是一门跨平台性的语言。（T）
（6）JRE是Java语言的开发环境。（F）
填空题
（1）判断用户从键盘输入的数据是否合法，可以调用Scanner对象的 hasNextInt() 。
简答题
（1）描述类加载器的种类。
1）动类加载器Bootstrap ClassLoader：是Java类加载层次中最顶层的类加载器，负责加载JDK中的核心类库,此类加载器并不继承于java.lang.ClassLoader,不能被java程序直接调用；这个类加载器负责放在<JAVA_HOME>\lib目录中的，或者被-Xbootclasspath参数所指定的路径中的。
2）扩展类加载器Extensions ClassLoader：这个类加载器由sun.misc.Launcher$AppClassLoader实现。它负责<JAVA_HOME>\lib\ext目录中的，或者被java.ext.dirs系统变量所指定的路径中的所有类库。用户可以直接使用
3）应用程序类加载器Application ClassLoader：这个类由sun.misc.Launcher$AppClassLoader实现。是ClassLoader中getSystemClassLoader()方法的返回值。它负责用户路径（CLASSPATH）所指定的类库。用户可以直接使用。如果用户没有自己定义类加载器，默认使用这个。
4）自定义类加载器Customer ClassLoader：用户自己定义的类加载器。也就是自己去写一个继承java.lang.ClassLoader这个类。
（2）请简述命令java、javac命令的作用。
javac源代码编译成字节码文件Hello.class；java通过JVM将编译后产生的字节码文件加载到内存中解释运行。
（3）请简述环境变量中的CLASSPATH，PATH，JAVA_HOME这三个环境变量的作用。
JAVA_HOME：简化其它变量设置过程中的内容输入。可先行将JDK的安装路径定义为一变量，以后凡使用到JDK 安装路径的地方均使用该变量进行替换。
PATH：指定执行外部命令时找寻对应可执行文件的路径范围。
CLASSPATH：代表Java类的根路径，java命令会从CLASSPATH中寻找所需的Java类；Java编译器编译Java类时，也会从CLASSPATH中寻找所需的Java类；classpath的默认值为当前路径。
（4）描述java程序从编写到编译到运行的过程。
1）编写：根据Java语法规则去编写Java源代码文件。
2）编译：在Java中指将java文件转化为.class文件（字节码文件）的过程。其中这个字节码文件，真正的实现了跨平台、跨语言。因为JVM里运行的就是.class文件，只要符合这个格式就能运行。所以在任何平台用任何语言只要你能把程序编译成字节码文件就能在JVM里运行。
3）类加载：类加载器加载.class文件到内存中。
4）执行：引擎寻找main（）方法，执行其中字节码指令。
（5）JDK、JRE、JVM是什么，他们的作用又是什么？
JDK(Java Development Kit)：指的是Java开发工具集。JDK是整个Java的核心，包括了Java基础类库、Java运行环境（JRE）和Java开发工具（这些开发工具都是可执行程序，主要包括：javac编译工具；java运行工具；javadoc生成JavaDoc文档的工具；jar打包工具）是做Java开发必须要安装的。
JRE(Java Runtime Environment)：指的是Java运行时环境。Java程序运行时必需要JRE的支持。如果系统只安装JRE的话，则意味着系统可以跑任何Java程序，但不能做Java开发。
JVM(Java Virtual Machine)：就是我们常说的java虚拟机，它是整个java实现跨平台的最核心的部分，所有的java程序首先被编译为.class文件，这种类文件可以在虚拟机上运行，也就是说class并不直接与机器的操作系统相对应。而是经过虚拟机间接的与操作系统交互，由虚拟机将程序解释给本地系统执行，只有JVM还不能将class执行，因为在解释class的时候JVM需要调用解释所需要的类库lib，而jre包含lib类库，JVM屏蔽了具体操作系统平台的相关信息，使得java程序只需要生成在java虚拟机上运行的目标代码。可以在多种平台（操作系统）上不加修改的运行。
（6）描述一下JVM加载class文件的原理机制。
1）装载：查找和导入class文件。
2）连接：
① 检查:检查载入的class文件数据的正确性；
② 准备:为类的静态变量分配存储空间；
③ 解析:将符号引用转换成直接引用(这一步是可选的)。
3）初始化：初始化静态变量，静态代码块。这样的过程在程序调用类的静态成员的时候开始执行，所以静态方法main()才会成为程序的入口方法。类的构造器也会引发该动作。
（7）对于Java是解释型语言还是编译型语言你有什么看法？
由Java的代码的执行过程可知，一个Java代码的执行过程是由.Java ==>.class ==>对应平台机器码;.Java==>.class是由Javac编译，这个过程符合编译型语言的特点（一次性编译，注意并未编译为实际平台的机器码，）而.class ==>对应平台机器码的这一过程是由Java解释执行（逐行解释为特定平台机器码）这一过程符合解释语言的特点；所以说Java既是编译型语言，又是解释型语言。
编程题
（1）下面是一个Java源文件，改正其中的错误。
package com.briup.md01;
public class Test4 {
public void main(String[] args) {
System.out.println("What's wrong with this program?");
}
}
改：
package com.briup.md01;
public class Test4 {
//main方法声明不正确 修饰符缺失
public void main(String[] args) {
System.out.println("What's wrong with this program?");
}
}
第二单元习题
单选题
（1）下列语句片段中，four的值为（D）。
int three = 3;
char one = ‘1’;
char four = (char)(three + one);
A．3 B．1 C.31 D．4
（2）下列文档注释正确的是（C）。
A．/*我爱北京天安门*/ B．//我爱北京天安门*/
C．/**我爱北京天安门*/ D．/*我爱北京天安门**/
（3）设x = 1 , y = 2 , z = 3，则表达式y＋＝z－－/＋＋x的值是（A）。
A．3 B．3.5 C．4 D．5
（4）为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为（A）。
A．static void method( ) B．public void method( )
C．final void method( ) D．abstract void method( )
（5）Java支持的类型有两类：基本类型和引用类型，下面是引用类型的是（B）。
A．boolean B．String C．int D．long
（6）给定如下java代码，编译运行时，结果是（A）。
public class Test{
public static void main (String args[ ]) {
for (int i=0;i<3;i++) {
System.out.print(i);
}
System.out.print(i);
}
}
A．编译时报错 B．正确运行，输出012
C．正确运行，输出123 D．正确运行，输出0123
（7）如果局部变量和成员变量同名，如何在局部变量作用域内引用成员变量（B）。
A．不能引用，必须改名，使它们的名称不相同
B．在成员变量前加this，使用this访问该成员变量
C．在成员变量前加super，使用super访问该成员变量
D．不影响，系统可以自己区分
（8）while循环和do…while循环的区别是（D）。
A．没有区别，这两个结构任何情况下效果一样
B．while循环比 do…while循环执行效率高
C．while循环是先循环后判断，所以循环体至少被执行一次
D．do…while循环是先循环后判断，所以循环体至少被执行一次
（9）关于for循环和while循环的说法哪个正确（B）。
A．while循环先判断后执行，for循环先执行后判断。
B．while循环判断条件一般是程序结果，for循环的判断条件一般是非程序结果
C．两种循环任何时候都不可以替换
D．两种循环结构中都必须有循环体，循环体不能为空
（10）下列标识符哪个是合法标识符（B）。
A．&abc B．abc C．int D．3qwe
（11）编译运行以下程序后，关于输出结果的说明正确的是（C）。
public class Conditional{
public static void main(String args[ ]){
int x=4;
System.out.println("value is "+ ((x>4) ? 99.9 :9));
}
}
A．输出结果为：value is 99.99 B．输出结果为：value is 9
C．输出结果为：value is 9.0 D．编译错误
（12）类Test1定义如下：
public class Test1{
public float aMethod(float a，float b){
}
}
将以下哪种方法插入行3是不合法的。（B）
A．public float aMethod（float a，float b，float c）{ }
B．public float aMethod（float c，float d）{ }
C．public int aMethod（int a，int b）{ }
D．private float aMethod（int a，int b，int c）{ }
（13）以下程序的输出结果为（D）。
public static void main(String[] args) {
int x = 1, y = 1, z =1;
if(x--==1&&y--==1||z--==1)
System.out.println(“x=” +x+”, y=” +y+”, z=” +z);
}
A．x=0, y=1, z=1 B．x=0, y=2, z=2
C．x=0, y=2, z=1 D．x=0, y=0, z=1
（14）以下程序的运行结果是（B）。
public class increment{
public static void main(string args[]){
int a;
a=6;
System.out.print(a);
System.out.print(a++);
System.out.print(a);
}
}
A．666 B．667 C．677 D．676
（15）关于下列程序段的输出结果，说法正确的是（D）。
public class Test2{
static int i;
public static void main(String argv[]){
System.out.println(i);
}
}
A．有错误，变量i没有初始化 B．null
C．1 D．0
（16）下列程序编译或运行的结果是（D）。
public static void main(String args[]){
int a = 10;
int b,c;
if(a>50){
b=9;
}
c = b + a;
System.out.println(c);
}
A．10 B．19 C．9 D．编译错误
（17）下列输出结果是（C）。
int a = 0 ;
while ( a<= 5 ) {
switch(a){
case 0:case 3 : a = a + 2;
case 1 :case 2 : a = a + 3;
default : a = a + 5;
}
}
System.out.print (a) ;
A．0 B．5 C．10 D．其他
（18）下面有关for循环的描述正确的是（A）。
A．for循环体语句中，可以包含多条语句，但要用大括号括起来
B．or循环只能用于循环次数已经确定的情况
C．在for循环中，不能使用break语句跳出循环
D．for循环是先执行循环体语句，后进行条件判断
（19）在java中下列关于自动类型转换说法正确的是（A）。
A．基本数据类型和String相加结果一定是字符串型
B．char类型和int类型相加结果一定是字符
C．double类型可以自动转换为int
D．char + int + double +结果一定是double
（20）下列代码输出结果是（B）。
int i = 10;
while ( i > o ){
i = i + 1;
if ( i = =10 ){
break;
}
}
A．while循环执行10次 B．死循环
C．循环一次都不执行 D．循环执行一次
（21）设有定义int i=123; long j=456;下面赋值不正确的语句是（D）。
A．j=i; B．j=(long)i; C．i=(int)j; D．i=j;
（22）设int型变量a、b，float型变量x、y，char型变量ch均已正确定义并赋值，正确的switch语句是（D）。
A．switch (x + y) B．switch ( ch + 1 ) { } { }
C．switch ch D．switch ( a + b ); { } { }
（23）以下由for语句构成的循环执行的次数是（B）。
for ( int i = 0; true ; i++)"
A．有语法错，不能执行 B．无限次
C．执行1次 D．一次也不执行
（24）下面哪一个循环会导致死循环（C）。
A．for (int k = 0; k < 0; k++) B．for (int k = 0; k < 0; k++)
C．for (int k = 0; k < 10; k--) D．for (int k = 0; k > 0; k++)
（25）下列语句序列执行后，i的值是（D）。
int i=16;
do { i/=2; } while( i > 3 );"
A．16 B．8 C．4 D．2
（26）下列语句序列执行后，k的值是（B）。
int m=3, n=6, k=0;
while( (m++) < ( -- n) ) ++k;"
A．0 B．1 C．2 D．3
（27）以下代码输出结果为（A）。
double c= 1+5%2;
System.out.println(c);
A．2 B．0 C．2 D．0
（28）为什么常量都是静态的（B）。
A．因为常量必须是静态的，这是语法规定
B．因为常量的值不变，没有必要让各实例保留一份
C．因为非静态的常量不是常量
D．以上说法都不对
（29）以下定义一维数组的语句中，正确的是（D）。
A．inta[5] B．int a[]=new [5];
C．int a[];int a=newint[5]; D．int a[]={1,2,3,4,5};
（30）Java中跳过本次循环应该使用什么关键字（C）。
A．break B．return C．continue D．next
（31）以下语句的输出结果是（A）。
public class ForTest {
public static void main(String[] args) {
int a[][] = {{1}, {2, 2}, {3, 3, 3}};
int sum = 0;
for (int i = 0; i < a．length; i++) {
for (int j = 0; j < a[i]．length; j++) {
sum += a[i][j];
}
}
System.out.println(""sum="" + sum);
}
}"
A．sum=14 B．sum=12 C．sum=10 D．sum=20
（32）下列程序段执行后b3的结果是（D）。
boolean b1=true, b2, b3; 24= b1 ? b1 : b2;
A．0 B．1 C．true D．false
（33）整型数据类型中，需要内存空间最少的是（D）。
A．short B．long C．int D．byte
（34）下列值不为true的表达式有（C）。
A．"john" = = "john" B．"john".equals("john") "john" = "john"
C．"john" = "john" D．"john".equals(new String("john"))
（35）运算符优先级别排序正确的是（A）
A．由高向低分别是：算术运算符、关系运算符、逻辑运算符、赋值运算符
B．由高向低分别是：关系运算符、算术运算符、赋值运算符、逻辑运算符
C．由高向低分别是：算术运算符、逻辑运算符、关系运算符、赋值运算符
D．由高向低分别是：关系运算符、赋值运算符、算术运算符、逻辑运算符
（36）（A）表达式不可以作为循环条件。
A．i++; B．i>5;
C．bEqual = str.equals("q") D．count == i;
（37）表达式(11+3*8)/4%3的值是（D）。
A．31 B．0 C．1 D．2
（38）以下（C）不是合法的标识符。
A．STRING B．x3x C．void D．de$f
（39）为一个boolean类型变量赋值时，可以使用（B）。
A．boolean = 1; B．boolean a = (9 >= 10)
C．boolean a="真" D．boolean a == false
（40）变量命名规范说法正确的是（B）.
A．变量由字母、下划线、数字、$符号随意组成
B．变量不能以数字作为开头
C．和a在java中是同一个变量
D．不同类型的变量，可以起相同的名字
（41）for循环的条件部分分成三段，对此以下说法不正确的是（C）。
A．各段以分号分割 B．中间段是条件表达式
C．最后段的表达式只执行一次 D．首段的表达式只执行一次
（42）在JAVA中，（B）关键字用来终止循环语句。
A．return B．break C．continue D． exit
（43）以下语句中，String str = “123456789”;str =str.subString(1,3);执行后str中的值为（A）。
A．"23" B．"123" C．"12" D．"234"
（44）下列程序的运行结果是（B）。
public class sun {
public static void main(String[] args) {
int x= 4, y = 0;
if(Math.pow(x, 2) == 16) {
y = x;
}
if(Math.pow(x, 2) < 15){
y = 1/ x;
}
if(Math.pow(x, 2) > 15){
y =(int) Math．pow(x, 2) + 1;
}
System.out.println(y);
}
}
A．4 B．17 C．18 D．25
（45）下列程序的执行结果是（B）。
public class Test2 {
void printValue(int m) {
do {
System.out.println(""The value is "" + m);
} while (--m > 10);
}
public static void main(String[] args) {
int i = 10;
Test2 t = new Test2();
t.printValue(i);
}
}
A．The value is 8 B．The value is 10
C．The value is 9 D．The value is 11
（46）下列javadoc注释正确的是（C）。
A．/*这是javadoc注释*/
B．/这是javadoc注释
C．/**
* 这是javadoc注释
*/
D．/*
* 这是javadoc注释
*/
多选题
（1）静态变量和实例变量的区别（ABC）。
A．静态变量是被static修饰符修饰的变量
B．实例变量必须依存某一实例，需要首先创建对象然后通过对象才能访问它
C．静态变量可以实现让多个对象共享内存
D．每次调用静态变量时，都首先需要创建实例对象
（2）下列（AC）属于引用数据类型。
A．String B．char C．用户自定义的Student类类型 D．int
（3）引用类型有哪些（ABC）。
A．类类型 B．数组类型 C．接口类型 D．整数类型
（4）以下不是Java基本数据类型的是（BD）。
A．char B．string C．byte D．date
判断题
（1）Java的字符类型采用的是Unicode编码，但所占字节由具体软硬件环境决定。（F）
（2）如果在类中未给成员变量赋予初值，则在系统执行时，不会自动对类中的成员进行初始化。（F）
（3）在Java的方法中定义一个常量要用const关键字。（F）
（4）Java语言的基本数据类型有4种：整型、浮点型、字符型和布尔型。（T）
（5）以//开始的是多行注释语句。（F）
（6）在循环语句中，使用continue;语句可以跳出循环。（F）
（7）语句int a=6--;能输出a。（F）
（8）while语句和do ...while语句的区别是，是否在第一次执行时进行条件判断。（T）
填空题
（1）假定x和y为整型变量其值分别为16和5，则x/y的值是 3 (double)x/y的值是 3.2
（2）代码10 >= 6 + 8 && 7 – 3 < 13 || 4 > 9 && ! false && !(50 > 3 + 9 + 10) 的最终运行结果是 false 。
（3）分别用 class 关键字来定义类，用 new 关键字来分配实例存储空间。
（4）假设x=13，y=4，则表达式x%y != 0的值是 true ，其数据类型是 boolean 。
（5）当一个方法的返回类型被定义为 void 时，表明该方法不返回任何值。
（6） 假定整数变量x的值为10，则执行y=2*x++赋值后，x和y的值分别为 11 和 20 。
（7）Java中用于声明一个常量的修饰符为 final 。
（8）程序语句如下：
int grade1=75;
String grade2="优秀";
String result = (grade1>90 && grade2.equals("优秀"))?"三好学生":"普通学生";
字符串变量result的值为： 普通学生 。
（9）Java的数据类型可以分为两大类： 基本数据类型 和引用数据类型。
（10） 类 是Java程序中基本的结构单位。
（11）以下代码运行后控制台会输出什么 0.0416666666666667
int count=0;
while(count>0){
System.out.println(count);
}
（12）以下代码执行后控制台会输出什么 年轻人
int age=45;
if(age>20) {
System.out.println(""年轻人"");
}else if(age>40){
System.out.println(""中年人"");
}else if(age>60){
System.out.println(""老年人"");
}
（13）在JDK1.6中switch选择结构能判断的数据类型只能是 int 和 char
（14）boolean类型的可能取值有 true 和 false
（15）Java语言提供了两种选择分支结构，主要的关键字分别是 if 和 switch
简答题
（1）分析以下代码的运行结果。
System.out.println(5&9);
System.out.println(5|9);
System.out.println(5^9);
System.out.println(~-5);
System.out.println(5<<2);
System.out.println(-5<<2);
System.out.println(-5>>2);
System.out.println(-5>>>2);
System.out.println(5>>2);
System.out.println(5>>34);
System.out.println(97=='a');
System.out.println(5.0==5);
System.out.println(4>5 ^ 'c'>'a');
System.out.println((int)(char)(byte)-1);
/* *************************
* 5: 0000 0101
* &
* 9: 0000 1001
* -------------
* 0000 0001
* *************************
*/
System.out.println(5&9);//1
/* *************************
* 5: 0000 0101
* |
* 9: 0000 1001
* -------------
* 0000 1101
* *************************
*/
System.out.println(5|9);//13
/* *************************
* 5: 0000 0101
* ^
* 9: 0000 1001
* -------------
* 0000 1100
* *************************
*/
System.out.println(5^9);//12
/* *************************
*数据在内存中是以补码的形式存在的
* -5: 1000 0101
* 反码：1111 1010
* 补码：1111 1011
* 取反 0000 0100
* *************************
*/
System.out.println(~-5);//4
/* *************************
* 5: 0000 0101
* 左移2位: 0001 0100
* *************************
*/
System.out.println(5<<2);//20
/* *************************
* -5源码: 1000 0101
* 反码: 1111 1010
* 补码: 1111 1011
* 左移2位:1110 1100
* 反码:1110 1011
* 原码:1001 0100
* *************************
*/
System.out.println(-5<<2);-20
/* *************************
* -5: 1000 0101
* 反码: 1111 1010
* 补码: 1111 1011
* 右移: 1111 1110
* 反码: 1111 1101
* 原码: 1000 0010
* *************************
*/
System.out.println(-5>>2);//-2
/* *************************
* -5: 1000 0000 0000 0000 0000 0000 0000 0101
* 反码: 1111 1111 1111 1111 1111 1111 1111 1010
* 补码: 1111 1111 1111 1111 1111 1111 1111 1011
* 右移: 0011 1111 1111 1111 1111 1111 1111 1110
* *************************
*/
System.out.println(-5>>>2);//1073741822
/**
* 5: 0000 0101
* 右移 0000 0001
*/
System.out.println(5>>2);//1
/**
* 5: 0000 0101
* 右移 0000 0001
*
*/
System.out.println(5>>34);//1
System.out.println(97 == 'a');//true
System.out.println(5.0 == 5);//true
/**
* false^true
*/
System.out.println(4 > 5 ^ 'c' > 'a');// true
/**
*
* -1(int): 1000 0000 0000 0000 0000 0000 0000 0001
* 反码: 1111 1111 1111 1111 1111 1111 1111 1110
* 补码: 1111 1111 1111 1111 1111 1111 1111 1111
* (byte) -1: 1111 1111
* 反码: 1111 1110
* 原码: 1000 0001 ->-1
* -1(int): 1000 0000 0000 0000 0000 0000 0000 0001
* 反码: 1111 1111 1111 1111 1111 1111 1111 1110
* 补码: 1111 1111 1111 1111 1111 1111 1111 1111
* (char)-1 : 1111 1111 1111 1111 ->65535
* 65535: 0000 0000 0000 0000 1111 1111 1111 1111
*
*/
System.out.println((int)(char)(byte)-1);
（2）swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上？
在Java 5以前，switch(expr)中，expr只能是byte、short、char、int；从Java 5开始，Java中引入了枚举类型，expr也可以是enum类型，从Java 7开始，expr还可以是字符串（String），但是长整型（long）在目前所有的版本中都是不可以的。
（3）请解释&和&&、|和||的区别。
1）&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&&改为&，则会抛出NullPointerException异常；&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。
2）普通或（|）表示所有的判断条件都要执行，不管前面是否满足；短路或（||）表示如果前面的条件已经是true了，那么后面无论如何判断都是true，就不判断了。
（4）==和equals的区别是什么？
==对于基本类型来说是值比较，对于引用类型来说是比较的是引用；
equals默认情况下是引用比较，只是很多类重新了equals方法，比如String、Integer等把它变成了值比较，所以0.5情况下equals比较的是值是否相等。
（5）String是最基本的数据类型吗?
不是；基本数据类型包括byte、int、char、long、float、double、boolean和short。除了基本数据类型（primitive type）和枚举类型（enumeration type），剩下的都是引用类型。
编程题
（1）判断101-200之间有多少个素数，并输出所有素数。(只能被1和它本身整除的自然数为素数)。
for (int i = 101; i < 200; i++) {
boolean is = true;
for (int j = 2; j < i; j++) {
if (i % j==0) {
is = false;
break;
}
}
if (is) {
System.out.print(i + " ");
}
}
（2）编写代码实现如下效果的九九乘法表。
int N = 10;
for (int i = 1; i < N; i++) {
for (int j = 1; j < i+1; j++) {
System.out.print(j+"*"+i+"="+j*i+"\t");
}
System.out.println();
}
第三单元习题
单选题
（1）对象的特征在类中表示为变量，称为类的（B）。
A．对象 B．属性 C．方法 D．数据类型
（2）类与对象的关系是（A）。
A．类是对象的抽象 B．对象是类的抽象
C．对象是类的子类 D．类是对象的具体实例
（3）在Java中,关于构造方法，下列说法错误的是（C）。
A．构造方法的名称必须与类名相同 B．构造方法可以带参数
C．构造方法不可以重载 D．构造方法绝对不能有返回值
（4）不允许作为类及类成员的访问控制符的是（D）。
A．public B．private C．protected D．static
（5）关于包说法不正确的是（A）。
A．一个Java文件中只能有一个import语句
B．使用package关键字可以指定类的所属的包
C．包在物理上的表现形式是嵌套的文件目录
D．导入包需要使用的关键字import
（6）如果一个类的成员变量只能在所在类中使用，则该成员变量必须使用的修饰是（C）。A．public B．protected C．private D．static
（7）访问修饰符作用范围由大到小是（D）。
A．private-default-protected-public B．public-default-protected-private
C．private-protected-default-public D．public-protected-default-private
（8）以下对重载描述错误的是（B）。
A．方法重载只能发生在一个类的内部
B．构造方法不能重载
C．重载要求方法名相同，参数列表不同
D．方法的返回值类型不是区分方法重载的条件
（9）A派生出子类B，B派生出子类C，并且在Java源代码中有如下声明：
A a0=new A（）;
A a1=new B（）;
A a2=new C（）;
问以下哪些说法是正确的（D）。
A．只有第一行能通过编译
B．第1、2行能通过编译，但第3行编译出错误
C．第1、2、3行能通过编译，但第2、3行运行时出错
D．第1行、第2行和第3行的声明都是正确的
（10）下列选项中，用于在定义子类时声明父类的关键字是（C） 。
A．interface B．package C．extends D．abstract
（11）给定如下java代码，编译时会在（D）出现错误。
class Parent{
}
class Child extends Parent{
public static void main（String args[]）{
Parent p1=new Child()；//第一行
Parent p2=new Parent()；//第二行
Child c1=new Child()；//第三行
Child c2=new Parent()；//第四行
}
}
A．第一行 B．第二行 C．第三行 D．第四行
（12）在Java中，由Java编译器自动导入，而无需在程序中用import导入的包是（C）。
A．java.applet B．java.awt C．java.lang D．java.util
（13）指出下列哪个方法与方法public void add(int a){}为不合法的重载方法（A）。
A．public void add(int a) B．public void add(Stringa)
C．public void add(int a，int b) D．public void add(float a)
（14）下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（C）。
A．public B．private C．static D．final
（15）Java语言的类间的继承关系是（B）。
A．多重的 B．单重的 C．线程的 D．不能继承
（16）关于以下程序段，正确的说法是(C)。
String s1=“a”+“b”;
String s2=new String（s1）；
If(s1==s2）
System.out.println(“= = is succeeded”);
if(s1.equals(s2))
System.out.println(“.equals() is succeeded”);
A．行4与行6都将执行 B．行4执行，行6不执行
C．行6执行，行4不执行 D．行4、行6都不执行
（17）下面哪个函数是public void aMethod(){...}的重载函数（D）。
A．void aMethod( ){...} B．public int aMethod(){...}
C．public void aMethod( ){...} D．public int aMethod(int m){...}
（18）下列代码段编译和运行的结果是（C）。
public static void main(String args[]){
String str = “null”;
if(str==null){
System.out.println(“null”);
}else if(str.length()==0){
System.out.println(“zero”);
} else {
System.out.println(“some”);
}
}
A．null B．zero C．some D．编译错误
（19）在创建对象时必须（C）。
A．不用声明对象，直接使用对象
B．先声明对象，然后才能使用对象
C．先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象
D．上述说法都对
（20）在Java中，关于构造方法，下列说法错误的是（C）。
A．构造方法的名称必须与类名相同
B．构造方法可以带参数
C．构造方法不可以重载
D．构造方法绝对不能有返回值
（21）下列方法定义中，正确的是（A）。
A．int x( ){ char ch= a ; return (int)ch;} B．void x( ){ .return true; }
C．int x( ){ .return true; } D．int x( int a, b){ return a+b; }
（22）下列最终属性i的定义中，正确的是（B）。
A．static final int i=100; B．final int i=1.2;
C．final i= w ; D．final char i;
（23）在Java语言中，下列关于类的继承的描述，正确的是（B）。
A．一个类可以继承多个父类
B．一个类可以具有多个子类
C．子类可以使用父类的所有方法
D．子类一定比父类有更多的成员方法
（24）对象的特征在类中表示为变量，称为类的（B）。
A．对象 B．属性 C．方法 D．数据类型
（25）关于类加载以下说法正确的是（A）。
A．得到某个类的全名字符串，是可以加载这个类的
B．从*.java文件可以加载
C．无法在运行时动态加载一个类
D．以上说法都不对
（26）设i、j、k为类x中定义的int型变量名，下列类x的构造函数中不正确的是（B）。
A．x( int m){ } B．void x( int m){ }
C．x( int m, int n){ } D．x( int h,int m,int n){ }
（27）定义类头时能使用的修饰符是（C）。
A．private B．static C．abstract D．protected
（28）关于被私有访问控制符private修饰的成员变量，以下说法正确的是（C）。
A．可以被三种类所引用：该类自身与它在同一个包中的其他类、在其他包中的该类的子类
B．可以被两种类访问和引用：该类本身、该类的所有子类
C．只能被该类自身所访问和修改
D．只能被同一个包中的类访问
（29）下列关于构造方法的叙述中，错误的是（C） 。
A．Java语言规定构造方法名与类名必须相同
B．Java语言规定构造方法没有返回值，但不用void声明
C．Java语言规定构造方法不可以重载Java
D．语言规定构造方法只能通过new自动调用
（30）以下关于继承的叙述正确的是（A）。
A．在Java中类只允许单一继承
B．在Java中一个类只能实现一个接口
C．在Java中一个类不能同时继承一个类和实现一个接口
D．在Java中接口只允许单一继承
（31）Java语言的类间的继承关系是（B）。
A．多重的 B．单重的 C．线程的 D．不能继承的
（32）有关Java中的类和对象，以下说法错误的是（B）。
A．同一个类的所有对象都拥有相同的特征和行为
B．类和对象一样，只是说法不同
C．对象是具有属性和行为的实体
D．类规定了对象拥有的特征和行为
（33）以下哪个过程不一定会执行（D）。
public class ObjectTest {
public static void main(String[] args) {
//对象的声明
String string;
//对象的实例化
string = String.class.toString();
//对象的使用
System.out.println(string);
//对象的销毁
string = null;
}
}
A．对象的声明 B．对象的实例化
C．对象的使用 D．对象的销毁
（34）下列哪一种说法是正确的（D）。
A．实例方法可直接调用超类的实例方法
B．实例方法可直接调用超类的类方法
C．实例方法可直接调用其余类的实例方法
D．实例方法可直接调用本类的类方法
（35）下列关于构造方法constructor说法正确的有（C）。
A．class中的constructor不可省略
B．constructor必须与class同名，但方法不能与class同名
C．constructor在一个对象被new时执行
D．一个class只能定义一个constructor
（36）下列选项中关于Java中super关键字的说法正确的是（A）。
A．super关键字是在子类对象内部指代其父类对象的引用
B．super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C．子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D．子类通过super关键字只能调用父类的属性，而不能调用父类的方法
（37）下列说法哪个是正确的（B）。
A．创建对象y一定要用new
B．属性可以是简单变量，也可以是一个对象
C．属性必须是简单变量
D．对象中必有属性和方法
多选题
（1）在Java中，下面对于构造函数的描述错误的是（BC）。
A．类不一定要显式定义构造函数
B．构造函数的返回类型是void
C．如果构造函数不带任何参数，那么构造函数的名称和类名可以不同
D．一个类可以定义多个构造函数
（2）关于类的描述正确的是（BC）。
A．在类中定义的变量称为类的成员变量，在别的类中可以直接使用
B．局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中
C．可以使用stringBuffer sb="这里是字符串"声明并初始化StringBuffer对象sb
D．String类提供了许多用来操作字符串的方法：连接，提取，查询等
（3）面向对象的特征（ABCD）。
A．继承 B．抽象 C．多态 D．封装
（4）Java中的final关键字有哪些用法（ABC）。
A．修饰类：表示该类不能被继承
B．修饰方法：表示该方法不能被重写
C．修饰变量：表示变量只能一次赋值以后不能被修改（常量）
D．修饰捕获异常，用于无论是否出现异常，都会执行代码
（5）以下说法正确的是（AB）。
A．this指针可以调用本类的属性
B．调用一个类中的属性可以使用get和set方法
C．Java中继承一个类要使用extend关键字
D．Java中一个方法默认的修饰符是private
判断题
（1）即使一个类中未显式定义构造函数，也会有一个缺省的构造函数，缺省的构造函数是无参函数，函数体为空。（T）
（2）由继承性可知，程序中子类拥有的成员数目一定大于等于父类拥有的成员数目。（F）
（3）子类所继承父类的成员都可以在子类中访问。（F）
（4）成员方法的重载和覆盖是同一回事。（F）
（5）在Java语言中，声明包语句的关键字为package，引入包语句的关键字为import。（T）
（6）可以使用obj1==obj2来判断两个对象是否相等。（F）
（7）类中要调用父类中的变量或者方法时应该使用super关键字。（T）
（8）可以在子类构造方法中通过this关键字调用基类的构造方法。（T）
（9）Java语言支持类的继承，但不支持类的多重继承。（T）
（10）定义自己的类加载器，需从ClassLoader类派生。（T）
（11）Field的实例描述一个字段，它只与类关联，与类是实例并无关系。（T）
（12）用static声明的成员变量在整个应用程序执行期间都有效。（T）
（13）一个类中的属性不设置get和set方法，其它对象就无法使用这个属性。（F）
（14）创建一个对象的关键字是class。（F）
填空题
（1）创建一个名为mypackage的包的语句是 package mypackage; ，该语句应该放在程序的位置为： 应该在程序第一句 。
（2）下面程序段被执行后，s1的值是 12 ，s2的值是 1234 ，s3的值是 1234 。
s1="12";
String s2=s1.concat("34");
String s3=s1+"34";
（3）下面程序运行后s1的值为 abc ，s2的值为 def 。
String s1="abc";
String s2="def";
s2.toUpperCase();
s1.concat(s2);
（4）子类对父类继承来的属性重新定义称为 重写 ，子类对自身拥有的同名方法的重新定义称 重载 。
（5）在Java语言中， 包 是组织Java程序中类的一种手段，其作用与Windows系统中的文件夹 类似。创建包的语句必须是文件的第 一 条语句。
（6）Java类中，如果类的定义者没有显式的定义任何构造方法，系统将自动提供一个 无参默认 构造方法。默认的构造方法没有 参数 ，也没有返回值，类A的构造方法为：publicA(){}
（7）用 static 修饰的变量叫静态变量，它可以通过类的 类名 和 对象 两种方式来访问。
（8）若子类对父类中的同名同参方法进行重新定义，我们称子类 重写 了父类的同名方法。
（9）Java中用类创建一个对象包括对象的声明和为对象 实例化 两个步骤。
（10）如果在子类中想使用被子类隐藏的父类的成员变量或方法可以使用关键字 super 。
（11）导入my.package包中的所类的命令是 import 。
（12）构造方法是一种特殊的成员方法，构造方法名与 类名 相同，并且此方法 无 （有/无）返回值。
（13）JAVA语言中提供了两种类型的字符串类来处理字符串，它们是 String 、StringBuffer 和 StringBuilder 。
（14）Java中所有类都是 Object 类的子类。
（15）在Java源文件中class、import和package语句的顺序是 package、import、class 。
（16）当类中的成员定义采用static关键字修饰时，则称该成员为类的（静态/实例） 静态 成员。
（17）面向对象编程的三个基本特性是 封装 、 继承 和 多态 。
（18）在Java中，声明静态方法、静态属性用的关键字是 static 。
（19）同一个类中多个方法具有相同的方法名，不同的 参数 称为方法重载。
（20）"I like Java、Math、and English very much、 so does Tom."对于字符串以顿号作为分隔符，则该字符串有 2 个单词。
（21） new 关键字的作用是根据对象的类型分配内存空间。当对象拥有内存空间时，会自动调用类中的 构造方法 为对象 实例化 。
（22）类由 属性 和 方法 组成。
（23）Java中参数的两种传递方式有 值 传递和 引用 传递
（24）引用父类对象需要使用什么关键字 super
（25）创建一个的类关键字是 class
（26）面向对象三大基本特征： 封装 、 继承 、 多态
（27）使用 private 关键字修饰的类成员称为私有成员。私有成员只能在 本类 中使用
简答题
（1）String和StringBuilder、StringBuffer的区别？
Java平台提供了两种类型的字符串：String和StringBuffer/StringBuilder，它们可以储存和操作字符串。
1）String是只读字符串，也就意味着String引用的字符串内容是不能被改变的。
2）StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改。
3）StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，区别在于它是单线程，而StringBuffer是多线程的。
（2）是否可以继承String类？
不能；String类被final修饰，因此不能被继承。
（3）重载和重写的区别。
方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。
重载(Overloading)：重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型作为重载函数的区分标准。
重写(Overriding)：重写的时候，父类中需要被重写的方法要求与子类中的定义某一方法有相同的方法名、参数类型和个数和返回类型，且子类函数的访问修饰权限不能少于父类。
（4）构造器（constructor）是否可被重写（override）?
构造器不能被继承，因此不能被重写，但可以被重载。
（5）数组有没有length()方法？String有没有length()方法？
数组没有length()方法，有length 的属性。String有length()方法。JavaScript中，获得字符串的长度是通过length属性得到的，这一点0.75和Java混淆。
（6）重载（Overload）和重写（Override）的区别？
方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。
（7）描述引用、对象、类，三者之间的关系。
类是一个模板，它描述一类对象的行为和状态；对象是类的一个实例，具有状态和行为；引用是存放某一对象起始地址的地址。
（8）Java中的final关键字有哪些用法？
1）修饰类：表示该类不能被继承
2）修饰方法：表示方法不能被重写
3）修饰变量：表示变量只能一次赋值以后值不能被修改（常量）
（9）值传递和引用传递的区别?
1）一个是针对基本数据类型，一个针对引用数据类型
2）值传递传递的是值，引用传递传递的是地址
3）值传递是拷贝了一份新的值给形式参数，在方法中进行操作不会影响原来的值；而引用传递的是地址，两个引用指向同一个地址，因此方法中改变了这个地址中的数据，那么原来的数据也会改变。
编程题
（1）定义并测试一个代表员工的Employee类。
描述：员工属性包括编号、姓名、基本薪水和薪水增长额，还包括计算增长后的工资总额。
class Employee {
private int empno ; //雇员编号
private String ename ; //雇员姓名
private double sal ; //基本工资
private double rate ; //工资增长额
public Employee() {
}
public Employee(int empno, String ename, double sal, double rate) {
super();
this.empno = empno;
this.ename = ename;
this.sal = sal;
this.rate = rate;
}
public String toString() {
return "雇员编号：" + this.empno + "，雇员姓名：" + this.ename + "，基本工资：" + this.sal ;
}
public void growthin() { //增长薪水
this.sal = this.sal * this.rate ;
}
}
public class TestDemo {
public static void main(String args[]) {
Employee emp = new Employee(7369, "SMITH", 1000, 1.5);
emp.growthin() ; //工资增长
System.out.println(emp);
}
}
（2）编写并测试一个代表地址的Address类。
描述：地址信息由国家、省份、城市、街道和邮编组成，并可以返回完整的地址信息。
class Address {
private String national;
private String provincial;
private String city;
private String street;
private String zipcode;
public Address() {
}
public Address(String national, String provincial, String city,
String street, String zipcode) {
super();
this.national = national;
this.provincial = provincial;
this.city = city;
this.street = street;
this.zipcode = zipcode;
}
public String toString() {
return "国家：" + this.national + "，省份：" + this.provincial + "，城市："
+ this.city + "，街道：" + this.street + "，邮政编码：" + this.zipcode;
}
}
public class TestDemo {
public static void main(String args[]) {
Address ad = new Address("中国", "北京", "北京市", "MLDN", "100088");
System.out.println(ad);
}
}
（3）建立一个人类（Person）和学生类（Student），其功能要求：
描述：建立一个人类（Person）和学生类（Student），其功能要求：
1）Person中包含4个保护型的数据成员name、address、sex、age，分别为字符串、字符串、字符及整型，表示姓名、地址、性别和年龄。一个4参构造方法、一个无参构造方法及一个输出方法用于显示4种属性。
2）Student继承Person，并增加输出成员math、english存放数学和英语成绩。一个6参构造方法、一个两参构造方法，一个无参构造方法，重写输出方法用于显示全部6种属性。
class Person {
private String name ;
private String address ;
private char sex ;
private int age ;
public Person() {
}
public Person(String name, String address, char sex, int age) {
super();
this.name = name;
this.address = address;
this.sex = sex;
this.age = age;
}
public String toString() {
return "姓名：" + this.name + "，地址：" + this.address + "，性别：" + this.sex
+ "，年龄：" + this.age;
}
}
class Student extends Person {
private double math ;
private double english ;
public Student() {
}
public Student(String name, String address, char sex, int age, double math,
double english) {
super(name, address, sex, age);
this.math = math;
this.english = english;
}
public String toString() {
return super.toString() + "，数学成绩：" + this.math + "，英语成绩：" + this.english;
}
}
public class TestDemo {
public static void main(String args[]) {
Student stu = new Student("张三", "北京西城区甲11号德外大街德胜科技园美江大厦 A座 - 6层", '男', 25, 90.0, 99.0);
System.out.println(stu);
}
}
（4）设计一个Dog类。
描述：有名字、颜色、年龄等属性，定义构造方法来初始化类的这些属性，定义方法输出Dog信息。编写应用程序使用Dog类。
class Dog {
private String name ;
private String color ;
private int age ;
public Dog() {
}
public Dog(String name, String color, int age) {
super();
this.name = name;
this.color = color;
this.age = age;
}
public String toString() {
return "狗的名字：" + this.name + "，狗的颜色：" + this.color + "，狗的年龄：" + this.age ;
}
}
public class TestDemo {
public static void main(String args[]) {
Dog dog = new Dog("金毛", "金黄色", 3);
System.out.println(dog);
}
}
（5）编写程序从字符串“want you to know one thing”中统计出字母“n”的出现次数。
描述：输出格式为：字母n的出现次数：“n的次数”
public class TestDemo {
public static void main(String args[]) {
String str = "want you to know one thing" ; //定义字符串
int sum = 0 ;
while (str.indexOf("n") != -1) { //是否还有字母n
sum ++ ; //数据统计量增加
str = str.substring(str.indexOf("n") + 1); //改变字符串内容
}
System.out.println("字母n的出现次数：" + sum);
}
}
（6）下面是一个java源文件，改正其中的错误，使其能够编译和运行。
package com.briup.md01;
public class Test1 {
public static void main(String[] args) {
System.out.println("What's wrong with this program?");
}
}
public class TestAnother1 {
public static void main(String[] args) {
System.out.println("What's wrong with this program?");
}
}
改：
package com.briup.md01;
public class Test1 {
public static void main(String[] args) {
System.out.println("What's wrong with this program?");
}
}
//一个.java文件中不能出现两个public修饰的类
class TestAnother1 {
public static void main(String[] args) {
System.out.println("What's wrong with this program?");
}
}
（7）下面是一个Java源文件，改正其中的错误。
package com.briup.md01;
public class Test3 {
public static void main(String args) {
System.out.println("What's wrong with this program?");
}
}
改：
package com.briup.md01;
public class Test3 {
//main方法声明不正确 参数类型不匹配
public static void main(String[] args) {
System.out.println("What's wrong with this program?");
}
}
（8）改下面是一个Java源文件，改正其中的错误。
package com.briup.md01;
public class Testing2 {
public static main(String[] args) {
System.out.println("What's wrong with this program?");
}
}
改：
package com.briup.md01;
public class Testing2 {
//main方法声明不正确，缺失返回值
public static void main(String[] args) {
System.out.println("What's wrong with this program?");
}
}
第四单元习题
单选题
（1）对下列代码，描述正确的是（A）。
public class Test{
int arr[] = new int[10];
public static void main(){
System.out.println(arr[1]);
}
}
A．编译时出错 B．编译时正确而运行时出错
C．输出0 D．输出null
判断题
（1）Java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。（T）
第五单元习题
单选题
（1）关于接口，说法不正确的是（B）。
A．接口不能被实例化，因为它的方法只有定义，没有实现
B．接口中的方法不全是public
C．继承接口接做实现（implements)
D．接口专用于模块之间的解耦
（2）内部匿名类的说法正确的是（A）。
A．是将类的派生与实例创建结合在一起的一种语法
B．匿名类只能从接口派生
C．匿名类中只能实现一个方法
D．匿名类不可以被替换为Lambda
（3）下列哪一个关键字用于实现接口（B）。
A．extends B．implements C．abstract D．interface
（4）在java中，使用（B）关键字来定义一个接口。
A．class B．interface C．extends D．implements
（5）下列关于抽象类的说法四个是正确的？（C）。
A．某个抽象类的父类是抽象类，则达个子类必须里载父类的所有抽象方法
B．接口和抽象类是同一回事
C．绝对不能用抽象类去创建对象
D．抽象类中不可以有非抽象方法
（6）以下代码，描述正确的有（A）。
interface IDemo{
public static final String name; 1
void print(); 2
public void getInfo(); 3
}
abstract class Person implements IDemo{ 4
public void print(){}
}
A．第1行错误，没有给变量赋值
B．第2行错误，方法没有修饰符
C．第4行错误，没有实现接口的全部方法
D．第3行错误，没有方法的实现
（7）关于Class类，说法错误的是（D）。
A．Class是实例中保存了一个类的元数据
B．通过Class实例，可以调用某个类的方法
C．通过Class实例，可以设置某个类的字段的值
D．Class对象与其所描述的类的实例是关连的
多选题
（1）在Java接口中，下列选项中有效的方法声明是（AB）。
A．public void aMethod() B．void aMethod()
C．protected void aMethod() D．private void aMethod()
（2）abstract的作用（ABCD）。
A．可以修饰类和方法
B．不能修饰属性和构造方法
C．abstract修饰的类是抽象类，需要被继承
D．abstract修饰的方法是抽象方法，需要子类被重写
（3）下列关于Object类说法正确的是（ABCD）。
A．Object类是所有Java类的祖先
B．Object类有一个默认构造方法public Object()，在构造子类实例时，都会先调用这个默认构造方法
C．可以使用型为Object的变量指向任何类型的对象
D．Object类的变量只能用作各种值的通用持有者
（4）反射获取类的方式有（ABC）。
A．通过getClass方法获取，通过对象获取
B．通过类名获取
C．通过完整的包名+类名
D．通过关键词new
判断题
（1）匿名内部类没有类名，因此没有构造方法。（T）
（2）静态内部类的创建不需要依赖外部类可以直接创建。（T）
（3）所谓内部类就是在一个类内部进行其他类结构的嵌套操作。（T）
（4）Java类之间并不允许多继承，接口只可以单继承。（F）
（5）一个类只能继承一个父类，但能实现多个接口。（T）
（6）接口与类的区别是，接口中只能定义方法不能实现方法。（T）
填空题
（1）接口的关键字是 interface
（2）基本数据的包装类分别是什么？例：byte -- Byte
short -- Short
int -- Integer
long -- Long
float – Float
double -- Double
char -- Character
boolean -- Boolean
（3）阅读程序回答以下问题：
1）程序输出的第一行是什么 这个人是:学生
2）三次输出的hashCode是否相同（是或否） 是
3）程序输出的第五行是什么 int
4）程序会输出多少行（只写数字） 6
public class Test03 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println("这个人是:" + person.name);
//方式一:通过对象获得
Class c1 = person.getClass();
System.out.println(c1.hashCode());
//方式二:forName获得
Class c2 = Class.forName("cn.reflectionTest.reflection.Student");
System.out.println(c2.hashCode());
//方式三:通过类名.class获得
Class c3 = Student.class;
System.out.println(c3.hashCode());
//方式四:基本内置类型的包装类都有一个Type属性
Class c4 = Integer.TYPE;
System.out.println(c4);
//获得父类类型
Class c5 = c1.getSuperclass();
System.out.println(c5);
}
}
class Person {
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
class Student extends Person {
public Student() {
this.name = "学生";
}
}
class Teacher extends Person {
public Teacher() {
this.name = "老师";
}
}
简答题
（1）抽象类（abstract class）和接口（interface）有什么异同？
抽象类是用来捕捉子类的通用特性的。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。
接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。
相同点：
1.他们都不能生成实例，都有抽象方法。
2.接口是特殊的抽象类。
3.接口和抽象类的继承都使用的关键字是extends。
不同点：
1.接口的定义的变量默认是public static final型，且必须给其赋初值。所以在实现类中不能重新定义，也不能改变其值。而在抽象类中其值在子类中可以重新定义也可以重新赋值。
2.接口的方法默认的都是public abstract类型的。
3.抽象类中可以有构造器，但是接口中除了抽象方法什么都没有。
4.名字不同，接口写的是public interface Shape{}； 而抽象类写的是public abstract class Shape{}。
5.还可以从继承的角度看，接口可以多继承，一个接口可以继承多个接口。但是抽象类却不能，只能是继承一个父类，不能继承多个父类。
6.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。
7.接口里全部都是抽象方法。而抽象类里可以有抽象方法也可以有其他的方法。
（2）int和Integer有什么区别？
1）Integer是int的包装类，int则是java的一种基本数据类型。
2）Integer变量必须实例化后才能使用，而int变量不需要。
3）Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值。
4）Integer的默认值是null，int的默认值是0。
（3）接口和抽象类有什么区别？
实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。
构造函数：抽象类可以有构造函数；接口不能有。
main方法：抽象类可以有 main 方法，并且我们能运行它；接口不能有 main 方法。
实现数量：类可以实现很多个接口；但是只能继承一个抽象类。
访问修饰符：接口中的方法默认使用public修饰；抽象类中的方法可以是任意访问修饰符。
编程题
（1）编写一个类实现简单的单例模式。
public class Singleton {
private static final Singleton singleton = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return singleton;
}
}
（2）定义一个ClassName接口。
描述：接口中只有一个抽象方法getClassName()。设计一个类Company，该类实现接口ClassName中的方法getClassName()，功能是获取该类的类名称。编写应用程序使用Company类。
interface ClassName {
public String getClassName() ;
}
class Company implements ClassName {
public String getClassName() {
return "Company";
}
}
public class TestDemo {
public static void main(String args[]) {
ClassName name = new Company() ;
System.out.println(name.getClassName());
}
}
（3）接口实现计算器。
描述：利用接口做参数，写个计算器，能完成加减乘除运算。
1）定义一个接口Compute含有一个方法int computer(int n, int m)。
2）设计四个类分别实现此接口，完成加减乘除运算。
3）设计一个类UseCompute，类中含有方法：public void useCom(Compute com, int one, int two)，此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。
4）设计一个主类InterFaceTest，调用UseCompute中的方法useCom来完成加减乘除运算。
/**
* 接口
*/
interface ICompute {
int computer(int number1, int number2);
}
/**
* 加法实现类
*/
class Add implements ICompute {
@Override
public int computer(int number1, int number2) {
return number1 + number2;
}
}
/**
* 减法实现类
*/
class Minus implements ICompute {
@Override
public int computer(int number1, int number2) {
return number1 - number2;
}
}
/**
* 乘法实现类
*/
class Multiply implements ICompute {
@Override
public int computer(int number1, int number2) {
return number1 * number2;
}
}
/**
* 除法实现类
*/
class Divide implements ICompute {
@Override
public int computer(int number1, int number2) {
return number1 / number2;
}
}
/**
* 调用类
*/
class UseComputer {
public void useCom(ICompute com, int one, int two) {
System.out.println(com.computer(one, two));
}
}
/**
* 测试类
*/
public class InterFaceTest {
public static void main(String[] number1rgs) {
UseComputer user = new UseComputer();
Add s1 = new Add();
System.out.print("和为：");
user.useCom(s1, 1024, 512);
Minus s2 = new Minus();
System.out.print("差为：");
user.useCom(s2, 1024, 512);
Multiply s3 = new Multiply();
System.out.print("乘积为：");
user.useCom(s3, 1024, 512);
Divide s4 = new Divide();
System.out.print("商为：");
user.useCom(s4, 1024, 512);
}
}
（4）利用接口做参数，写个计算器，完成加减乘除运算的功能。
要求：
1）定义一个接口Compute含有一个方法int computer(int n, int m)。
2）设计四个类分别实现此接口，完成加减乘除运算。
3）设计一个类UseCompute，类中含有方法：public void useCom(Compute com, int one, int two)，此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。
4）设计一个主类Test，调用UseCompute中的方法useCom来完成加减乘除运算。
interface Compute {
int computer(int n, int m);
}
class Jia implements Compute {
@Override
public int computer(int n, int m) {
return n + m;
}
}
class Jian implements Compute {
@Override
public int computer(int n, int m) {
return n - m;
}
}
class Chen implements Compute {
@Override
public int computer(int n, int m) {
return n * m;
}
}
class Chu implements Compute {
@Override
public int computer(int n, int m) {
return n / m;
}
}
public class Calculator {
public void userCom(Compute com, int one, int two) {
System.out.println(com.computer(one, two));
}
public static void main(String[] args) {
Compute jia = new Jia();
Compute jian = new Jian();
Compute chen = new Chen();
Compute chu = new Chu();
Calculator c = new Calculator();
c.userCom(jia, 3, 1);
c.userCom(jian, 3, 1);
c.userCom(chen, 3, 1);
c.userCom(chu, 3, 1);
}
}
第六单元习题
单选题
（1）给定如下所示的JAVA代码，则运行String s = null; s.concat("abc");时会产生（B）。
A．ArithmeticException B．NullPointerException
C．IOException D．ClassNotFoundException
（2）下列哪种异常是检查型异常，需要在编写程序时声明（C）。
A．NullPointerException B．ClassCastException
C．FileNotFoundException D．IndexOutOfBoundsException
（3）对于已经被定义过可能抛出异常的语句，在编程时（A）。
A．必须使用try／catch语句处理异常，或用throws将其抛出
B．如果程序错误，必须使用try／catch语句处理异常
C．可以置之不理
D．只能使用try／catch语句处理
（4）下面代码运行结果是（B）。
public class Demo{
public int add(int a,int b){
try{
return a+b;
}catch(Exception e){
System.out.println(“catch 语句块”);
}finally{
System.out.println(“finally 语句块”);
}
return 0;
}
public static void main(String[] args){
Demo demo = new Demo();
System.out.println(“和是：”+demo.add(9,34));
}
}
A．编译异常 B．finally语句块 和是：43
C．和是：43 finally语句块 D．catch语句块 和是：43
（5）以下程序运行结果是（D）。
public class Test {
public int div(int a, int b) {
try{
return a / b;
}catch(Exception e){
System.out.println(“Exception”);
}catch(NullPointerException e){
System.out.println(“ArithmeticException”);
}catch(ArithmeticException e) {
System.out.println(“ArithmeticException”);
}finally {
System.out.println(“finally”);
}
return 0;
}
public static void main(String[] args) {
Test demo = new Test();
System.out.println(“商是：” + demo.div(9, 0));
}
}
A．Exception finally商是：0 B．ArithmeticException finally商是：0
C．finally商是：0 D．编译报错
多选题
（1）以下说法正确的是（ACD）。
A．Throwable是Error的父类 B．Throwable是Exception的子类
C．Throwable是Object的子类 D．Throwable实现了Serialiable接口
填空题
（1）所有的异常都是从 Throwable 继承而来的，是所有异常的共同祖先。
简答题
（1）写出5种常见的运行时异常。
空指针，数组越界，算术异常，类转换，数组存储异常。
（2）运行时异常和编译时异常的区别。
编译时异常继承自Exception，编译期间会主动检查这种异常，发现报错后要求我们处理。
运行时异常继承自RuntimeException编译期间，不会检查这种异常，也不要处理，但是运行期间，可能抛出这种类型的异常。
（3）Error和Exception区别。
error表示错误情况，0.5是程序出现了比较严重的问题，并且程序自身无法进行处理。
exception表示异常情况，大多数是可以通过特定的方式进行处理，并且处理完后，程序还可以继续往下正常运行。
（4）Java程序中通常有哪几种方式处理异常，各有什么特点。
在Java应用程序中，异常处理机制为：抛出异常，捕捉异常。
抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
捕捉异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。
编程题
（1）编写应用程序，从命令行输入两个小数参数，求它们的商。
描述：要求程序中捕获NumberFormatException异常和ArithmeticException异常。
class MyMath {
public int div(String x, String y) throws NumberFormatException,
ArithmeticException {
//出现异常要交给被调用处出理
int result = 0;
try {
int numa = Integer.parseInt(x) ;
int numb = Integer.parseInt(y) ;
result = numa / numb; //除法计算
} catch (Exception e) {
throw e; }
return result;
}
}
public class TestDemo {
public static void main(String args[]) {
if (args.length != 2) {
System.out.println("程序运行出错！");
System.exit(1) ; //程序退出
}
try {
MyMath mm = new MyMath() ;
System.out.println(mm.div(args[0], args[1])); //被调用处处理异常
} catch (Exception e) {
e.printStackTrace();
}
}
}
第七单元习题
单选题
（1）在java中，（C）对象可以使用键/值的形式保存数据。
A．ArrayList B．HashSet C．HashMap D．LinkedList
（2）下列哪项说法正确（C）。
A．String是原始基本数据类型 B．HashMap不允许存放空值、空键
C．List接口允许重复 D．Set接口允许重复
（3）欲构造ArrayList类得一个实例，此类继承了List接口，下列哪个方法是正确的（B）。
A．ArrayList myList = new Object() B．List myList = new ArrayList()
C．ArraylList myList = new List() D．List myList = new List()
（4）下列关于Iterator接口说法错误的是（C）。
A．Iterator接口是Collection接口的父接口
B．从JDK5开始所有实现了Iterable的集合类都是可迭代的，都支持foreach循环遍历
C．可以通过hasNext()方法获取下一个元素
D．remove()方法移除迭代器返回的最后一个元素
（5）关于集合框架特征，说法不正确的是（A）。
A．Map集合中的键对象不允许重复、有序
B．List集合中的元素允许重复、有序
C．Set集合中的元素不允许重复、无序
D．Collection集合中的元素允许重复、无序
（6）在Java中LinkedList类和ArrayList类同属于集合框架类，下列（D）选项中的方法是这两个类都有的。
A．addFirst(Object o) B．getFirst() C．removeFirst() D．add(Object o)
（7）下面集合类能够实现“FIFO”特点的是（A）。
A．LinkedList B．Stack C．TreeSet D．TreeSet
（8）创建一个ArrayList集合实例，该集合中只能存放String类型数据，下列（B）代码是正确的。
A．ArrayList myList=new ArrayList () B．ArrayList myList=new ArrayList<> ()
C．ArrayList<> myList=new ArrayList () D．ArrayList<> myList=new List<> ()
（9）在java中，下列集合类型可以存储无序、不重复的数据的是（D）。
A．Arraylist B．Linkedlist C．Treeset D．Hashset
（10）Java中的集合类包括ArrayList、LinkedList、HashMap等类，下列关于集合类描述错误的是（C）。
A．ArrayList和LinkedList均实现了List接口
B．ArrayList访问速度比LinkedList快
C．添加和删除元素时，ArrayList的变现更佳
D．HashMap实现Map接口，它允许任何类型的键和值对象并允许将null用作键或值
（11）要正确输出集合strs中的各元素，如下Java代码横线处应填写（A）。
A．itor.hasNext()、itor.next() B．itor.next()、itor.hasNext()
C．itor.hasNext()、itor D．itor.next()、itor
（12）关于泛型集合，下列说法错误的是（D）。
A．可以这样建立泛型集合对象List<String> ls = new LinkedList<String>()
B．HashMap、ArrayList、LinkedList、Iterator都是泛型集合
C．泛型是为了能够进行类型检查的一种技术，应用在集合上也是这个原因
D．编写程序时，如果涉及到集合，尽可能不要使用泛型集合
（13）下面的集合中，（A）不可以存储重复元素。
A．Set B．Collection C．Map D．List
（14）ArrayList类的底层数据结构是(A)。
A．数组结构 B．链表结构 C．哈希表结构 D．红黑树结构
填空题
（1）Java中的泛型基本上都是在 编译器 这个层次来实现的。
（2）List接口的特点是元素 有 （有|无）顺序， 可以 （可以|不可以）重复。Set接口的特点是元素 无 （有|无）顺序， 不可以 （可以|不可以）重复。Map接口的特点是元素是<key, value>，其中 value 可以重复， key 不可以重复。
（3） Map 接口由键值对组成。
（4） ArrayList 对象是长度可变的对象引用数组,类似于动态数组。
简答题
（1）集合中是否可以存放基本类型？为什么？
不可以、集合存储对象。Java集合中实际存放的只是对象的引用，每个集合元素都是一个引用变量，实际内容都放在堆内存或者方法区里面，但是基本数据类型是在栈内存上分配空间的，栈上的数据随时就会被收回的。
（2）HashMap和HahsTable的区别。
HashMap的键和值可以为空，HashTable的键和值都不能为空。
（3）map可以使用迭代器遍历吗？为什么？
不可以。Map没有继承Iterable接口，而迭代器方法是Iterable接口的抽象方法。
（4）List接口和Set接口的特点。
共同特点：都继承Collection。
List：元素是有序的，元素可以重复。因为该集合体系有索引。
ArrayList：底层的数据结构使用的是顺序结构。特点：查询速度很快。但是增删稍慢。线程不同步。
LinkedList：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
Vector：底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
Stack：它用于模拟了“栈”这种数据结构，“栈”通常是指“后进先出”的容器。
Set：元素是无序，元素不可以重复。
HashSet：实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set的迭代顺序；特别是它不保证该顺序恒久不变，此类允许使用null元素。
TreeSet：使用元素的自然顺序对元素进行排序LinkedHashSet：使用链表维护了一个添加进集合中的顺序。导致当我们遍历LinkedHashSet集合元素时，是按照添加进去的顺序遍历的！
（5）LinkedList Vector ArrayList的区别。
1）从存储数据结构分析ArrayList：数组、Vector：数组、LinkedList：双向链表。数组：可以根据下标快速查找，所以大部分情况下，查询快。但是如果要进行增删操作的时候，会需要移动修改元素后面的所有元素，所以增删的开销比较大，数组的对增删操作的执行效率低。而采用数组作为数据存储结构的ArrayList、Vector也存在这些特性，查询速度快（可以根据下标直接取，比迭代查找更快），增删慢。链表：增加和删除元素方便，增加或删除一个元素，仅需处理结点间的引用即可。就像人手拉手连成一排，要增加或删除某个人只要附近的两个人换一个人牵手，对已经牵好手的人没影响。无论在哪里换人耗费的资源和 时间都是一样的。但是查询不方便，需要一个个对比，无法根据下标直接查找。而采用链表结构存储的LinkedList也有这些特性，增删方便，查询慢(指的是随机查询，不是顺序查询)。
2）从并发安全上分析线程class{ private int age; main(){ } }，Vector：线程安全synchronized 效率低了Colllections ArrayList：非线程安全效率高、LinkedList：非线程安全。
3）数据增长分析Vector：缺省的情况下，增长为原数组长度的一倍。说到缺省，说明他其实是可以自主设置初始化大小的。ArrayList：自动增长原数组的50%。老容量+老容量>>1
编程题
（1）定义一个方法可以遍历输出Collection集合，并且消除泛型警告，遍历集合中存放的类型为Number类型及子类型。
public class GenericsTest {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
list.add(i);
}
print(list);
Set<Float> set = new HashSet<>();
for (int i = 0; i < 10; i++) {
set.add((float)i);
}
print(set);
}
private static void print(Collection<? extends Number> collection) {
Iterator<? extends Number> iterator = collection.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
（2）创建两个Set集合，判断这两个集合是否有交集，并打印出他们的交集retainAll和removeAll的使用。
Set set = new HashSet(Arrays.asList(1, 2, 3, 4));
Set set1 = new HashSet(Arrays.asList(1, 4));
// 保留参数集合有的
set.retainAll(set1);// 1 4
System.out.println(set);
// 移除参数集合有的
set.removeAll(set1); // 2 3
System.out.println(set);
（3）生成10个1到20之间的不重复的随机数set的使用和循环随机数。
public class Demo {
public static void main(String[] args) {
Set set = new HashSet();
Random r = new Random();
while (set.size() < 10) {
// 随机数*（最大值-最小值） + 最小值
double random = Math.random() * (20 - 1) + 1;
set.add(random);
}
for (Object object : set) {
System.out.println(object);
}
System.out.println("容量大小");
System.out.println(set.size());
}
}
2219
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
