JavaEE基础教程课后习题答案
下载本文
第一章 Java语言概述与编程环境
1．Java语言特点是什么？
Java语言具有如下特性：简单性、面向对象、分布式、解释型、可靠、安全、平台无关、可移植、高性能、多线程、动态性等。
2．什么叫Java虚拟机？什么叫Java平台？Java虚拟机与Java平台的关系如何？
Java虚拟机（Java Virtual Machine) 简称JVM 。Java虚拟机是一个想象中的机器,在实际的计算机上通过软件模拟来实现。Java虚拟机有自己想象中的硬件,如处理器、堆栈、寄存器等,还具有相应的指令系统。
3．Java程序是由什么组成的？一个程序中必须有public类吗？Java源文件的命名规则是怎样的？
一个Java源程序是由若干个类组成。一个Java程序不一定需要有public类：如果源文件中有多个类时，则只能有一个类是public类；如果源文件中只有一个类，则不将该类写成public也将默认它为主类。源文件命名时要求源文件主名应与主类（即用public修饰的类）的类名相同，扩展名为.java。如果没有定义public类，则可以任何一个类名为主文件名，当然这是不主张的，因为它将无法进行被继承使用。另外，对Applet小应用程序来说，其主类必须为public，否则虽然在一些编译编译平台下可以通过（在BlueJ下无法通过）但运行时无法显示结果。
4．开发与运行Java程序需要经过哪些主要步骤和过程？ (1) 下载、安装J2SDK；
(2) 设置运行环境参数：JAVA_HOME、PATH、CLASSPATH; (3) 使用文本编辑器编写原代码如HelloWorld.java；
(4) 运行命令“javac HelloWorld.java” 编译HelloWorld.java为HelloWorld.class; (5) 运行“java HelloWorld”生成HelloWorld.exe。
5．怎样区分应用程序和小应用程序？应用程序的主类和小应用程序的主类必须用public修饰吗？
Java Application是完整的程序，需要独立的解释器来解释运行；而Java Applet则是嵌在HTML编写的Web页面中的非独立运行程序，由Web浏览器内部包含的Java解释器来解释运行。 两者的主要区别是：任何一个Java Application应用程序必须有且只有一个main方法，它是整个程序的入口方法；任何一个Applet小应用程序要求程序中有且必须有一个类是系统类Applet的子类，即该类头部分以extends Applet结尾。
应用程序的主类当源文件中只有一个类时不必用public修饰，但当有多于一个类时则主类必须用public修饰。小应用程序的主类在任何时候都需要用public来修饰。
6．安装JDK之后如何设置JDK系统的PATH，CLASSPATH？他们的作用是什么？
（1）PATH环境变量。设置环境变量path是因为window xp是多用户操作系统，支持不同用户的个性化系统定制，这里设置的信息只影响当前用户，而不会影响其他用户。假如只有一个用户，只是运行.class文件，则也不需要设置path环境，因为JDK安装之后会把java.exe等几个关键文件复制到c:\\windows\\system32目录中，而此目录已经存在于path变量，所以说用户变量path随不同用户而设置的，设置路径：“D:\\jdk1.5\\bin ”。 PATH环境变量作用
是指定命令搜索路径，在命令行下面执行命令如javac编译java程序时，它会到PATH变量所指定的路径中查找看是否能找到相应的命令程序。我们需要把jdk安装目录下的bin目录增加到现有的PATH变量中，bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好PATH变量后，就可以在任何目录下执行javac/java等工具了。
（2）CLASSPATH环境变量。作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPTH来寻找类的。我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。设置classpath环境变量是为了运行一些特殊的java程序，如以.jar为后缀的文件或者是javac运行java程序，假如不运行这类程序，也就不必要设置classpath环境变量了，设置方法是：（安装jdk是的目录为：d:\\jdk1.5) 那么就在“变量值”文本框中键入：“.;D:\\jdk1.\\lib\\dt.jar;D:\\jdk1.5\\lib\\tools.jar ”；
第二章 Java编程基础
1．试分析基本数据类型和引用数据类型的基本特点。
Java的基本数据类型都有固定的数据位，不随运行平台的变化而变化。
基本数据类型包括byte、int、char、long、float、double、boolean和short。 引用类型都是用类或对象实现的，引用数据类型包括:类,数组,接口。 基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的。不论是基本数据类型还是引用类型，他们都会先在栈中分配一块内存，对于基本类型来说，这块区域包含的是基本类型的内容；而对于对象类型来说，这块区域包含的是指向真正内容的指针，真正的内容被手动的分配在堆上 。
2．分析以下程序段，得到什么打印结果: 0 -1 1 2 System.out.println( 1 >>> 1); System.out.println( -1 >> 31); System.out.println( 2 >> 1); System.out.println( 1 << 1);
3．以下temp 变量的最终取值是: 1 long temp = (int)3.9; temp %= 2;
4．以下代码运行后得到的输出结果: Not equal! 10 int output=10; boolean b1 = false;
if((b1==true) && ((output+=10)==20)){
System.out.println(\} else{
System.out.println(\}
5．以下代码运行后的输出结果: We are equal 20 int output=10; boolean b1 = false;
if((b1=true) && ((output+=10)==20)){
System.out.println(\} else{
System.out.println(\}
6．运行以下程序，将得到的输出结果: 17 9 17 9 public class Abs{ static int a=0x11; static int b=0011; static int c='\'; static int d=011;
public static void main(String args[]){ System.out.println(a); System.out.println(b); System.out.println(c); System.out.println(d); } }
7．分析下列代码段，i、count变量的最终取值是: 6 12 int i=3;
int count=(i++)+(i++)+(i++);
8．字符‘A’的Unicode 编码为65。下面代码正确定义了一个代表字符‘A’的选项是：a c d
A) char ch = 65; B) char ch = '\\65'; C) char ch = '\A'; D) char ch = 'A'; E)char ch = \
9．下面哪些是java关键字: a d e g h
A) final B) Abstract C) Long D) static E) class F) main G) private H) System 10．下面哪些是不合法的标识符 c e f h
A) do_it_now B) _Substitute C) 9thMethod D) $addMoney E) %getPath F) 2variable G) variable2 H) #myvar 11．字节型数据的取值范围是: -128到127
12．请问下面哪些变量定义语句编译时会出错: a c f h
A) float f = 1.3; B) double D=4096.0; C) byte b = 257; D) String s = \ E) int i = 10; F) char c = \G) char C=4096; H) boolean b = null;
13．如果调用下面方法且参数值为67，那么方法的返回值是: 64 public int maskoff(int N){ return N^3; }
14．编写程序将34.5和68.4两个数相加，并将结果显示成以下形式：x+y=34.5+68.4=***.* public class test { public static void main(String[] args) {
float x=34.5f, y=68.4f; System.out.println( \
第三章 控制结构
1．结构化程序设计有哪三种流程？他们分别对应Java中那些语句。
结构化程序设计有三种基本流程：循环、分支和顺序。Java程序中的分支语句包含if语句、switch语句；循环语句包括了while语句，do-while语句、for语句；其他语句如变量、对象定义、赋值语句、方法调用语句、以及上面的循环结构、分支结构等按照上下文排列都是顺序语句。
2．在一个循环中使用break、continue和return有什么不同？
break用于跳出整个循环语句，在循环结构中一旦遇到break语句，不管循环条件如何，程序立即退出所在的循环体。
continue用于跳过本次循环中尚未执行的语句，但是仍然继续执行下一次循环中的语句。 在循环中使用return语句，将终止当前方法调用，同时终止循环，使流程返回到调用语句的下一个语句执行。
3.面代码将输出:________
a=9；b=18；c=4；d=14；e=-14；f=-2
g=18.4；h=2.3999999999999986；i=5；j=3；k=5
public class test3{
public static void main(String args[]){ int a=5+4; int b=a*2; int c=b/4; int d=b-c; int e=-d; int f=e%4; double g=18.4;
double h=g%4; int i=3;
int j=i++; int k=++i;
System.out.println(\；b=\；c=\；d=\；e=\；f=\ System.out.println(\；h=\；i=\；j=\；k=\} }
4.下面代码将输出:________ 25＜3=false
3!=0&&25/3>5=true 0!=0&&25/0>5=false
public class LogicTest{
public static void main(String args[]){ int a=25,b=3; boolean d=a System.out.println(a+\＜\＝; int e=3; d=(e!=0&&a/e>5); System.out.println(e+\ int f=0; d=(f!=0&&a/f>5); System.out.println(f+\ } } 5．编写程序，求两个整数的最大公约数。 import java.util.Scanner; public class Gcd_Lcm{ public static void main(String args[]){ Scanner sc = new Scanner(System.in); System.out.println(\输入2个数：以',' 隔开\ String []str = sc.next().split(\ int m = Integer.parseInt(str[0]); int n = Integer.parseInt(str[1]); int min = m>n？n:m; int max = m>n？m:n; int num1 =1; int num2 = max; for (int i = min; i>0; i--) { if (m%i==0&&n%i==0) { num1 = i;break; } } while (true) { if (num2%m==0&&num2%n==0) { break; } num2 = m*n>num2*2？num2*2:m*n; } System.out.println(\最大公约数：\最小公倍数:\} } 6．编写程序，打印出如下九九乘法表。 * | 1 2 3 4 5 6 7 8 9 -------|------------------------------------------------------- 1 | 1 2 | 2 4 3 | 3 6 9 4 | 4 8 12 16 5 | 5 10 15 20 25 6 | 6 12 18 24 30 36 7 | 7 14 21 28 35 42 49 8 | 8 16 24 32 40 48 56 64 9 | 9 18 27 36 45 54 63 72 81 public class NineByNineMul{ public static void main(String args[]){ System.out.print(\ |\ for(int i=1;i<=9;i++){ System.out.print(\ \ } System.out.println(); System.out.print(\ for(int i=1;i<=9;i++){ System.out.print(\ } System.out.println(); for(int i=1;i<=9;i++){ System.out.print(\ for(int j=1;j<=i;j++){ System.out.print(i*j+\ } System.out.println(); } } } 7．下面代码将输出: one two default int i = 1; switch (i) { case 0: System.out.println(\ break; case 1: System.out.println(\case 2: System.out.println(\ \ | \ default:System.out.println(\} 8．下面代码将输出: Equal class EqualsTest { public static void main(String[] args) { char a='\'; String s=a==0x0005L？\ System.out.println(s); } } 9．编写程序，对A[]={30，1，-9，70，25}数组由小到大排序。 public class booktest { public static void main(String[] args) { int a[]={30,1,-9,70,25}; System.out.print(\数组原始顺序：\ for (int i=0;i case 0: System.out.println(\ break; case 1: System.out.println(\ break; case 2: System.out.println(\ break; default: System.out.println(\ } 11．编写程序，求2-1000内的所有素数，并按每行5列的格式输出。 public class PrimeTest{ public static void main(String args[]) { int num=2; System.out.print(2 + \ for(int i=3;i<=1000;i+=2){ boolean f = true; for (int j=2;j 12．编写程序，生成100个1~6之间的随机数，统计1~6每个数字出现的概率。 public class RandomTest { public static void main(String[]args){ int[] randomnum=new int[100]; int[] n=new int[6]; double a; for(int i=0;i<100;i++){ a = Math.random()*6; a = Math.ceil(a); randomnum[i] = new Double(a).intValue(); System.out.print(randomnum[i]); switch (randomnum[i]){ case 1: n[0]++; break; case 2: n[1]++; break; case 3: n[2]++; break; case 4: n[3]++; break; case 5: n[4]++; break; case 6: n[5]++; break; } } System.out.println();//以下可改为循环输出 System.out.println(\数字1出现的概率=\ System.out.println(\数字2出现的概率=\ System.out.println(\数字3出现的概率=\ System.out.println(\数字4出现的概率=\ System.out.println(\数字5出现的概率=\ System.out.println(\数字6出现的概率=\ } } 13．编写程序，求1!+2!+3!+?+15!。 public class FactorialSum { static int f(int x) { if (x<=0) return 1; else return x*f(x-1); } public static void main(String[]args){ int sum=0; for(int j=1;j<=15;j++) { sum+=f(j); } System.out.println(sum); } } 14．编写程序，分别用do-while和for循环计算1+1/2!+1/3!+1/4!+?的前15项的和。 for循环代码: public class For_FactorialSum { static int f(int x) { if (x<=0) return 1; else return x*f(x-1); } public static void main(String[]args){ double sum=0; for(int j=1;j<=15;j++) { sum+=1.0/f(j); } System.out.println(sum); } } do-while循环代码: public class DoWhile_FactorialSum { static int f(int x) { if (x<=0) return 1; else return x*f(x-1); } public static void main(String[]args){ double sum=0; int j=1; do { sum+=1.0/f(j); j++; } while(j<=15); System.out.println(sum); } } 15．编写一个程序，用选择法对数组a[]={20,10,55,40,30,70,60,80,90,100}进行从大到小的排序。 (分别采用冒泡排序、选择排序和插入排序方法) public class SortAll { public static void main(String[] args) { int a[]={20,10,55,40,30,70,60,80,90,100}; System.out.println(\冒泡排序的结果：\ maoPao(a); System.out.println(); System.out.println(\选择排序的结果：\ xuanZe(a); System.out.println(); System.out.println(\插入排序的结果：\ chaRu(a); } // 冒泡排序 public static void maoPao(int[] x) { for (int i = 0; i < x.length; i++) { for (int j = i + 1; j < x.length; j++) { if (x[i] > x[j]) { int temp = x[i]; x[i] = x[j]; x[j] = temp; } } } for (int i : x) { System.out.print(i + \ } } // 选择排序 public static void xuanZe(int[] x) { for (int i = 0; i < x.length; i++) { int lowerIndex = i; // 找出最小的一个索引 for (int j = i + 1; j < x.length; j++) { if (x[j] < x[lowerIndex]) { lowerIndex = j; } } // 交换 int temp = x[i]; x[i] = x[lowerIndex]; x[lowerIndex] = temp; } for (int i : x) { System.out.print(i + \ } } // 插入排序 public static void chaRu(int[] x) { for (int i = 1; i < x.length; i++) {//i从1开始，因为第1个数已经是排好序的 for (int j = i; j > 0; j--) { if (x[j] < x[j - 1]) { int temp = x[j]; x[j] = x[j - 1]; x[j - 1] = temp; } } } for (int i : x) { System.out.print(i + \ } } } 16．编写程序，产生30个素数，按从小到大的顺序放入数组prime[]中。 public class PrimeArray { public static void main(String args[]) { int[] primearry=new int[30]; primearry[0]=2; int num=1; System.out.print(2 + \ for(int i=3;i<=1000;i+=2){ boolean f = true; for (int j=2;j f= false; break; } } if(!f) {continue;} primearry[num++]=i; System.out.print(i + \ if(num%5 == 0)System.out.println(); if(num==30)break; } } } 17. 一个数如果恰好等于它的因子之和，这个数就称为“完数”。分别编写一个应用程序和小应用程序求 1000之内的所有完数。 public class Wanshu { public static void main(String[] args) { int sum=0,i,j; for(i=1;i<=1000;i++) { for(j=1,sum=0;j System.out.print (\完数:\其因子是：\ for(int k=1;k<=sum/2;k++) { if(sum%k==0) System.out.print(\ } System.out.println(); } } } } 18. 从键盘读取若干个数，以“-1”结束，按从小到大的顺序排序。 import java.util.Scanner; public class sc_num { public static void main(String[] args) { Scanner scanner=new Scanner(System.in); int scnum=0,i=0; int []scarry=new int[30]; System.out.println(\输入整数(-1结束):\ while(scnum!=-1){ scarry[i]=scanner.nextInt();; scnum=scarry[i]; i++; } xuanZe(scarry,i-1); } // 选择排序 public static void xuanZe(int[] x,int n) { for (int i = 0; i 第四章 类与对象的基本概念 1．面向对象的软件开发有哪些优点？ 面向对象设计是一种把面向对象的思想应用于软件开发过程中，指导开发活动的系统方法，是建立在“对象”概念基础上的方法学。所谓面向对象就是基于对象概念，以对象为中心，以类和继承为构造机制，来认识、理解、刻画客观世界和设计、构建相应的软件系统。 从面向过程到面向对象是程序设计技术的一个飞跃。人们之所以要采用面向对象的程序设计技术，其目的在于：按照与人类习惯思维方法一致的原则开发系统；提高代码的可重用性(或者称为复用性)；提升程序的开发与运行效率；提高程序的可靠性与可维护性；提高程序的可扩展性；增强程序的可控制性。总之，面向对象的程序设计，能够有效分解、降低问题的 难度与复杂性，提高整个求解过程的可控制性、可监视性和可维护性，从而获得较高的开发效率与可靠效果。 2．什么叫对象？什么叫类？类和对象有什么关系。 对象(Object)是一个应用系统中用来描述客观事物的实体，是具有特定属性(数据)和行为(方法)的基本运行单位，是类的一个特定状态下的实例。对象是一件事、一个实体、一个名词、一个可以想象为有自己的标识的任何东西。对象是类的实例化。概括来说：万物皆对象。对象具有状态，一个对象用数据值来描述它的状态。 类(Class)是Java代码的基本组织模块，是用以描述一组具有共同属性和行为的对象的基本原型，是对这组对象的概括、归纳与抽象表达。类是对象的模板，它定义了本类对象所应拥有的状态属性集及操作这组属性的行为方法集。是对一组有相同数据和相同操作的对象的定义，一个类所包含的方法和数据描述一组对象的共同属性和行为。 类和对象之间的关系是抽象和具体的关系：类就是一种模板，表达的是一种抽象的概念，它描述了该类对象的共同特征，类是在对象之上的抽象，对象则是类的具体化，是类的实例。对象是模板的实例化，是个性的产物，是一个具体的个体；类必须通过对象才能使用，而对象中的属性和行为都必须在类中定义；类由属性和行为（方法）组成。 3．什么是包？把一个类放在包里有什么作用？ Java中的包(Package) 是一种松散的类的集合，是用来组织与管理类与接口的容器。包的作用主要是把需要协同工作的不同的类组织在一起，使得程序功能清楚、结构分明。 4．作用域public、private、protected以及不写时(default)有什么区别？ 当用一个类创建了一个对象之后，该对象可以通过“.”运算符访问自己的变量，并使用类中的方法。但访问自己的变量和使用类中的方法是有一定限制的。通过修饰符private、default、protected和public来说明类成员的使用权限。 private（私有的）：类中限定为private的成员只能在这个类中被访问，在类外不可见。 default（无修饰符，缺省的）：如果没有访问控制符，则该类成员可以被该类所在包中的所有其它类访问。 protected（受保护的）：用该关键字修饰的类成员可以被同一类、被该类所在包中的所有其它类或其子类(可以不在同一包中)的实例对象访问。 public：用public修饰的类成员可以被其他任何类访问，前提是对类成员所在的类有访问权限。 类成员访问控制符与访问能力之间的关系 同一个类 同一个包 不同包的子类 不同包非子类 private * default * * protected * * * public * * * * 5．什么是方法？方法的结构是怎样的？设计方法应考虑哪些因素？ 方法是Java类的一个组成部分，通过类的方法改变对象的状态。 方法的结构：[方法修饰符] 返回值类型 方法名（[形参列表]）[throws异常列表] { 方法体； } 设计方法应考虑因素有： (1) 方法名是Java中任意的标识符，按照命名的约定，方法名应该是有意义的动词或动词短语，它的第一个字母一般要小写，其他有意义的单词的首字母要大写，其余字母小写。 (2) 返回值类型可以是任意的Java类型，甚至可以是定义此方法的类。如果方法没有返回值，则用void表示。 (3) 形式参数列表是可选的。如果方法没有形式参数，就用一对小括号“()”表示。形式参数列表的形式如下： (类型 形参名，类型 形参名，??) (4) throws异常列表规定了在方法执行中可能导致的异常。 6．什么是方法的覆盖？ 与方法的重载有何不同？方法的覆盖与属性的隐藏有何不同？ 子类重新定义父类中已经存在的方法，称为方法的覆盖。 方法重载指一个类中有多个方法享有相同的名字，但是这些方法的参数必须不同，或者是参数的个数不同，或者是参数类型不同。返回类型不能用来区分重载的方法。其实方法重载的最主要的作用就是实现同名的构造方法可以接受不同的参数。参数类型的区分度一定要足够，例如不能是同一简单类型的参数，如int与long。方法的重载不是子类对父类同名方法的重新定义，而是在一个类中定义了同名的不同方法。 方法覆盖与属性的隐藏不同：子类重新定义父类已有的域，并不能完全取代它从父类那里继承的同名的域，这个域仍然占用子类的内存空间，在某些情况下会被使用；而当子类重新定义父类的方法时，从父类那里继承来的方法将被新方法完全取代，不再在子类的内存空间中占一席之地。 7．什么是成员变量、局部变量、类变量和实例变量？ 在方法外但在类声明内定义的变量叫成员变量，作用域是整个类。 在方法体中定义的变量和方法的参数被称为局部变量。 类的成员变量分为类变量和实例变量，类变量是用关键字static声明的变量。成员变量在整个类内都有效，局部变量只在定义它的方法内有效。 他们的生存期分别是：局部变量在定义该变量的方法被调用时被创建，而在该方法退出后被撤销；实例变量在创建该类的实例时被创建，而其生存期和该类的实例对象的生存期相同；类变量在该类被加载时被创建，所有该类的实例对象共享该类变量，其生存期是类的生存期。任何变量在使用前都必须初始化,但是需要指出的是局部变量必须显式初始化，而实例变量不必，原始类型的实例变量在该类的构造方法被调用时为它分配的缺省的值，整型是0，布尔型是false，而浮点型是0.0f，引用类型（类类型）的实例变量的缺省值是null，类变量的规则和实例变量一样，不同的是类变量的初始化是在类被加载时。 8．什么是继承？什么是父类？什么是子类？继承的特性可给面向对象编程带来什么好处？ 继承(Inheritance)：继承是指从已有的类中派生出若干个新类，是子类自动共享父类之间数据和方法的机制。已有类称为基类或父类，新类称为派生类或子类；子类将自动地获得基类的属性与方法，从而不需再重复定义这些属性与方法；当然子类还可以修改父类的方法或增加新的方法，从而使自己更适合特殊的需要。类之间的继承关系是现实世界中遗传关系的直接模拟。 如果没继承性机制，则类对象中数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性。继承是子对象可以继承父对象的属性和行为，亦即父对象拥有的属性和行为，其子对象也就拥有了这些属性和行为。这非常类似大自然中的物种遗传。 9．什么是多态？面向对象程序设计为什么要引入多态的特性？ 多态性：是指不同类的对象收到相同的消息时，得到不同的结果。即允许不同类的对象对同一消息作出各自的响应，以统一的风格处理已存在的数据及相关的操作。即 多态性语言具有灵活、抽象、行为共享、代码共享的优势，较好地解决了应用程序中方法同名的问题。多态的特点大大提高了程序的抽象程度和简洁性，更重要的是它最大限度地降低了类和程序模块之间的耦合性，提高了类模块的封闭性，使得它们不需了解对方的具体细节，就可以很好地共同工作。这对程序的设计、开发和维护都有很大的好处。 10．“子类的域和方法的数目一定大于等于父类的域和方法的数目”，这种说法是否正确？为什么？ 这样说是不对的，因为父类的私有方法不能被继承。如果父类有N个私有域和方法而只有一个非私有的域或方法时，跟据继承的原则子类只能拥有父类的非私有域和方法。这时子类的域和方法就要小于父类了。 11．父类对象与子类对象相互转化的条件是什么？如何实现它们的相互转化？ 一个子类对象也可以被合法地视为一个父类的对象，即一个父类对象的引用，其指向的内存单元可能实际上是一个子类的对象。在这种情况下，可以使用强制类型转换，将父类对象的引用转换成实际的子类对象的引用。 12．以下代码共创建了几个对象: 2 String s1=new String(\String s2=new String(\String s3=s1; String s4=s2; 13．分析以下代码，编译时出现什么现象: The local variable myArg may not have been initialized public class Test { static int myArg = 1; public static void main(String[] args) { int myArg; System.out.println(myArg); } } 14．对于以下程序，运行“java Mystery Mighty Mouse”，得到的结果: Mouse Mighty public class Mystery { public static void main(String[] args) { Changer c = new Changer(); c.method(args); System.out.println(args[0] + \} static class Changer { void method(String[] s) { String temp = s[0]; s[0] = s[1]; s[1] = temp; } } } 15．阅读下列程序，写出输出的结果: i = 100 i = 10 i = 10 class Xxx { private int i; Xxx x; public Xxx() { i = 10; x = null; } public Xxx(int i) { this.i = i; x = new Xxx(); } public void print() { System.out.println(\ System.out.println(x); } public String toString() { return \ } } public class Test{ public static void main(String[] args) { Xxx x = new Xxx(100); x.print(); System.out.println(x.x); } } 16．为了使以下Java应用程序输出11、10、9，应在(**)处插入的语句是: i[a]=(int)x[a]+1; 如果要求输出10、9、8，则在（**）处插入的语句应是: i[a]=(int)x[a]; public class GetIt { public static void main(String args[]) { double x[] = {10.2, 9.1, 8.7}; int i[] = new int[3]; for(int a = 0;a < (x.length);a++) { （**） System.out.println(i[a]); } } } 17．阅读下列程序，分析程序的输出结果: My func abstract class Base{ abstract public void myfunc(); public void another(){ System.out.println(\} } public class Abs extends Base{ public static void main(String argv[]){ Abs a = new Abs(); a.amethod(); } public void myfunc(){ System.out.println(\} public void amethod(){ myfunc(); } } 18．分析以下代码，编译时会出现的错误信息是: Test.java:6:secret 可以在A中访问private (return a.secret++; 出错) class A{ private int secret; } public class Test{ public int method(A a){ return a.secret++; } public static void main(String args[]){ Test test=new Test(); A a=new A(); System.out.println(test.method(a)); } } 19、分析以下程序，写出运行结果: 1234 public class Test19 { public static void changeStr(String str){ str=\ } public static void main(String[] args) { String str=\ changeStr(str); System.out.println(str); } } 20、分析以下程序，写出运行结果: ABDCBDCB public class Test20 { static boolean foo(char c) { System.out.print(c); return true; } public static void main(String[] args) { int i = 2; for (foo('A'); foo('B') && (i < 4); foo('C')) { i++; foo('D'); } } } 21．编写程序，要求创建一个Dog类，添加name,eyeColor属性，为该属性自动添加相应的set和get方法，并给出至少两个构造方法。 public class Dog { private String name, eyeColor; // 无形参的构造方法 public Dog (){ this. name =\逗逗\ this. eyeColor = \黑\ } // 有形参的构造方法 public Dog(String name, String eyeColor ){ this. name = name; this. eyeColor = eyeColor; } public String getEyeColor() { return eyeColor; } public void setEyeColor(String eyeColor) { this.eyeColor = eyeColor; } public String getName() { return name; } public void setName(String name) { this.name = name; } } 22．统计一个字符串中出现某个字母的次数(注意区分大小写)。 String类中的相关方法（具体用法请查看JDK帮助文档）： length( )：计算字符串长度，得到一个int型数值； indexOf( )：在字符串中定位某个子串，并返回位置编号 substring( )：截取字符串中的一部分，并作为一个新字符串返回； equals( )：比较两个String内容是否完全相同。 String str = \String chr = \int count = 0; for (int i = 0; i < str.length(); i++) { if (chr.equals(str.charAt(i))) count++; } System.out.println(\ 23. 创建一个桌子(Table)类，该类中有桌子名称、重量、桌面宽度、长度和桌子高度属性，以及以下几个方法： (1) 构造方法：初始化所有成员变量。 (2) area( )：计算桌面的面积。 (3) display( )：在屏幕上输出所有成员变量的值。 (4) changeWeight(int w)：改变桌子重量。 在测试类的main()方法中实现创建一个桌子对象，计算桌面的面积，改变桌子重量，并在屏幕上输出所有桌子属性的值。 package com.test; public class Table { String name;//名称 double weight;//重量 double width;//宽 double longth;//长 double height;//高 //构造方法 public Table(String name, double weight, double width, double longth, double height) { super(); this.name = name; this.weight = weight; this.width = width; this.longth = longth; this.height = height; } //计算桌面的面积 public void area(){ System.out.println(\桌子面积是\ } // 在屏幕上输出所有数据成员的值 public void display(){ System.out.println(\桌子名称:\重量:\宽:\长:\高:\ } //改变桌子重量的方法 public void changeWeight(int i){ this.weight=i; System.out.println(\面积改为\ } public static void main(String[] args) { Table table=new Table(\红木桌\ System.out.println(\创建一个桌子对象，属性如下\ table.display(); table.area(); table.changeWeight(100); System.out.println(\更改重量后，属性如下\ table.display(); } } 24．编写一个程序，在主类中创建和调用方法sumf()，方法sumf()的功能是进行两个浮点数的加法运算。试将12.7和23.4两个数相加并显示运算结果。 import java.util.Scanner; public class test { static float sumf(float x,float y) { return x+y; } public static void main(String[]args){ Scanner sc = new Scanner(System.in); System.out.println(\输入2个浮点数求和表达式，如：23.4+67.01\ String []str = sc.next().split(\ float m = Float.parseFloat(str[0]); float n = Float.parseFloat(str[1]); System.out.println(m+\ } } 第五章 类的高级特性 1．接口与抽象类有哪些异同点？ 在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。 接口与抽象类的主要异同点如下： (1) 接口定义了一组特定功能的对外接口与规范，而并不真正实现这种功能，功能的实现留待给实现这一接口的各个类来完成。抽象类一般作为公共的父类为子类的扩展提供基础，这里的扩展包括了属性上和行为上的。而接口一般来说不考虑属性，只考虑方法，使得子类可以自由的填补或者扩展接口所定义的方法。抽象类表示的是\关系，接口着重表示的是\关系。 (2) abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承。但是，一个类却可以实现多个interface，接口可以解决多重继承问题。 (3) 接口是抽象方法和常量值的定义的集合，从本质上讲，接口是一种只包含常量与抽象方法的特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。接口里面不能有私有的方法或变量，是用于让别人使用的，接口中的所有常量必须是public static final，且必须给其初值，其实现类中不能重新定义，也不能改变其值。接口中的方法必须是public abstract，这是系统默认的，不管你在定义接口时，写不写修饰符都是一样的。抽象类中是可以有私有方法或私有变量的，抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。 (4) 实现抽象类和接口的类必须实现其中的所有方法。在抽象类中可以有自己的数据成员，也可以有非abstarct的成员方法。而在interface中，只能够有静态的不能被修改的数据成员，所有的成员方法都是abstract的。实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重 写需要用到的方法。一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。 2．区分接口与抽象类分别在什么场合使用？ 如果预计要创建类的多个版本，则创建抽象类。抽象类提供简单的方法来控制类版本。 如果创建的功能将在大范围的异类对象间使用，则使用接口。 如果要设计小而简练的功能块，则使用接口。 如果要设计大的功能单元，则使用抽象类。如果要向类的所有子类提供通用的已实现功能，则使用抽象类。 抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。 抽象类应主要用于关系密切的对象，而接口最适合为不相关的类提供通用功能。 接口多定义对象的行为；抽象类多定义对象的属性； 3．一个类如何实现接口？实现某接口的类是否一定要重载该接口中的所有抽象方法？ 一个类使用关键字implements实现某接口。实现某接口的类如果不是抽象类，则需要通过重载来实现该接口中的所有抽象方法；如果这个类是抽象类，则它可以不必实现该接口中的 所有抽象方法。 4．对于以下程序，运行“java StaticTest”，得到的输出结果: public class StaticTest { static { System.out.println(\} public void print() { System.out.println(\} public static void main(String args []) { StaticTest st1 = new StaticTest(); st1.print(); StaticTest st2 = new StaticTest(); st2.print(); } } 答案： Hi there Hello Hello 5．编写程序，要求创建一个抽象类Father，其中有身高、体重等属性及爱好（唱歌）等方法，创建子类Son类继承Father类，并增加性格这个属性，改写父类的方法（爱好）。 public class test { public static void main(String args[]) { Son son = new Son(\乖儿子\篮球\ son.showInfo(); son.singsong(); } } abstract class Father { float high,weight; protected String name; Father(String name,float high,float weight) { this.name = name; this.high=high; this.weight=weight; } abstract void singsong(); abstract void showInfo(); } class Son extends Father { String specialty; Son(String name, float high,float weight,String specialty) { super(name,high,weight); this.specialty = specialty; } void singsong(){ System.out.println(name+\ } void showInfo() { System.out.println(\姓名：\身高：\体重：\爱好：\ } } 第六章 常用类库 1．Java中提供了名为（）的包装类来包装原始字符串类型。 A．Integer B．Char C．Double D．String 答案：D 2．java.lang包的（）方法比较两个对象是否相等，相等返回true。 A．toString（） B．equals（） C．compare（） D．以上所有选项都不正确 答案：B 3．使用（）方法可以获得Calendar类的实例。 A．get（） B．equals（） C．getTime（） D．getInstance（） 答案：D 4．下面的集合中，（）不可以存储重复元素。 A．Set B．Collection C．Map D．List 答案：C 5．关于Map和List，下面说法正确的是( )。 A．Map继承List B．List中可以保存Map或List C．Map和List只能保存从数据库中取出的数据 D．Map的value可以是List或Map 答案：D 6．给定如下Java代码，编译运行的结果是（）。 import java.util.*; public class Test { public static void main(String[] args) { LinkedList list=new LinkedList(); list.add(\ list.add(2,\ String s=(String)list.get(1); System.out.println(s); } } A．编译时发生错误 B．运行时引发异常 C．正确运行，输出：A D．正确运行，输出：B 答案：B 7．请写出下列语句的输出结果 char[] data={'a','b','c','d'}; System.out.println(String.valueOf(10D)); System.out.println(String.valueOf(3>2)); System.out.println(String.valueOf(data,1,3)); 参考答案： 10.0 true bcd 8．写出下面代码运行后的输出结果是。 public class Arrtest { public static void main(String kyckling[]){ int i[ ] = new int[5]; System.out.println(i[4]); amethod(); Object obj[ ] = new Object[5]; System.out.println(obj[2]); } public static void amethod(){ int K[ ] = new int[4]; System.out.println(K[3]); } } 参考答案： 0 0 null 9．什么是封装？Java语言中的封装类有哪些？ 参考答案： 封装是表示把数据项和方法隐藏在对象的内部，把方法的实现内容隐藏起来。Java中的封装类有Double、Integer、Float、Byte、Long、Character、Short和Boolean等类。 10．什么是泛型？使用泛型有什么优点？泛型List和普通List有什么区别？ 参考答案： 泛型是对Java语言的数据类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看做是使用参数化类型时指定的类型的一个占位符。 优点：提高Java程序的类型安全；消除强制类型转换；提高代码的重用率。 泛型List可以实例化为只能存储某种特定类型的数据，普通List可以实例化为存储各种类型的数据。通过使用泛型List对象，可以规范集合对象中存储的数据类型，在获取集合元素时不用进行任何强制类型转换。 11．编写一个程序，实现下列功能： ? 测试两个字符串String str1=”It is”和String str2=”It is”；是否相等 ? 将” a book.”与其中的str1字符串连接 ? 用m替换新字符串中的i 参考代码： public class Ex11 { public static void main(String[] args) { String str1=\ String str2=\ } } //比较字符串 System.out.println(\的结果：\ System.out.println(\的结果：\//连接字符串 String str3=str1.concat(\ System.out.println(\连接后的字符串为：\//替换字符 String str4=str3.replace('i','m'); System.out.println(\替换后的字符串为：\ 12．编程计算距当前时间10天后的日期和时间，并用“xxxx年xx月xx日”的格式输出新的日期和时间。 参考代码： import java.util.Calendar; public class Ex12 { public static void main(String[] args) { Calendar cal=Calendar.getInstance(); cal.add(Calendar.DAY_OF_YEAR,10); String strDate=cal.get(Calendar.YEAR)+\年\ } } +(cal.get(Calendar.MONTH)+1)+\月\ +cal.get(Calendar.DATE)+\日\System.out.println(\天后的日期为：\ 13．创建一个类Stack，代表堆栈（其特点为：后进先出），添加方法add(Object obj)、方法get（）和delete( )，并编写main方法进行验证。 参考代码： import java.util.LinkedList; import java.util.List; class Stack{ LinkedList list; public Stack() { list = new LinkedList(); } public void add(Object obj){ list.addFirst(obj); } public Object get(){ return list.getFirst(); } public void delete(){ list.removeFirst(); } } public class Ex13 { public static void main(String[] args) { Stack stack=new Stack(); stack.add(\ stack.add(\ stack.add(\ System.out.println(stack.get()); stack.delete(); System.out.println(stack.get()); } } 14．编写程序，计算任意两个日期之间间隔的天数。 参考代码： import java.util.Calendar; public class Ex14 { public static void main(String[] args) { Calendar c1 = Calendar.getInstance(); c1.set(2010, 7, 1); Calendar c2 = Calendar.getInstance(); long ca1 = c1.getTimeInMillis(); long ca2 = c2.getTimeInMillis(); // 计算天数 long days = (ca2 - ca1) / (24 * 60 * 60 * 1000); System.out.println(days); } } 15．创建一个HashMap对象，添加一些学生的姓名和成绩：张三：90分，李四，83分。接着从HashMap中获取并他们的姓名和成绩，然后把李四的成绩改为100分，再次输出他们的信息。 参考代码： import java.util.HashMap; public class Ex15 { public static void main(String[] args) { HashMap map=new HashMap(); map.put(\张三\ map.put(\李四\ System.out.println(\修改前的成绩：\ System.out.println(map); map.put(\李四\ System.out.println(\修改后的成绩：\ System.out.println(map); } } 16．编写一个程序，用parseInt方法将字符串200由十六进制转换为十进制的int型数据，用valueOf方法将字符串123456转换为float型数据。 参考代码： public class Ex16 { public static void main(String[] args) { String str1=\ System.out.println(Integer.parseInt(str1,16)); String str2=\ System.out.println(Float.parseFloat(str2)); } } 17．编写程序，将long型数据987654转换为字符串，将十进制数365转换为十六进制数表示的字符串。 参考代码： public class Ex17 { public static void main(String[] args) { long num=987654L; int i=365; System.out.println(\类型转换为String：\ String HexI=DtoX(i); System.out.println(HexI); } //转换函数 public static String DtoX(int d) { String x=\ if(d<16){ x=change(d); } else{ int c; int s=0; int n=d; while(n>=16){ s++; n=n/16; } String [] m=new String[s]; int i=0; do{ c=d/16; //判断是否大于10，如果大于10，则转换为A-F的格式 m[i++]=change(d); d=c; }while(c>=16); x=change(d); for(int j=m.length-1;j>=0;j--){ x+=m[j]; } } return x; } //判断是否为10-15之间的数，如果是则进行转换 public static String change(int d){ String x=\ switch(d){ case 10: x=\ break; case 11: x=\ break; case 12: x=\ } break; case 13: x=\ break; case 14: x=\ break; case 15: x=\ break; default: x=String.valueOf(d); } return x; } 18．编写一个程序，接收以克为单位的一包茶叶的单位重量、卖出的包数和每克的价格，计算并显示出销售的总额。其中三个数据一行输入，数据间用“-”分隔。比如：输入“3-100-2.1”，表示每包的重量为3克，共卖出100包，每克的价格为2.1元。此时的销售总额为630元。 参考代码： import java.util.Scanner; public class Ex18 { public static void main(String[] args) { Scanner scan=new Scanner(System.in); } } System.out.println(\请依次输入重量、包数、价格，并以-分隔：\String strIn=scan.nextLine(); Scanner sc=new Scanner(strIn); sc.useDelimiter(\ int num=sc.nextInt(); int bag=sc.nextInt(); float price=sc.nextFloat(); double total=price*num*bag; //设置分隔符 System.out.println(\销售总额为：\ 19．编写一个泛型方法，能够返回一个int类型数组的最大值和最小值、String类型数组的最大值和最小值（按字典排序）。 参考代码： class Pair public Pair() { min = null; max = null; } public Pair(T min, T max) { this.min = min; this.max = max; } public T getMin() { return min; } public T getMax() { return max; } public void setMin(T newValue) { min = newValue; } public void setMax(T newValue) { max = newValue; } } class ArrayAlg { public static T min = a[0];T max = a[0]; for (int i = 1; i < a.length; i++) { if (min.compareTo(a[i]) > 0) {min = a[i];} if (max.compareTo(a[i]) < 0) { max = a[i];} } return new Pair public class Ex19 { public static void main(String[] args) { //测试整型数组 Integer[] arrI={1,2,3,4,5,6}; Pair System.out.println(\整型数组的最小值：\System.out.println(\整型数组的最大值：\//测试字符串数组 String[ ] words ={\Pair System.out.println(\字符串数组的最小值：\ System.out.println(\字符串数组的最大值：\ } } 20．编写一个泛型方法，接受对象数组和集合作为参数，将数组中的对象加入集合中。并编写代码测试该方法。 参考代码： import java.util.*; public class Ex20 { static } } fromArrayToCollection(ia, cn);// T是Number类型 System.out.println(cn); 21．试编写一个List类型的对象只能存储通讯录（存储同学的姓名和联系方式），并输出通讯录的列表到控制台。 参考代码： import java.util.*; class Student{ private String name; private String phone; public Student(String name, String phone) { this.name = name; this.phone = phone; } public String toString() { return name+\ } } public class Ex21 { public static void main(String[] args) { Student st1=new Student(\ Student st2=new Student(\ List 22．设计一个程序，基于泛型Map实现10个英文单词的汉语翻译，即通过单词得到它的中文含义。 参考代码： import java.util.*; public class Ex22 { public static void main(String[] args) { String[] eng={\ String[] chs={\苹果\桔子\绿色\ Map 第七章 异常 1．什么是异常？什么是Java的异常处理机制？ 参考答案： 异常是指程序运行过程中产生的错误，它出现在程序运行过程中。 异常处理机制是为程序提供错误处理的能力。根据这个机制，对程序运行时可能遇到的异常情况，预先提供一些处理的方法。在程序执行代码的时候，一旦发生异常，程序会根据预定的处理方法对异常进行处理，处理完成后，程序进行运行。 2．Java中的异常分为哪几类？ 参考答案： Java中的异常分为两种类型： ? 内部错误：又称为致命错误。比如：硬盘损坏、软驱中没有软盘 ? 运行时异常：比如除数为0、数组下标越界 3．所有异常的父类是（）。 A．Error B．Throwable C．RuntimeException D．Exception 答案：B 4．下列（）操作不会抛出异常。 A．除数为零 B．用负数索引访问数组 C．打开不存在的文件 D．以上都会抛出异常 答案：D 5．能单独和finally语句一起使用的块是（）。 A．try B．throws C．throw D．catch 答案：A 6．在多重catch块中同时使用下列类时，（）异常类应该最后列出。 A．Exception B．ArrayIndexOutOfBoundsException C．NumberFormatException D．ArithmeticException 答案：A 7．执行下面的代码会引发（）异常。 String str=null; String strTest=new String(str); A．InvalidArgumentException B．IllegalArgumentException C．NullPointerException D．ArithmeticException 答案：C 8．这段代码的输出结果是（）。 try{ System.out.print(\，\ return; } catch(Exception e){ System.out.print(\，\ } finally { System.out.print(\ } A．try， B．try，catch， C．try，finally D．try， catch，finally 答案：C 9．这个方法的返回值是（）。 public int count() { try{ return 5/0; } catch(Exception e){ return 2*3; } finally { return 3; } } A．0 B．6 C．3 D．程序错误 答案：C 10．编写一个程序，产生ArrayIndexOutOfBoundsException异常，并捕获该异常，在控制台输出异常信息。 参考代码： public class Ex10 { public static void main(String[] args) { int[] arr=new int[2]; try { System.out.println(arr[2]); } catch (ArrayIndexOutOfBoundsException e) { e.printStackTrace(); } } } 11．设计一个Java程序，自定义异常类，从键盘输入一个字符串，如果该字符串值为“abc”，则抛出异常信息，如果从键盘输入的是其他字符串，则不抛出异常。 参考代码： import java.util.Scanner; class MyException extends Exception{ private String errorMsg; //getter和setter方法 public MyException(String errorMsg){ this.errorMsg=errorMsg; } @Override public String toString() { return errorMsg; } } public class Ex11 { public static void main(String[] args) { String strIn; Scanner scan=new Scanner(System.in); strIn=scan.nextLine(); try { if(strIn.equals(\ } } throw new MyException(\输入的字符串不正确！\} catch (MyException e) { System.out.println(e); } 12．设计一个Java程序，从键盘输入两个数，进行减法运算。当输入串中含有非数字时，通过异常处理机制使程序正常运行。 参考代码： import java.util.*; public class Ex12 { public static void main(String[] args) { int num1,num2; Scanner in=new Scanner(System.in); try { num1=in.nextInt(); } catch (InputMismatchException e) { System.out.println(\第一个数格式不对\ num1=0; } try { num2=in.nextInt(); } catch (InputMismatchException e) { System.out.println(\第二个数格式不对\ num2=0; } System.out.println(\ } } 13．自定义异常类，在进行减法运算时，当第一个数大于第二个数时，抛出“被减数不能小于减数”，并编写程序进行测试。 参考代码： import java.util.Scanner; //MyException类的定义（同第11题） public class Ex13 { public static void main(String[] args) { int num1,num2; Scanner scan=new Scanner(System.in); num1=scan.nextInt(); num2=scan.nextInt(); try { if(num1 } throw new MyException(\被减数不能小于减数\} catch (MyException e) { System.out.println(e); } 第八章 输入输出流 1．什么是流？什么是输入流和输出流？ 参考答案： 流是一组有序的数据系列。数据系列从文件、内存或其他设备中流入到CPU的，称为输入流。数据系列从CPU流出到文件、内存或其他设备的，称为输出流。 2．Java语言的流分为哪几类？ 参考答案： 根据数据流的流动方向，把流分为输入流和输出流。根据流动的内容，把流分为字节流和字符流。 3．Java中，（）类提供定位本地文件系统的功能，对文件或目录及其属性进行基本操作。（选择一项） A．FileInputStream B．FileReader C．FileWriter D．File 答案：D 4．在Java中，要判断d盘下是否存在文件abc.txt，应该使用以下（）判断句。 A．if(new File(“d:/abc.txt”).exists()==1) B．if(File.exists(“d:/abc.txt”) ==1) C．if(new File(“d:/abc.txt”).exists()) D．if(File.exists (“d:/abc.txt”)) 答案：C 5．字符流是以（）传输数据的。 A．1个字节 B．8位字符 C．16位Unicode字符 D．1个比特 答案：C 6．（）方法可以用来清除流。 A．void release（） B．void close（） C．void Remove（） D．void flush（） 答案：D 7．给定下面的代码段，file1.txt文件的内容是“Hello World”。编译运行后，输出结果为“Hello”，而不是预期的“Hello Word”。 FileInputStream in=new FileInputStream(\ StringBuffer sb=new StringBuffer(); //第一行 for(int i=0;i 8．编写一个程序将文件source.txt的内容复制到文件object.txt中，源文件和目标文件的名称在程序运行时输入。 参考代码： import java.io.*; public class Ex08 { public static void main(String[] args) { String FileIn=args[0]; String FileOut=args[1]; int rs; byte b[]=new byte[10]; try { FileInputStream fis=new FileInputStream(FileIn); FileOutputStream fos=new FileOutputStream(FileOut); rs=fis.read(b,0,10); while(rs>0){ fos.write(b,0,10); rs=fis.read(b,0,10); } fos.close(); fis.close(); } catch (Exception e) { e.printStackTrace(); } } } 9．编写一个程序，将一个身份证号码以数字的形式写入文件中。 参考代码： import java.io.FileWriter; import java.util.Scanner; public class Ex09 { public static void main(String[] args) { Scanner scan=new Scanner(System.in); try { FileWriter fw=new FileWriter(\ String in=scan.nextLine(); char[] arr=in.toCharArray(); fw.write(arr); fw.close(); } catch (Exception e) { e.printStackTrace(); } } } 10．编写一个程序，将文本文件中的内容，以行为单位，调整为倒序排列。 参考代码： import java.io.*; import java.util.LinkedList; public class Ex10 { public static void main(String[] args) { String temp=null; LinkedList } fw.close(); } catch (Exception e) { e.printStackTrace(); } } 11．列出D盘中所有的文件和目录。如果是目录的话，再次进行列举，直到把D盘中的所有目录中的文件都列举出来为止。 参考代码： import java.io.File; public class Ex11 { public static void main(String[] args) { File file = new File(\ getFile(file); } public static void getFile(File file) { if (file.isDirectory()) { } 12．假设有字节数组： byte b[]=new byte[50]和FileInputStream类的对象in， in=new FileInputStream(“m.java”); 那么对于：int len=in.read(b)；m的值一定是50吗？ 参考答案： len的值不一定是50。这里的len表示读入缓冲区的字节总数，如果读入的字节不满50个，则返回实际读入的字节数。 13．编写一个程序，从键盘读入一个数字字符串，然后转换成相对应的int数值后保存到文件中。 参考代码： import java.io.*; import java.util.Scanner; public class Ex13 { public static void main(String[] args) { Scanner scan=new Scanner(System.in); String str=scan.next(); int i=Integer.valueOf(str); } System.out.println(\目录: \ File[] subFiles = file.listFiles(); for (int i = 0; i < subFiles.length; i++) { getFile(subFiles[i]); } } else { System.out.println(\文件: \} } } try { FileWriter fw=new FileWriter(\ fw.write(i); fw.close(); } catch (IOException e) { e.printStackTrace(); } 14．设计一个程序，实现下述功能：假设file1.txt包含“1，3，5，7，8”，另一个文件file2.txt包含“2，9，11，13”，编写程序把这两个文件的内容合并到一个新文件中，并且要求这些数据必须按照升序排列写入到新文件中。 参考代码： import java.io.*; import java.util.Arrays; public class Ex14 { public static void main(String[] args) { try { FileReader fr1=new FileReader(\ BufferedReader bf1=new BufferedReader(fr1); FileReader fr2=new FileReader(\ BufferedReader bf2=new BufferedReader(fr2); String str1=bf1.readLine(); String str2=bf2.readLine(); bf1.close();fr1.close();bf2.close();fr2.close(); String[] strI=str1.split(\ String[] strJ=str2.split(\ String[] str=new String[strI.length+strJ.length]; System.arraycopy(strI,0,str,0,strI.length); System.arraycopy(strJ,0,str,strI.length, strJ.length); Arrays.sort(str); FileWriter fw=new FileWriter(\ BufferedWriter bw=new BufferedWriter(fw); for(int i=0;i 第九章 多线程 1．什么是线程？什么是进程？它们有什么区别？ 参考答案： 进程是程序的一次执行，对应了从代码的加载、执行到执行结束的完整过程。 线程是比进程更小的执行单元，是程序执行流的最小单元。 它们的区别主要是：每个进程对应一个单独的地址空间，而多个线程共用一个存储空间；一个进程可以产生若干个线程，进程负责线程的创建和启动。 2．如何创建一个线程，实现Runnable接口和继承Thread类有什么区别？ 参考答案： 线程的创建有两种方法：一种是通过实现Runnable接口；另一种通过继承Thread类实现。实现Runnable接口时，在run()方法中实现规定的功能；继承Thread类时，通过重写该类的run()方法实现规定的功能。 3．什么是线程的同步，为什么要实现线程的同步？ 参考答案： 线程同步是指多个线程有序访问某个/些资源的机制。当多个线程同时访问一个对象时，为了保持对象数据的统一性和完整性，必须采用线程的同步机制。 4．run（）方法在（）方法被调用后执行。 A．init（） B．begin（） C．start（） D．create（） 答案：C 5．分析下面的代码，选择所有正确的选项。 public class Test { public static void main(String[] args) { Thread t=new Thread(); t.start(); } } A．Test类必须继承Thread类 B．Test类必须实现Runnable接口 C．由于未实现run（）方法，因此会出现运行时错误 D．这段代码没有任何错误 答案：D 6．编写一个程序，用于实现Runnable接口并创建两个线程，分别输出从10到15的数，每个数字间延迟500毫秒，要求输出的结果如下所示： 10，11，12，13，14，15 10，11，12，13，14，15 提示：采用线程同步的方法。 参考代码： class Sync{ public static synchronized void print(){ try { for(int i=10;i<=15;i++){ System.out.print(i); } if(i!=15) System.out.print(\ Thread.sleep(500); } System.out.println(); } catch (InterruptedException e) { e.printStackTrace(); } } public class Ex06 implements Runnable { public static void main(String[] args) { Thread t1=new Thread(new Ex06()); Thread t2=new Thread(new Ex06()); t1.start(); t2.start(); } public void run() { Sync.print(); } } 7．编写一个采用多线程技术的程序，对10000个数据求累加和？ 参考代码： public class Ex07 extends Thread{ private int start; private int len; private static double[] arr; public static double sum; public Ex07(int start,int len){ this.start=start; this.len=len; arr=new double[10000]; for(int i=0;i<10000;i++){ arr[i]=Math.random(); } } public static void main(String[] args) { Ex07 t1=new Ex07(0,2000); Ex07 t2=new Ex07(2000,2000); Ex07 t3=new Ex07(4000,2000); Ex07 t4=new Ex07(6000,2000); Ex07 t5=new Ex07(8000,2000); t1.start();t2.start();t3.start();t4.start();t5.start(); System.out.println(\ } @Override public void run() { for(int i=start;i } 8．编写一个程序，创建3个线程，分别输出26个字母。在输出结果时要指明是哪个线程输出的字母。 参考代码： class Syn extends Thread{ private char ch='a'; public Syn(String name){ setName(name); } public void run() { char temp; for(int i=0;i<26;i++){ temp=(char)(ch+i); System.out.println(this.getName()+\ } } } public class Ex08{ public static void main(String[] args) { } Syn t1=new Syn(\线程1\Syn t2=new Syn(\线程2\Syn t3=new Syn(\线程3\t1.start(); t2.start(); t3.start(); } 9．使用Runnable接口，把下面的类转化为线程，实现利用该线程打印边界范围内的所有奇数。 public class PrintOdds { private int bound; public PrintOdds(int b){ bound=b; } public void print(){ for(int i=1;i } 参考代码： class PrintOdds extends Thread { private int bound; public PrintOdds(int b){ bound=b; } public void run(){ for(int i=1;i public class Ex09 { public static void main(String[] args) { PrintOdds p1=new PrintOdds(100); p1.start(); } } 第十章 数据库编程 1． JDBC API中常用的类和接口有哪几个？ 参考答案： 常用的类和接口包括：DriverManger类、Connection接口、Statement接口、PreparedStatement接口和ResultSet接口。 2． Statement接口与PreParedStatement接口有什么区别？ 参考答案： PreparedStatement接口继承自Statement接口，它具有Statement的所有方法，同时添加了一些新的方法。它们的区别主要有以下两点： ? PreparedStatement接口包含已编译的SQL语句，而Statement没有 ? PreparedStatement接口中的SQL语句可包含若干个in参数，也可用“？”占位符， 而Statement没有。 3． 修改例10-3，为InsertUser类添加两个方法实现如下功能： （1） 根据用户ID添加删除用户方法del(int userId) （2） 根据用户ID修改用户密码方法update(int userId,String password) 参考代码： import java.sql.*; public class Ex03 { private Connection con; private PreparedStatement pstmt; public int del(int userId){ int result=0; con=ConnectionManager.getConnction();//得到数据库连接 try { String sql=\ pstmt=con.prepareStatement(sql); //创建PreparedStatement对象 pstmt.setInt(1,userId); result=pstmt.executeUpdate(); //执行删除操作 } catch (SQLException e) { e.printStackTrace(); } finally { ConnectionManager.closeStatement(pstmt);//释放PreparedStatement对象 ConnectionManager.closeConnection(con);//关闭与数据库连接 } return result; } public int update(int userId,String password){ int result=0; con=ConnectionManager.getConnction();//得到数据库连接 try { String sql=\ pstmt=con.prepareStatement(sql); //创建PreparedStatement对象 pstmt.setString(1,password); pstmt.setInt(2,userId); result=pstmt.executeUpdate(); //执行更新操作 } catch (SQLException e) { e.printStackTrace(); } finally { ConnectionManager.closeStatement(pstmt);//释放PreparedStatement对象 ConnectionManager.closeConnection(con);//关闭与数据库连接 } return result; } } 4． 已知与表userinfo对应的实体类为UserInfo，代码如下： public class UserInfo{ private int userId; private String username; private String password; //相应的set和get方法省略 } 创建一个OpUserInfo类，添加相应方法实现如下功能： （1）根据用户名和密码查询用户信息，如果找到满足条件用户则返回1，否则返回0 （2）根据用户名进行模糊查询，返回值为一个List类型的实例，数组实例中存放的是UserInfo类的对象。可参照例10-10。 参考代码： import java.sql.*; import java.util.ArrayList; import java.util.List; public class Ex04 { private Connection connection; private PreparedStatement UserQuery; private ResultSet results; public int getByUserAndPwd(String username,String password){ int result=0; try { connection = ConnectionManager.getConnction(); UserQuery = connection .prepareStatement(\password=?\ UserQuery.setString(1,username); UserQuery.setString(2,password); ResultSet results = UserQuery.executeQuery(); if(results.next()) { result=1; } } catch (SQLException exception) {// 处理数据库异常 exception.printStackTrace(); } // 释放资源 finally { ConnectionManager.closeResultSet(results); ConnectionManager.closeStatement(UserQuery); ConnectionManager.closeConnection(connection); } return result; } public List getByUser(String username) { List UserList = new ArrayList(); try { connection = ConnectionManager.getConnction(); UserQuery = connection .prepareStatement(\'%\ ResultSet results = UserQuery.executeQuery(); // 读取行数据 while (results.next()) { UserInfo userinfo=new UserInfo(); //将数据表中的一条记录数据添加到封装类中 userinfo.setUserId(results.getInt(1)); } } } userinfo.setLoginName(results.getString(2)); userinfo.setPassword(results.getString(3)); UserList.add(userinfo); // 处理数据库异常 catch (SQLException exception) { exception.printStackTrace(); } // 释放资源 finally { ConnectionManager.closeResultSet(results); ConnectionManager.closeStatement(UserQuery); ConnectionManager.closeConnection(connection); } return UserList; } 5．在例-5和例-6基础上，为account表添加查询功能：根据用户账号查询用户的余额，如果查找到则返回余额，如果未找到则返回-1。 参考代码： import java.sql.*; public class Ex05 { private Connection con; private PreparedStatement pstmt; private ResultSet res; //根据用户账号查询记录 public double findById(int id) { double result=-1; con=ConnectionManager.getConnction();//得到数据库连接 try { String sql=\ pstmt=con.prepareStatement(sql); //创建PreparedStatement对象 pstmt.setInt(1,id); res=pstmt.executeQuery(); //执行查询操作 if(res.next()) result=res.getDouble(1); } catch (SQLException e) { e.printStackTrace(); } finally { //释放ResultSet对象 ConnectionManager.closeResultSet(res); //释放PreparedStatement对象 ConnectionManager.closeStatement(pstmt); } } ConnectionManager.closeConnection(con);//关闭与数据库连接 } return result; 第十一章 java web概述与web发布 1． 怎样理解HTTP是无状态协议？HTTP协议默认端口号是多少？ 参考答案： HTTP是一个无状态协议；客户端与服务器端通信之前将建立一个连接，传递相关的信息，然后服务器端会关闭这个连接，在服务器端不会保存任何客户端的信息。在客户端和服务器端进行下一次通信时，会重复第一次的过程，不会保留任何信息，这就是所谓的无状态协议。HTTP协议默认端口号是80。 2． 通过HTTP协议向服务提交请求有哪两种方式？它们有什么区别？ 参考答案： 有两种方式：一种是Get方式，另一种是Post方式。它们的区别有两个方面：第一、用Get方式提交的数据在地址栏中是可见的，而Post方式是不可见的；第二、用Get方式提交数据时有长度限制，而Post方式则没有长度的限制。 3． 在服务器返回的头信息中状态码200和404分别表示什么含义？ 参考答案： 状态码200表示已成功处理了用户的请求；状态码404代表输入的URL地址不存在或者不可访问，即没有访问权限。 4． Tomcat有哪几个组件组成，它们的关系如何？ 参考答案： Tomcat由Engine组件、Host组件和Context组件等三个组件构成；这三个组件分别代表不同的服务范围；其中Engine组件的范围大于Host组件，而Host组件的范围大于Context组件。 5． 在MyEclipse中如何配置和启动Tomcat？ 参考答案： 在MyEclipse中通过加载Tomcat插件；设置CLASSPATH变量；设置Tomcat服务器的路径的方法配置Tomcat。如果成功配置了Tomcat服务器，可以在MyEclipse的工具栏中启动Tomcat；或者在Server窗体中启动Tomcat服务器。 6．简述Java Web的目录结构？ 参考答案： 在成功创建了一个Java Web项目后，会自动生成两个目：一个是src目录，用来存放类源文件；另一个是WebRoot目录，存放静态网页和动态网页，在WebRoot目录下有WEB-INF和lib两个子目录，WEB-INF存放受保护的文件，lib目录存放Java Web工程使用到的jar包。 第十二章 JSP技术 1．JSP页面中注释与<%---->注释有何区别？ 参考答案： 在JSP中，注释在客户端是可见的，就是说用户访问所在页时能够看到这段注释；而<%-- --%>注释在客户端是不可见的，就是说用户不能看到这段注释的内容，只有软件开发人员才能看到。 2．在JSP页面声明<%!......%>中定义的变量与在JSP程序段<%......%>中定义的变量有何不同？ 参考答案： 在JSP中，<%! %>中声明的变量相当于static变量，系统会自动给它赋初值，它的作用域是整个页面，用户再次请求该页面时，该变量的值会被保留；而<% %>中声明的变量需要显式初始化，赋予初值，当用户再次请求页面时，该变量会再次被初始化。换一种说法就是：<%! %>中声明的变量相当于全局变量；而<% %>中声明的变量相当于局部变量。 3．编写一个JSP程序，要求设置一个计数器，并输出访问该页面的次数。 参考代码： <%@ page language=\ int count=0; if(application.getAttribute(\ count=(Integer)application.getAttribute(\ %> 一共有<%=++count%>访问该页面 <%application.setAttribute(\ 4．编写一个JSP程序，输出当前系统日期，日期格式为YYYY年MM月DD日。 参考代码： <%@ page language=\ Date dt=new Date(); SimpleDateFormat smf=new SimpleDateFormat(\年MM月dd日\ out.print(smf.format(dt)); %> 5．编写一个JSP页面，利用for循环语句动态生成如下的表格： 第1列 1 6 11 第2列 2 7 12 第3列 3 8 13 第4列 4 9 14 第5列 5 10 15 参考代码： <%@ page language=\ 自动生成的表格 <%for(int i=0;i<12;i+=5){ %> 6．制作一个网站的首页，页面由上、中、下三个部分组成，每一部分都是一个独立的JSP页面。上面页面由一个Logo图片组成，下面页面是相关版权信息和联系方式，中间页面是正文。在网站的首页index.jsp中用include指令将三个页面组织在一起。 参考代码： //top.jsp页面 //center.jsp页面 <%@ page contentType=\ <%} %>