admin 管理员组文章数量: 887154
2023年12月23日发(作者：css实现从下往上滑动效果)
第1-7章习题解答
习题1 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 HelloWorva” 编译HelloWorla为HelloWorass;
(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:windowssystem32目录中，而此目录已经存在于path变量，所以说用户变量path随不同用户而设置的，设置路径：“D:jdk1.5bin ”。 PATH环境变量作用是指定命令搜索路径，在命令行下面执行命令如javac编译java程序时，它会到PATH变量所指定的路径中查找看是否能找到相应的命令程序。我们需要把jdk安装目录下的bin目录增加到现有的PATH变量中，bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好PATH变量后，就可以在任何目录下执行javac/java等工具了。
（2）CLASSPATH环境变量。作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPTH来寻找类的。我们需要把jdk安装目录下的lib子目录中的r和toor设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。设置classpath环境变量是为了运行一些特殊的java程序，如以.jar为后缀的文件或者是javac运行java程序，假如不运行这类程序，也就不必要设置classpath环境变量了，设置方法是：（安装jdk是的目录为：d:jdk1.5) 那么就在“变量值”文本框中键入：“.;D:jdk1.libr;D:jdk1.5libtool ”；
习题2 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("We are equal "+output);
}
else{
Syste.println("Not equal! "+output);
}
5．以下代码运行后的输出结果: We are equal 20
int output=10;
boolean b1 = false;
if((b1=true) && ((output+=10)==20)){
Syste.println("We are equal "+output);
}
else{
System.ointln("Not equal! "+output);
}
6．运行以下程序，将得到的输出结果: 17 9 17 9
public class Abs{
static int a=0x11;
static int b=0011;
static int c='u0011';
static int d=011;
public static void main(String args[]){
System.out.println(a);
Systntln(b);
System.out.println(c);
System.ointln(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 = 'u0041';
D) char ch = 'A'; E)char ch = "A";
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 = "1"; E) int i = 10; F) char c = "a";
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;
Syste.println( "x+y="+x+"+"+y+"="+(x+y));
习题3
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("a="+a+"；b="+b+"；c="+c+"；d="+d+"；e="+e+"；f="+f);
System.ointln("g="+g+"；h="+h+"；i="+i+"；j="+j+"；k="+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+"＜"+b+"="+d);//＝; int e=3; d=(e!=0&&a/e>5); System.out.println(e+"!=0&&"+a+"/"+e+">5="+d); int f=0; d=(f!=0&&a/f>5); Systntln(f+"!=0&&"+a+"/"+f+">5="+d); } } 5．编写程序，求两个整数的最大公约数。 import java.util.Scanner; public class Gcd_Lcm{ public static void main(String args[]){ Scanner sc = new Scanner(System.in); System.ointln("输入2个数：以',' 隔开"); String []str = sc.next().split(","); int m = IntegrseInt(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.ointln("最大公约数："+num1+" 最小公倍数:"+num2); } } 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.oint(" * |"); for(int i=1;i<=9;i++){ Systnt(" "+i+" "); } Syste.println(); System.oint("-------|-----"); for(int i=1;i<=9;i++){ Systnt("-----"); } Syste.println(); for(int i=1;i<=9;i++){ System.out.print(" "+i+" | "); for(int j=1;j<=i;j++){ System.out.print(i*j+" "); } Systntln(); } } } 7．下面代码将输出: one two default nt ii = 1; switch (i) { case 0: System.ointln("zero"); break; case 1: Systntln("one"); case 2: Systntln("two"); default:Systntln("default"); } 8．下面代码将输出: Equal class EqualsTest { public static void main(String[] args) { char a='u0005'; String s=a==0x0005L？"Equal":"Not Equal"; Systntln(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<gth;i++) System.out.print(a[i] + " "); for (int i = 0; i < a.length; i++) { int lowerIndex = i; for (int j = i + 1; j < ngth; j++) if (a[j] < a[lowerIndex]) lowerIndex = j; int temp = a[i]; a[i] = a[lowerIndex]; a[lowerIndex] = temp; } Syste.print("n数组排序后的顺序： "); for (int i=0;i } } 10．运行下面代码将输出什么内容？ one int i=1; switch(i){ case 0: System.out.println("zero"); break; case 1: System.out.println("one"); break; case 2: Systntln("two"); break; efaudlt: Syste.println("default"); } 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 if(i % j == 0){ f= false; break; } } if(!f) {continue;} System.out.print(i + " "); if(num++%5 == 0)System.out.println(); } } } 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(); Systnt(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; } } Syste.println();//以下可改为循环输出 System.ointln(" 数字1出现的概率="+(n[0]/100.0)*100+"%"); Systntln(" 数字2出现的概率="+(n[1]/100.0)*100+"%"); Systntln(" 数字3出现的概率="+(n[2]/100.0)*100+"%"); Systntln(" 数字4出现的概率="+(n[3]/100.0)*100+"%"); Systntln(" 数字5出现的概率="+(n[4]/100.0)*100+"%"); Systntln(" 数字6出现的概率="+(n[5]/100.0)*100+"%"); } } 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); Syste.println(); System.out.println("----选择排序的结果："); xuanZe(a); Syste.println(); System.out.println("----插入排序的结果："); chaRu(a); } // 冒泡排序 public static void maoPao(int[] x) { for (int i = 0; i < ngth; i++) { for (int j = i + 1; j < gth; 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) { Systnt(i + " "); } } // 插入排序 public static void chaRu(int[] x) { for (int i = 1; i < ngth; 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) { Syste.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.oint(2 + " "); for(int i=3;i<=1000;i+=2){ boolean f = true; for (int j=2;j if(i % j == 0){ f= false; break; } } if(!f) {continue;} primearry[num++]=i; Systnt(i + " "); if(num%5 == 0)Systntln(); 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 { if(i%j==0) sum=sum+j; } if(sum==i) { System.out.print ("完数:"+i+" "+"其因子是：" ); for(int k=1;k<=sum/2;k++) { if(sum%k==0) Syste.print(" "+k); } System.ointln(); } } } } 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]=scannxtInt();; scnum=scarry[i]; i++; } xuanZe(scarry,i-1); } // 选择排序 public static void xuanZe(int[] x,int n) { for (int i = 0; i int lowerIndex = i; for (int j = i + 1; j < n; j++) { if (x[j] < x[lowerIndex]) { lowerIndex = j; } } int temp = x[i]; x[i] = x[lowerIndex]; x[lowerIndex] = temp; } for (int i=0;i<n;i++) { System.out.print(x[i] + " "); } } } 习题4 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("hello"); String s2=new String("hello"); 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.ointln(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] + " " + args[1]); } 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("i = " + i); System.out.println(x); } public String toString() { return "i = " + i; } } public class Test{ public static void main(String[] args) { Xxx x = new Xxx(100); x.print(); System.ointln(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++) { （**） Systntln(i[a]); } } } 17．阅读下列程序，分析程序的输出结果: My func abstract class Base{ abstract public void myfunc(); public void another(){ System.out.println("Another method"); } } public class Abs extends Base{ public static void main(String argv[]){ Abs a = new Abs(); a.amethod(); } public void myfunc(){ System.ointln("My func"); } public void amethod(){ myfunc(); } } 18．分析以下代码，编译时会出现的错误信息是: Teva:6:secret 可以在A中访问private (return cret++; 出错) 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.ointln(test.method(a)); } } 19、分析以下程序，写出运行结果: 1234 public class Test19 { public static void changeStr(String str){ str="welcome"; } public static void main(String[] args) { String str="1234"; changeStr(str); System.ointln(str); } } 20、分析以下程序，写出运行结果: ABDCBDCB public class Test20 { static boolean foo(char c) { System.oint(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) { theColor = 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 = "abckajbfhbbkhfgabkbjkdfasjkbdanjkasfbai"; String chr = "b"; int count = 0; for (int i = 0; i < sngth(); i++) { if (cuals(str.charAt(i))) count++; } System.ointln("The count is " + count); 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; thdth = width; this.longth = longth; this.height = height; } //计算桌面的面积 public void area(){ System.ointln("桌子面积是"+longth*width); } // 在屏幕上输出所有数据成员的值 public void display(){ Syste.println("桌子名称:"+name+"n"+"重量:"+weight+"n"+"宽:"+width+"n"+"长:"+longth+"n高:"+height); } //改变桌子重量的方法 public void changeWeight(int i){ this.weight=i; System.out.println("面积改为"+this.weight); } public static void main(String[] args) { Table table=new Table("红木桌",100.5,3.2,2.3,1.5); Syste.println("创建一个桌子对象，属性如下"); table.display(); table.area(); tablngeWeight(100); System.out.println("更改重量后，属性如下"); tablplay(); } } 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]); Systntln(m+"+"+n+"="+ sumf(m,n)); } } 习题5 1．接口与抽象类有哪些异同点？ 在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。 接口与抽象类的主要异同点如下： (1) 接口定义了一组特定功能的对外接口与规范，而并不真正实现这种功能，功能的实现留待给实现这一接口的各个类来完成。抽象类一般作为公共的父类为子类的扩展提供基础，这里的扩展包括了属性上和行为上的。而接口一般来说不考虑属性，只考虑方法，使得子类可以自由的填补或者扩展接口所定义的方法。抽象类表示的是"is-a"关系，接口着重表示的是"can-do"关系。 (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("Hi there"); } public void print() { System.out.println("Hello"); } 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("乖儿子",1.78f,61f, "篮球"); son.showInfo(); sogsong(); } } abstract class Father { float high,weight; protected String name; Father(String name,float high,float weight) { this.name = name; this.high=high; thight=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(){ Syste.println(name+"is singging loudly!"); } void showInfo() { System.ointln("姓名："+name+";身高："+high+";体重："+weight+";爱好："+specialty); } } 习题6 [解答] 1．Java中提供了名为（）的包装类来包装原始字符串类型。 A．Integer B．Char C．Double D．String 答案：D 2．javg包的（）方法比较两个对象是否相等，相等返回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 jail.*; public class Test { public static void main(String[] args) { LinkedList list=new LinkedList(); list.add("A"); lid(2,"B"); 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)); Systntln(StrinueOf(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.ointln(obj[2]); } public static void amethod(){ int K[ ] = new int[4]; Systntln(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="It is"; String str2="It is"; //比较字符串 Syste.println("str1==str2的结果："+(str1==str2)); System.out.println("stuals(str2)的结果："+str1.equals(str2)); //连接字符串 String str3=str1.concat("a book"); Syste.println("连接后的字符串为："+str3); //替换字符 String str4=str3.replace('i','m'); Systntln("替换后的字符串为："+str4); } } 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=ca(Calendar.YEAR)+"年" +(ct(Calendar.MONTH)+1)+"月" +ca(Calendar.DATE)+"日"; System.out.println("10天后的日期为："+strDate); } } 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(); stac("1"); stack.add("2"); stad("3"); Syste.println(stack.get()); stack.delete(); System.out.println(stat()); } } 14．编写程序，计算任意两个日期之间间隔的天数。 参考代码： import java.util.Calendar; public class Ex14 { public static void main(String[] args) { Calendar c1 = CalendaInstance(); c1.set(2010, 7, 1); Calendar c2 = Calendar.getInstance(); long ca1 = c1.getTimeInMillis(); long ca2 = cTimeInMillis(); // 计算天数 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("张三",90); map.put("李四",83); System.ointln("修改前的成绩："); Syste.println(map); map.put("李四",100); System.out.println("修改后的成绩："); Systntln(map); } } 16．编写一个程序，用parseInt方法将字符串200由十六进制转换为十进制的int型数据，用valueOf方法将字符串123456转换为float型数据。 参考代码： public class Ex16 { public static void main(String[] args) { String str1="200"; System.ointln(Integer.parseInt(str1,16)); String str2="123456"; Syste.println(Float.parseFloat(str2)); } } 17．编写程序，将long型数据987654转换为字符串，将十进制数365转换为十六进制数表示的字符串。 参考代码： public class Ex17 { public static void main(String[] args) { long num=987654L; int i=365; Syste.println("Long类型转换为String："+String.valueOf(num)); String HexI=DtoX(i); Syste.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%16); 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="A"; break; case 11: x="B"; break; case 12: x="C"; break; case 13: x="D"; break; case 14: x="E"; break; case 15: x="F"; 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.ointln("请依次输入重量、包数、价格，并以-分隔："); String strIn=scan.nextLine(); Scanner sc=new Scanner(strIn); sc.useDelimiter("-"); //设置分隔符 int num=xtInt(); int bag=stInt(); float price=sc.nextFloat(); double total=price*num*bag; Syste.println("销售总额为："+total); } } 19．编写一个泛型方法，能够返回一个int类型数组的最大值和最小值、String类型数组的最大值和最小值（按字典排序）。 参考代码： class Pair private T min; private T max; public Pair() { min = null; max = null; } public Pair(T min, T max) { this.min = min; thx = 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 if (a == null || a.length == 0) { return null; } 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<Integer> p1=ArrayAlg.minmax(arrI); System.ointln("整型数组的最小值："+p1.getMin().intValue()); Syste.println("整型数组的最大值："+p1.getMax().intValue()); //测试字符串数组 String[ ] words ={"able","word","excel","course","java","c#"}; Pair<String> p2=ArrayAlg.minmax(words); System.ointln("字符串数组的最小值："+pMin()); Syste.println("字符串数组的最大值："+p2.getMax()); } } 20．编写一个泛型方法，接受对象数组和集合作为参数，将数组中的对象加入集合中。并编写代码测试该方法。 参考代码： import java.util.*; public class Ex20 { static for (T o : a){ d(o); } } public static void main(String[] args) { Integer[] ia = new Integer[100]; Collection 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+":"+phone; } } public class Ex21 { public static void main(String[] args) { Student st1=new Student("John","23214"); Student st2=new Student("Alice","4563"); List lid(st1);lis(st2); for(int i=0;i System.out.println(lis(i)); } } 22．设计一个程序，基于泛型Map实现10个英文单词的汉语翻译，即通过单词得到它的中文含义。 参考代码： import java.util.*; public class Ex22 { public static void main(String[] args) { String[] eng={"Apple","Orange","Green"}; String[] chs={"苹果","桔子","绿色"}; Map for(int i=0;i map.put(eng[i],chs[i]); String test="Orange"; Systntln(test+"翻译："+map.get(test)); } } 习题7 [解答] 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{ Syste.print("try，"); return; } catch(Exception e){ System.out.print("catch，"); } finally { System.out.print("finally"); } 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) { intStackTrace(); } } } 11．设计一个Java程序，自定义异常类，从键盘输入一个字符串，如果该字符串值为“abc”，则抛出异常信息，如果从键盘输入的是其他字符串，则不抛出异常。 参考代码： import java.util.Scanner; class MyException extends Exception{ private String errorMsg; //getter和setter方法 public MyException(String errorMsg){ thiorMsg=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=scatLine(); try { if(strIn.equals("abc")) throw new MyException("输入的字符串不正确！"); } catch (MyException e) { Systntln(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.ointln("第一个数格式不对"); num1=0; } try { num2=xtInt(); } catch (InputMismatchException e) { Systntln("第二个数格式不对"); num2=0; } Syste.println("num1-num2="+(num1-num2)); } } 13．自定义异常类，在进行减法运算时，当第一个数大于第二个数时，抛出“被减数不能小于减数”，并编写程序进行测试。 参考代码： import java.util.Scanner; //MyException类的定义（同第11题） public class Ex13 { public static void main(String[] args) { int num1,num2; Scanner scan=new Scanner(Syst); num1=scan.nextInt(); num2=scxtInt(); try { if(num1 throw new MyException("被减数不能小于减数"); } catch (MyException e) { Syste.println(e); } } } ******************************************************* ******************************************************* ******************************************************* 2011年南通大学全国软件大赛选拔赛试卷 提交时，请将各个原程序存放在以 学号+姓名 命名的文件夹内，提交该文件夹。 1. （10分）从键盘输入10个数，对这10个数进行升序排序，输出排序前、后的数列。 2、（10分）按5 度的增量逐行输出一个从摄氏温度c（范围：-20℃-50℃）到华氏温度h的转换表。 （摄氏温度c到华氏温度h的转换关系是：h=c*9/5+32） 3、（10分）从键盘输入两个年份（如：1950，2050），输出该年份区间的所有闰年。闰年的条件是符合下面二者之一：（1）能被4 整除，但不能被100 整除； （2）能被4 整除，又能被100 整除。 4、（20分）编写程序，输入n值，打印下列形状的金字塔，其中n代表金字塔的层数。 1 1 2 1 1 2 3 2 1 1 2 3 4 3 2 1 5、（25分）哥德巴赫猜想的一般提法是：每个大于等于6的偶数，都可表示为两个奇素数之和；每个大于等于9的奇数，都可表示为三个奇素数之和。其实，后一个命题就是前一个命题的推论。哥德巴赫猜想到目前，还没人能推翻他的正确性。但又没能从数学上得到严密的证明。所以，不能称定理，只能叫猜想。 请编写程序，验证200以内的数符合哥德巴赫猜想。 6、（25分）ｎ×ｎ的螺旋方阵，当n=5和n= 3时分别是如下的形式 1 2 3 4 5 1 2 3 16 17 18 19 6 8 9 4（ｎ＝3时） 15 24 25 20 7（ｎ＝5时） 7 6 5 14 23 22 21 8 13 12 11 10 9 请编写程序，对于任意的输入ｎ，输出按照上面规律所获得的ｎ×ｎ的螺旋方阵。 3、编写显示当前时间和日期的程序 序功能：程该程序通过使用一个自定义类Time，实现显示当前日期和时间的功能。 程序代码如下： import java.util.Calendar; class Time { private Calendar t; private int y, m, d, hh, mm, ss; Time (){ t=CalendtInstance(); y=t.get(R); m=(NTH)+1; d=t.get(E); hh=t(t.HOUR_OF_DAY); mm=(NUTE); ss=t.get(OND); } public String getDate() { return y+" 年"+m+"月"+d+"日"; } public String getTime() { return hh+" 时"+mm+"分"+ss+"秒"; } } public class EXP3_3{ public static void main(String[] args){ Time t=new Time(); Systntln("当前日期："+t.getDate()); Systntln("当前时间："+t.getTime()); } } 编写一个调用对象方法的程序 (1) 程序功能：通过调用对象的方法在方法调用后修改了成员变量的值。 (2) 程序源代码如下： class EXP3_6 { public static void main(String[] args) { Power p=new Power(); 2(10,10); System.out.println("方法调用后 x="+p.x+", y="+p.y); } } class Power{ int x=10, y=10; void ff2(int passX, int passY) { System.out.println("初始时 x="+x+", y="+y); x=passX*passX; y=passY*passY; Systntln("方法调用中 x="+x+", y="+y); } }
版权声明：本文标题：JavaEE基础教程(清华大学出版史胜辉)第1-7章答案 内容由网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：http://www.freenas.com.cn/free/1703326843h447041.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论