第一篇：川大网教《面向对象程序设计》第一次作业答案(96分)
《面向对象程序设计》第一次作业答案
你的得分： 96.0
完成日期：2013年09月02日 15点40分
每道小题括号里的答案是您最高分那次所选的答案，标准答案将在本次作业结束(即2013年09月12日)后显示在题目旁边。
一、单项选择题。本大题共30个小题，每小题 2.0 分，共60.0分。在每小题给出的选项中，只有一项是符合题目要求的。1.C＋＋函数的声明和定义可以分开，函数声明不需要（D）。
A.返回类型 B.函数名 C.参数表 D.2.函数体
函数的形参是(B)。
A.全局变量 B.C.静态变量 D.局部变量
3.部变量
数组名表示的是数组的（C）。
A.类型 B.用途 C.地址 D.长度
4.如果短整型的长度是2字节，有一个短整型指针p的值是0xFFED1200，那么p+1的值为（B）。
A.0xFFED1201 B.0xFFED1202 C.0xFFED1203 D.5.0xFFED1204 private访问属性限制对象的成员可以在(A)中访问。
A.本类的成员函数 B.main函数 C.父类的成员函数 D.子类的成员函数
6.如果定义了一个类myclass，则为myclass类对象以成员函数形式重载后++运算符的声明应该为（C）。
A.myclass operator++();B.myclass& operator++();C.myclass operator++(int);D.7.myclass& operator++(int);如果有如下定义： const char* str = “OK”;那么，sizeof（str）的值应该是（D）
A.B.C.D.8.4 父类和子类各自定义一个成员函数，函数名相同，参数表不同，那么（C）。A.在子类中这两个函数构成重载关系 B.子类不会继承父类的这个函数 C.D.子类中的函数会覆盖父类中的函数
编译时会发生错误
9.如果myclass类定义了拷贝构造函数和一个整型参数的构造函数，还重载了赋值运算符，那么语句myclass obj = 100；会（B）。
A.调用拷贝构造函数
B.C.D.调用赋值运算符
调用整型参数的构造函数
引起编译错误
10.抽象类指的是（D）。
A.B.只有成员函数没有数据成员的类 C.D.有虚函数的类
没有任何成员的类
有纯虚函数的类
11.多重继承时，如果派生类的两个父类有一个共同的虚基类，那么虚基类的初始化参数由（C）的构造函数来传递。
A.第一个父类 B.第二个父类 C.派生类 D.以上都不是 12.多态性是通过（C）实现的。
A.构造函数 B.析构函数 C.虚函数 D.函数重载
13.十进制数127转换成二进制数是（A）
A.11111111 B.01111111 C.10000000 D.11111110 14.执行语句
char ch[] = “Hello”;char * p = &ch[0];cout<<*p 结果是输出（C）。
A.一个地址 B.H C.Hello D.乱码
15.以下不能正确进行字符串赋初值的语句是（A）
A.char str[5]=“good!”;B.char str[]=“good!”;C.char *str=“good!”;D.char str[5]={‘g',‘o',‘o',‘d'};
16.用cin为整型变量输入数据时，如果从键盘输入的不是数字，输入后整型变量中的结果会是：（D）
A.0 B.负数 C.正数 D.不确定
17.使用流控制符（C）需要头文件。
A.endl B.hex C.setw D.left 18.C＋＋泛型编程通过（B）实现。
A.void B.template C.NULL D.typedef 19.C＋＋异常处理机制中没有（D）。
A.try B.throw C.catch D.finally 20.要打开一个文件并从中读取数据，应该使用（C）类的对象。
A.istream B.ostream C.ifstream D.ofstream 21.判断一个ofstream类对象file打开文件是否失败，应该判断（D）。
A.B.C.D.feof成员函数的返回值
open成员函数的返回值
创建文件流对象时是否抛出异常
!file 是否为真
22.链表的基本单元是（B）。
A.节点 B.头指针 C.尾指针 D.数据域
23.二叉查找树按（C）遍历时访问到节点的数据是排好序的。
A.前序 B.中序 C.后序
D.层次
24.二进制数00001001跟01000011异或的结果为（C）。
A.01001011 B.00000001 C.01001010 D.01001100 25.若有定义：int aa[ 8]。则以下表达式中不能代表数组元aa[1]的地址的是（C）
A.&aa[0]+1 B.&aa[1] C.&aa[0]++ D.aa+1 26.一个类如果没有定义任何函数，编译器不会自动为这个类产生（C）。
A.拷贝构造函数 B.无参构造函数 C.输出流运算符 D.赋值运算符
27.如果在try块中用
throw “error”；
语句抛出一个异常，则参数类型是（B）的catch块能够捕获这个异常。
A.char * B.const char * C.Char D.const char
28.队列的最大特征是（A）。
A.先进先出 B.C.自动排序 D.大数优先
29.下列排序算法中，平均效率最低的排序算法是（B）。
A.插入法 B.C.冒泡法
后进先出 选择法 D.快速排序法
30.下面不支持下标操作的容器是（C）。
A.vector B.deque C.list D.map
二、多项选择题。本大题共5个小题，每小题 4.0 分，共20.0分。在每小题给出的选项中，有一项或多项是符合题目要求的。1.for语句的格式为for（表达式1；表达式2；表达式3），其中可以省略的是（BCD）。
A.两个分号 B.表达式1 C.表达式2 D.2.表达式3 C＋＋中变量要求（ABD）。
A.有明确的类型 B.先声明后使用 C.名字中不能使用下划线
D.3.严格区分大小写
流程控制语句有（ABC）几种。
A.条件语句 B.C.D.表达式语句
分支语句
循环语句
4.面向对象的编程方法的主要特征包括（ABC）。
A.封装 B.继承 C.多态 D.5.消息
类成员的访问属性可以是（ABC）。
A.public B.protected C.private D.default
三、判断题。本大题共5个小题，每小题 4.0 分，共20.0分。1.正确
2.正确
3.正确
4.错误 错误 错误 _int可以定义为用户标识符。(正确)结构化程序设计的基本方法是递归法。(错)C++语言的跳转语句中，break语句只应用于循环体中。（错）
C++语言是从早期的C语言逐渐发展演变而来的，与C语言相比，它在求解问题方法上进行的最大改进是面向过程。（错）
正确 错误
5.重载函数形参个数可以不同。(正确)正确
错误
第二篇：川大网教2018《统计学》第一次作业答案
川大网教2018《统计学》第一次作业答案
一、单项选择题。本大题共10个小题，每小题 4.0 分，共40.0分。在每小题给出的选项中，只有一项是符合题目要求的。
1.进行全市百货商店售货员工作情况调查时，总体单位是（）。
A.每个百货商店
B.百货商店的每个售货员 C.所有的百货商店
D.百货商店的所有售货员 2.对全市的科技人员进行调查，每一位科技人员是总体单位，则科技人员的职称是（）。A.质量指标
B.数量指标 C.数量标志 D.品质标志
3.全国工业企业生产设备普查，每个工业企业是（）。A.调查对象 B.调查单位
C.填报单位
D.调查单位,也是填报单位
4.某些产品在检验和测量时常有破坏性，一般宜采用（）。
A.全面调查 B.典型调查 C.重点调查 D.抽样调查
5.对城镇居民的生活水平调查是（）。
A.普查
B.抽样调查 C.重点调查 D.典型调查
6.某连续变量数列,其末组为开口组,下限为500,又知其邻组的组距为40,则末组的组中值为()。A.520 B.510 C.500 D.480
7.说明统计表名称的词句，在统计表中称为（）。
A.B.C.D.横行标题 纵栏标题
主词 总标题 8.下列指标中（）中是总量指标。
A.职工平均工资 B.国内生产总值 C.出勤率 D.人口密度
9.某企业计划产值比去年提高10%,实际提高15%,则其计划完成程度为()。A.115% B.120% C.104.5% D.110.5%
10.工人出勤率指标是（）。
A.B.C.D.比较相对指标
结构相对指标 强度相对指标
计划完成程度相对指标
二、多项选择题。本大题共5个小题，每小题 5.0 分，共25.0分。在每小题给出的选项中，有一项或多项是符合题目要求的。
1.某年级共有学生102人，其中共青团员100人，女生占71%，某课程考试平均成绩为80分，某同学考分最高为96分。下列说法正确的是（）。A.其中共青团员100人是质量指标 B.女生占71%是品质标志
C.某课程考试平均成绩80分是质量指标
D.每名同学是总体单位
E.某同学考分96分是变量值 2.普查属于（）.A.一次性调查 B.经常性调查 C.全面性调查 D.非全面调查
E.专门调查
3.下列指标中属于时期指标的有（）
A.工业增加值 B.商品零售额 C.房屋竣工面积 D.工资总额 E.出生人口数
4.已知一个时期数列的项数，平均增长量和平均增长速度，便可得出（）
A.最初水平与任一时期的水平之比 B.各期发展水平C.最初水平D.最末水平
E.各期的定基发展速度
5.相关关系具有的特点是现象之间()。
A.B.C.D.E.确实存在数量上的依存关系 数量上的关系是确定的 存在质的联系 存在函数关系
数量上的依存关系不是确定的
三、判断题。本大题共10个小题，每小题 4.0 分，共40.0分。1.2.3.4.5.6.7.8.9.数量指标是由数量标志值汇总来的，质量指标是由品质标志值汇总来的。综合为统计指标的前提是总体的同质性。
进行全面调查，只会产生登记性误差，没有代表性误差。
重点调查和抽样调查都是非全面调查，其调查结果都可以用于推算总体指标。通过统计分组，使同一组内的各单位性质相同，不同组的单位性质相异。相对指标实际上是两个有联系的指标数值之比，所以它们之间必须是同值的。比较两总体的平均数的代表性，标准差系数较小的总体，其平均数代表性亦小。平均数反映了总体分布的集中趋势，它是总体分布的重要特征值。
几何平均数是计算平均比率和平均速度的比较适用的一种方法，符合人们的认识实际。
10.各变量值的次数相同时，众数不存在。
第三篇：面向对象程序设计教程 答案
面向对象程序设计教程（C++语言描述）题解与课程设计指导
第1章
面向对象程序设计概论
一、名词解释 抽象封装消息 【问题解答】
面向对象方法中的抽象是指对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。
面向对象方法中的封装就是把抽象出来的对象的属性和行为结合成一个独立的单位，并尽可能隐蔽对象的内部细节。
消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对象要求另一个对象实施某种操作的一个请求。
二、填空题（1）目前有面向过程的结构化程序设计方法和面向对象的程序设计方法两种重要的程序设计方法。
（2）结构化程序设计方法中的模块由顺序、选择和循环3种基本结构组成。（3）在结构化程序设计方法中，程序可表示为程序=数据结构+算法； 而面向对象的程序设计方法，程序可表示为程序=对象+消息。（4）结构化程序设计方法中的基本模块是过程； 而面向对象程序设计方法中的基本模块是类。
（5）面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。
三、选择题（至少选一个，可以多选）
（1）面向对象程序设计着重于（B）的设计。A.对象B.类C.算法D.数据（2）面向对象程序设计中，把对象的属性和行为组织在同一个模块内的机制叫做（C）。
A.抽象 B.继承 C.封装 D.多态
（3）在面向对象程序设计中，类通过（D）与外界发生关系。A.对象 B.类 C.消息 D.接口
（4）面向对象程序设计中，对象与对象之间的通信机制是（C）。A.对象 B.类 C.消息 D.接口
（5）关于C++与C语言的关系的描述中，（D）是错误的。A.C语言是C++的一个子集 B.C语言与C++是兼容的
C.C++对C语言进行了一些改进 D.C++和C语言都是面向对象的
【结果分析】
C语言是面向过程的。C++语言是一种经过改进的更为优化的C语言，是一种混合型语言，既面向过程也面向对象。
（6）面向对象的程序设计将数据结构与（A）放在一起，作为一个相互依存、不可分割的整体来处理。A.算法 B.信息 C.数据隐藏 D.数据抽象（7）下面（A）不是面向对象系统所包含的要素。
A.重载 B.对象 C.类 D.继承 【结果分析】
面向对象=对象+类+继承+消息+多态（8）下面说法正确的是（BC）。
A.将数据结构和算法置于同一个函数内，即为数据封装 B.一个类通过继承可以获得另一个类的特性
C.面向对象要求程序员集中于事物的本质特征，用抽象的观点看待程序 D.同一消息为不同的对象接受时，产生的行为是一样的，这称为一致性 【结果分析】
面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。将数据结构和算法置于同一个类内，即为数据封装。同一消息为不同的对象接受时，产生的行为可能是不一样的，这称为多态性。（9）下面说法正确的是（AD）。
A.对象是计算机内存中的一块区域，它可以存放代码和数据 B.对象实际是功能相对独立的一段程序
C.各个对象间的数据可以共享是对象的一大优点
D.在面向对象的程序中，对象之间只能通过消息相互通信 【结果分析】
对象是计算机内存中的一块区域。在对象中，不但存有数据，而且存有代码，使得每个对象在功能上相互之间保持相对独立。对象之间存在各种联系，但它们之间只能通过消息进行通信。
四、判断题
（1）在高级程序设计语言中，一般用类来实现对象，类是具有相同属性和行为的一组对象的集合，它是创建对象的模板。（√）
（2）C++语言只支持面向对象技术的抽象性、封装性、继承性等特性，而不支持多态性。（×）【结果分析】
C++语言不仅支持面向对象技术的抽象性、封装性、继承性等特性，而且支持多态性。
（3）面向对象程序设计中的消息应该包含“如何做”的信息。（×）【结果分析】
消息是面向对象程序设计用来描述对象之间通信的机制。向对象“发送消息”只需告诉对象做什么，对象根据这个消息决定如何做。（4）一个消息只能产生特定的响应效果。（×）【结果分析】
当一个对象发出消息时，由于接收对象的类型可能不同，所以，它们可能做出不同的反应。这样，一个消息可以产生不同的响应效果，这种现象叫做多态。（5）类的设计和类的继承机制实现了软件模块的可重用性。（√）（6）C++语言和Java语言均不是一个纯正的面向对象的程序设计的语言。（×）【结果分析】
Java语言是一个纯正的面向对象的程序设计语言。（7）学习C++语言是学习面向对象的程序设计方法的唯一途径。（×）【结果分析】
程序设计方法是独立于具体程序设计语言的一种技术，学习C++语言是学习面向对象程序设计方法的重要途径之一。
（8）在C++语言中，类是支持数据封装的工具。（√）
五、简答题
（1）什么是结构化程序设计方法？它有哪些优点和缺点？ 【问题解答】
结构化程序设计方法着眼于系统要实现的功能，从系统的输入输出出发，分析系统要做哪些事情，进而考虑如何做这些事情，自顶向下地对系统的功能进行分解，来建立系统的功能结构和相应的程序模块结构，有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护。随着程序规模与复杂性的增长，这种面向过程的结构化程序设计方法存在明显的不足之处。首先是数据安全性问题。由于数据被每个模块所共用，因此是不安全的，一旦出错，很难查明原因。其次是可维护性及可重用性差。它把数据结构和算法分离为相互独立的实体，一旦数据结构需要改变时，常常要涉及整个程序，修改工作量极大并容易产生新的错误。每一种相对于老问题的新方法都要带来额外的开销。另外，图形用户界面的应用程序，很难用过程来描述和实现，开发和维护也都很困难。
（2）什么是面向对象程序设计方法？它有哪些优点？ 【问题解答】
面向对象的程序设计方法中，将程序设计为一组相互协作的对象而不是一组相互协作的函数。在程序中，属性用数据表示，用来描述对象静态特征； 行为用程序代码实现，用来描述对象动态特征。可见，在面向对象的程序设计方法中，对象是数据结构和算法的封装体。对象之间存在各种联系，它们之间通过消息进行通信。程序可表示为：
程序=对象+消息
在面向对象程序设计中应着重于类的设计。类正是面向对象语言的基本程序模块，通过类的设计来完成实体的建模任务。类通过一个简单的外部接口与外界发生关系。一个类中的操作不会处理到另一个类中的数据，这样程序模块的独立性、数据的安全性就有了良好的保障。程序的执行取决于事件发生的顺序，由顺序产生的消息来驱动程序的执行。不必预先确定消息产生的顺序，更符合客观世界的实际。并且面向对象程序设计方法提供了软件重用、解决大问题和复杂问题的有效途径，具有抽象性、封装性、继承性和多态性等特点。
（3）结构化程序设计方法与面向对象程序设计方法在对待数据结构和算法关系上有 什么不同？ 【问题解答】
结构化程序设计方法中，把数据结构和算法分离为相互独立的实体； 而在面向对象程序设计中，数据结构和算法封装在一起，结合成一个独立的单位，即对象，并尽可能隐蔽对象的内部细节。对象的私有属性只能由这个对象的行为来读取和修改，与外部的联系通过公有行为充当外部接口。第 2 章
从C到C++
面向对象程序设计教程（C++语言描述）题解与课程设计指导
第2章 从C到 C++
一、名词解释
引用内联函数重载函数 【问题解答】
所谓引用就是给对象取一个别名，使用该别名可以存取该对象。换句话说是使新对象和原对象共用一个地址。
内联函数是使用inline关键字声明的函数。
重载函数指在同一个作用域内名字相同而参数不同的函数。重载函数通常用来对具有相似行为而数据类型或数据个数不同的操作提供—个通用的名称。
二、填空题
（1）一般情况下，用C++语言编写的程序是由函数加上类组成的。（2）C++有两种注释符号，一种是//，另一种是 /*„„*/。
（3）使用C++风格的输入输出，在程序中必须包含头文件“iostream”。（4）cin是预定义的标准输入流对象，>>是输入操作符，也称提取运算符。（5）cout是预定义的标准输出流对象，<<是输出操作符，也称插入运算符。（6）指针的值是它所指向那个对象的地址值。指针的类型是它所指向对象的类型。指针的内容便是它所指向对象的值。
（7）C++使用运算符&来定义一个引用，对引用的存取都是对它所引用的对象的存取。（8）当一个函数调用出现在函数定义之前时，必须先用函数原型对函数进行声明。
（9）C++有值传递和引用传递两种参数传递机制。（10）使用关键字inline声明的函数称为内联函数。（11）运算符new用于进行动态内存分配，运算符delete用于释放动态分配的内存。
（12）下面程序的输出结果为x=10，y=10；
x=100，y=100。
#include
using namespace std;
int main（）
{
int x=10，&y=x;
cout<<“x=”< int *p=&y; *p=100; cout<<“x=”< return 0; } 三、选择题（至少选一个，可以多选） （1）在整型指针变量p2、p3的定义中，错误的是（A）。A.int p1，*p2，p3;B.int*p2，p1，*p3;C.int p1，*p2=&p1，*p3;D.int*p2，p1，*p3=&p1;【结果分析】 指针定义的具体格式如下所示： <类型> *<指针名1>，*<指针名2>，„; （2）若有定义“double xx=3.14，*pp=&xx； ”，则*pp等价于（A.&xxB.*xxC.3.14D.xx 【结果分析】 pp指向xx所在的内存单元，这样*pp和xx等价。（3）下面对引用的描述中（C）是错误的。A.引用是某个变量或对象的别名 B.建立引用时，要对它初始化）。C C.对引用初始化可以使用任意类型的变量 D.引用与其代表的对象具有相同的地址 【结果分析】 所谓引用就是给对象取一个别名，使用该别名可以存取该对象，所以对引用初始化必须使用同类型的变量。 （4）函数没有返回值的时候，应该选择（A）的函数类型。A.void B.int C.不确定 D.float（5）在函数的定义格式中，下面各组成部分中，（D）是可以省略的。A.函数名 B.函数体 C.返回值类型 D.函数参数 【结果分析】 函数的定义可以缺省形式参数，此时称为无参函数。 （6）对重载的函数来说，下面叙述不正确的是（D）。A.参数的类型不同 B.参数的顺序不同 C.参数的个数不同 D.参数的个数、类型、顺序都相同，但函数的返回值类型不同 【结果分析】 对重载的函数来说，编译系统将根据函数参数的类型和个数来判断使用哪一个函数，所以重载函数参数的个数、类型、顺序不能都相同。 （7）下列有关设置函数参数默认值的描述中，（D）是正确的。A.对设置函数参数默认值的顺序没有任何规定 B.函数具有一个参数时不能设置默认值 C.默认参数要设置在函数的原型中，而不能设置在函数的定义语句中 D.设置默认参数可使用表达式，但表达式中不可用局部变量 【结果分析】 在C++中，在函数原型中可以为一个或多个参数指定默认值。对函数参数设置默认值要注意以下几点。◆若没有声明函数原型，参数的默认值可在函数定义的头部进行设置，否则必须在函数原型中进行设置。 ◆在一个指定了默认值的参数右边不能出现没有指定默认值的参数。◆设置默认参数可使用表达式，但表达式中不可用局部变量。（8）下面说法正确的是（BC）。A.所有的函数都可以说明为内联函数 B.具有循环语句、switch语句的函数不能说明为内联函数 C.使用内联函数，可以加快程序执行的速度，但会增加程序代码的大小 D.使用内联函数，可以减小程序代码大小，但使程序执行的速度减慢 【结果分析】 内联函数主要是解决程序的运行效率问题。在程序编译时，编译系统将程序中出现内联函数调用的地方用函数体进行替换，进而减少了程序运行的时间，但会增加程序代码的大小。它是以空间换取时间，因此内联函数适用于功能不太复杂，但要求被频繁调用的函数。 （9）一个函数功能不太复杂，但要求被频繁调用，应选用（A）。A.内联函数 B.重载函数 C.递归函数 D.嵌套函数（10）C++对C语言做了很多改进，下列描述中使得C语言发生了质变，即从面向过程变成面向对象的是（D）。A.增加了一些新的运算符 B.允许函数重载，并允许设置默认参数 C.规定函数说明必须用原型 D.引进了类和对象的概念 【结果分析】 面向对象=对象+类+继承+消息+多态 四、判断题 （1）C++程序中，不得使用没有定义或说明的变量。（√）（2）使用const说明常量时，可以不必指出类型。（×）【结果分析】 如果用const 定义的是一个整型常量，则类型说明符int可以省略。（3）引用被创建时可以用任意变量进行初始化。（×）【结果分析】 对引用初始化必须使用同类型的变量。 （4）一个返回引用的调用函数可以作为左值。（√）（5）函数可以没有参数，也可以没有返回值。（√）（6）没有参数的两个函数是不能重载的。（√）（7）函数可设置默认参数，但不允许将一个函数的所有参数都设置为默认参数。（×） 【结果分析】 函数可设置默认参数，且允许将一个函数的所有参数都设置为默认参数。（8）运算符new分配的空间由运算符delete释放。（√） 五、简答题 （1）名字空间的用途是什么？ 【问题解答】 名字空间用来防止命名的冲突。（2）引用有何用处？ 【问题解答】 除了独立引用外，在C++程序中，引用的主要用途是用作函数参数和函数的返回值。 （3）比较值调用和引用调用的相同点与不同点。【问题解答】 在值调用机制中，作为实参的表达式的值被复制到由对应的形参名所标识的一个对象中，作为形参的初始值。函数体对形参的访问、修改都是在这个标识对象上操作的，与实参无关，即数据的传递是单向的。 使用引用作函数的形参时，调用函数的实参要用变量名。实参传递给形参，相当于在被调用函数中使用了实参的别名。于是，在被调用函数中对形参的操作实质是对实参的直接操作，即数据的传递是双向的。（4）内联函数有什么作用？它有哪些特点？ 【问题解答】 内联函数是使用inline关键字声明的函数。在程序编译时，编译系统将程序中出现内联函数调用的地方用函数体进行替换，进而减少了程序运行的时间。使用内联函数应注意以下几点。◆递归函数不能定义为内联函数。 ◆内联函数一般适合于不含有switch和while等复杂的结构且只有1~5条语句的小函数，否则编译系统将该函数视为普通函数。 ◆内联函数只能先定义后使用，否则编译系统也将该函数视为普通函数。◆对内联函数也不能进行异常接口声明。（5）函数原型中的参数名与函数定义中的参数名以及函数调用中的参数名必须一致吗？ 【问题解答】 不必一致。所有的参数是根据位置和类型而不是名字来区分的。（6）重载函数时通过什么来区分？ 【问题解答】 编译系统将根据函数参数的类型和个数来判断使用哪一个函数。 六、程序分析题（写出程序的输出结果，并分析结果） #include using namespace std; int main（） { int num=50; int& ref=num; ref=ref+10; cout<<“num=”< num=num+40; cout<<“ref=”< return 0;} 【输出结果】 num=60 ref=100 【问题分析】 本题主要考查引用的含义。【结果分析】 程序首先定义一个int类型的对象num，并给它赋初始值50。然后又定义了一个int类型的引用ref，并将它和num相联系。这样，无论是对num还是对ref进行操作，实际上都是对那个一开始放着50的物理单元的内容进行操作。 七、程序设计题 写出一个完整的C++程序，使用系统函数pow（x，y）计算xy的值，注意包含头文件cmath。【问题分析】 本题主要考查简单的输入输出和标准库函数的调用方法。【解题思路】 ① 由于要用到系统函数pow（x，y），所以要包含头文件cmath。 ② 要计算xy的值，首先必须知道x和y的值。为了程序的通用性，最好通过交互的方式输入x和y的值。【参考程序】 // xt2_1.cpp #include #include using namespace std; int main（） { float x，y; cout<<“please input 2 floats to x，y:”; cin>>x>>y; float z=pow（x，y）; cout<<“pow（”< return 0;} 【输出结果】 please input 2 floats to x，y:3.1 2 pow（3.1，2）=9.61 第 3 章 类与对象 面向对象程序设计教程（C++语言描述）题解与课程设计指导 第3章 类 与 对 象 一、填空题（1）类定义中关键字private、public和protected以后的成员的访问权限分别是私有、公有和保护。如果没有使用关键字，则所有成员默认定义为private权限。具有public访问权限的数据成员才能被不属于该类的函数所直接访问。（2）定义成员函数时，运算符“∷”是作用域运算符，“MyClass∷”用于表明其后的成员函数是在“MyClass类”中说明的。 （3）在程序运行时，通过为对象分配内存来创建对象。在创建对象时，使用类作为样板，故称对象为类的实例。 （4）假定Dc是一个类，则执行“Dc a［10］，b（2）”语句时，系统自动调用该类构造函数的次数为11。【结果分析】 创建10个数组元素需调用构造函数10次，创建对象b需调用构造函数1次，所以系统自动调用该类构造函数的总次数为11。 （5）对于任意一个类，析构函数的个数最多为1个。 （6）delete运算符通常用于实现释放该类对象中指针成员所指向的动态存储空间的任务。（7）C++程序的内存格局通常分为4个区： 数据区、代码区、栈区和堆区。（8）数据定义为全局变量，破坏了数据的 封装性； 较好的解决办法是将所要共享的数据定义为类的 静态成员。 （9）静态数据成员和静态成员函数可由 任意访问权限许可的函数访问。（10）友元函数和 友元类统称为友元。（11）友元的正确使用能提高程序的效率，但破坏了类的封装性和数据的隐蔽性。（12）若需要把一个类A定义为一个类B的友元类，则应在类B的定义中加入一条语句： friend class A。 二、选择题（至少选一个，可以多选）（1）以下不属于类访问权限的是（B）。A.public B.staticC.protectedD.private 【结果分析】 类的访问权限有public、protected 和private。（2）有关类的说法不正确的是（BC）。A.类是一种用户自定义的数据类型 B.只有类的成员函数才能访问类的私有数据成员 C.在类中，如不做权限说明，所有的数据成员都是公有的 D.在类中，如不做权限说明，所有的数据成员都是私有的 【结果分析】 类是一种用户自定义的数据类型，类中成员均具有一种访问权限。关键字public、protected 和private以后的成员的访问权限分别是公有、保护和私有的，所有成员默认定义为private的。 私有成员是被隐藏的数据，只有该类的成员函数或友元函数才可以访问它。（3）在类定义的外部，可以被任意函数访问的成员有（C）。A.所有类成员 B.private或protected的类成员 C.public的类成员 D.public或private的类成员 【结果分析】 类是一种用户自定义的数据类型，类中成员均具有一种访问权限。公有成员定义了类的外部接口。私有成员是被隐藏的数据，只有该类的成员函数或友元函数才可以引用它。保护成员具有公有成员和私有成员的双重性质，可以被该类或派生类的成员函数或友元函数引用。可见在类定义的外部，可以被任意函数访问的成员是public的类成员。 （4）关于类和对象的说法（C）是错误的。A.对象是类的一个实例 B.任何一个对象只能属于一个具体的类 C.一个类只能有一个对象 D.类与对象的关系和数据类型与变量的关系相似 【结果分析】 C++语言的类就是一种用户自己定义的数据类型，类和对象的关系就相当于基本数据类型与它的变量的关系，所以任何一个对象只能属于一个具体的类，但一个类可以有多个对象。（5）设MClass是一个类，dd是它的一个对象，pp是指向dd的指针，cc是dd的引用，则对成员的访问，对象dd可以通过（B）进行，指针pp可以通过（D）进行，引用cc可以通过（B）进行。 A.∷ B..C.& D.->（6）关于成员函数的说法中不正确的是（C）。A.成员函数可以无返回值 B.成员函数可以重载 C.成员函数一定是内联函数 D.成员函数可以设定参数的默认值 【结果分析】 与普通函数不同的是，成员函数是属于某个类的。成员函数的实现，可以放在类体内，也可以放在类体外。在类体外实现的成员函数不再是内联函数。（7）下面对构造函数的不正确描述是（B）。A.系统可以提供默认的构造函数 B.构造函数可以有参数，所以也可以有返回值 C.构造函数可以重载 D.构造函数可以设置默认参数 【结果分析】 构造函数不能指定返回类型，即使是void类型也不可以，当然不可能有返回值。（8）假定A是一个类，那么执行语句“A a，b（3），*p； ”调用了（B）次构造函数。 A.1 B.2 C.3 D.4 【结果分析】 声明指针是不会调用构造函数的。 （9）下面对析构函数的正确描述是（AC）。A.系统可以提供默认的析构函数 B.析构函数必须由用户定义 C.析构函数没有参数 D.析构函数可以设置默认参数 【结果分析】 析构函数的作用是在对象消失时执行一项清理任务。如果一个类中没有定义析构函数，系统将自动生成一个默认析构函数。析构函数没有参数，当然不可能设置默认参数。 （10）类的析构函数是（D）时被调用的。 A.类创建 B.创建对象 C.引用对象 D.释放对象 （11）创建一个类的对象时，系统自动调用（B）； 撤销对象时，系统自动调用（C）。 A.成员函数 B.构造函数 C.析构函数 D.复制构造函数（12）通常拷贝构造函数的参数是（C）。 A.某个对象名 B.某个对象的成员名 C.某个对象的引用名 D.某个对象的指针名（13）关于this指针的说法正确的是（B）。 A.this指针必须显式说明B.当创建一个对象后，this指针就指向该对象 C.成员函数拥有this指针D.静态成员函数拥有this指针。【结果分析】 this指针是由C++编译器自动产生且较常用的一个隐含对象指针，它不能被显式声明。当创建一个对象时，this指针就初始化指向该对象。但只有非静态成员函数才拥有this指针，并通过该指针来处理对象。（14）下列关于子对象的描述中，（B）是错误的。A.子对象是类的一种数据成员，它是另一个类的对象 B.子对象可以是自身类的对象 C.对子对象的初始化要包含在该类的构造函数中 D.一个类中能含有多个子对象作其成员 【结果分析】 子对象不可以是自身类的对象。 （15）对new运算符的下列描述中，（B）是错误的。A.它可以动态创建对象和对象数组 B.用它创建对象数组时必须指定初始值 C.用它创建对象时要调用构造函数 D.用它创建的对象数组可以使用运算符delete来一次释放 【结果分析】 使用运算符new创建对象数组的格式如下： new <类型说明符> ［<算术表达式>］ 其中，<算术表达式>给出数组的大小，后面不能再跟构造函数参数，所以用它创建对象数组时不能指定初始值。 （16）对delete运算符的下列描述中，（D）是错误的。A.用它可以释放用new运算符创建的对象和对象数组 B.用它释放一个对象时，它作用于一个new所返回的指针 C.用它释放一个对象数组时，它作用的指针名前须加下标运算符［ ］ D.用它可一次释放用new运算符创建的多个对象 【结果分析】 用delete一次只能释放用new创建的1个对象，但可释放一个对象数组。（17）关于静态数据成员，下面叙述不正确的是（C）。A.使用静态数据成员，实际上是为了消除全局变量 B.可以使用“对象名.静态成员”或者“类名∷静态成员”来访问静态数据成员 C.静态数据成员只能在静态成员函数中引用 D.所有对象的静态数据成员占用同一内存单元 【结果分析】 静态数据成员可以在静态成员函数中引用，也可以在非静态成员函数中引用。（18）对静态数据成员的不正确描述是（CD）。A.静态成员不属于对象，是类的共享成员 B.静态数据成员要在类外定义和初始化 C.调用静态成员函数时要通过类或对象激活，所以静态成员函数拥有this指针 D.只有静态成员函数可以操作静态数据成员 【结果分析】 this指针是一个局部量，局部于某个对象，而静态成员函数是属于整个类而不是某个对象，它没有this指针。静态成员函数和非静态成员函数均可操作静态数据成员。 （19）下面的选项中，静态成员函数不能直接访问的是（D）。A.静态数据成员 B.静态成员函数 C.类以外的函数和数据 D.非静态数据成员 【结果分析】 由于静态成员函数没有this指针，它只能直接访问该类的静态数据成员、静态成员函数和类以外的函数和数据，访问类中的非静态数据成员必须通过参数传递方式得到对象名，然后通过对象名来访问。 （20）在类的定义中，引入友元的原因是（A）。 A.提高效率 B.深化使用类的封装性 C.提高程序的可读性 D.提高数据的隐蔽性 【结果分析】 友元的作用主要是为了提高效率和方便编程，但友元破坏了类的封装性和隐蔽性，使用时要权衡利弊。 （21）友元类的声明方法是（A）。 A.friend class<类名>； B.youyuan class<类名>； C.class friend<类名>； D.friends class<类名>；（22）下面对友元的错误描述是（D）。A.关键字friend用于声明友元 B.一个类中的成员函数可以是另一个类的友元 C.友元函数访问对象的成员不受访问特性影响 D.友元函数通过this指针访问对象成员 【结果分析】 友元函数是一个放在类中的普通函数，它没有this指针。（23）下面选项中，（C）不是类的成员函数。 A.构造函数 B.析构函数 C.友元函数 D.拷贝构造函数 三、简答题 （1）类与对象有什么关系？ 【问题解答】 类是一种用户自己定义的数据类型，和其他数据类型不同的是，组成这种类型的不仅可以有数据，而且可以有对数据进行操作的函数。程序员可以使用这个新类型在程序中声明新的变量，具有类类型的变量称为对象。创建对象时，类被用做样板，对象称为类的实例。 （2）类定义的一般形式是什么？其成员有哪几种访问权限？ 【问题解答】 定义类一般形式为： class类名{ public: <公有数据和函数> protected: <保护数据和函数> private: <私有数据和函数> }; 访问权限共有3种： 分别是公有（public）、保护（protected）和私有（private）。（3）类的实例化是指创建类的对象还是定义类？ 【问题解答】 指创建类的对象。 （4）什么是this指针？它的主要作用是什么？ 【问题解答】 this指针是C++语言为成员函数提供的一个隐含对象指针，它不能被显式声明。this指针是一个局部量，局部于某个对象。不同的对象调用同一个成员函数时，编译器根据this指针来确定应该引用哪一个对象的数据成员。（5）什么叫做拷贝构造函数？拷贝构造函数何时被调用？ 【问题解答】 拷贝构造函数是一种特殊的构造函数，它的作用是用一个已经存在的对象去初始化另一个对象。为了保证所引用的对象不被修改，通常把引用参数声明为const参数。 在以下3种情况下，拷贝构造函数都会被自动调用： ◆当用类的一个对象去初始化该类的另一个对象时； ◆当函数的形参是类的对象，进行形参和实参结合时； ◆当函数的返回值是类的对象，函数执行完成返回调用者时。 四、程序分析题（写出程序的输出结果，并分析结果）（1） #include using namespace std; class Test { private: int num;public: Test（）;// 默认构造函数 Test（int n）;// 带一个参数构造函数 }; Test∷Test（） { cout<<“Init defa”< num=0;} Test∷Test（int n） { cout<<“Init”<<“ ”< num=n;} int main（） { Test x［2］;// 语句1 Test y（15）;// 语句2 return 0;} 【输出结果】 Init defa Init defa Init 15 【问题分析】 本题主要考查构造函数的调用时机和构造函数的匹配问题。【要点提示】 构造函数在创建对象时被自动调用，具体调用哪个构造函数将由编译系统根据重载函数的匹配原则来确定。【结果分析】 ① 程序声明了2个对象x和y，类中有2个构造函数。 ② 程序首先执行语句1，创建对象x，调用默认构造函数。由于对象x是对象数组，每个数组元素被创建时都要调用构造函数，所以默认构造函数被调用了2次，输出第1、2行结果。程序接着执行语句2，创建对象y，调用带一个参数的构造函数，输出第3行结果。（2） #include using namespace std; class Xx { private: int num; public: Xx（int x）{num=x;} // 构造函数 ~Xx（）{cout<<“dst ”< }; int main（） { Xx w（5）;// 语句1 cout<<“Exit main”< return 0;} 【输出结果】 Exit main dst 5 【问题分析】 本题主要考查析构函数的调用时机。【要点提示】 析构函数在释放对象时被自动调用。【结果分析】 ① 程序声明了一个对象w。 ② 程序首先执行语句1，创建对象w，调用构造函数，num得到初值5。程序接着执行语句2，输出第1行结果。当程序结束时，释放对象w，析构函数被调用，输出第2行结果。 （3）将例3.10中的Whole类如下修改，其他部分不变，写出输出结果。 class Whole { public: Whole（int i）;// Whole的有参构造函数 Whole（）{};// Whole的无参构造函数 ~Whole（）;// Whole的析构函数 private: Part p1;// 子对象1 Part p2;// 子对象2 Part p3;// 子对象3 };Whole∷Whole（int i）:p2（i），p1（） { cout<<“Constructor of Whole”< Whole∷~Whole（） { cout<<“Destructor of Whole”< 【输出结果】 Default constructor of Part Constructor of Part，3 Default constructor of Part Constructor of Whole Destructor of Whole Destructor of Part，0 Destructor of Part，3 Destructor of Part，0 【问题分析】 本题主要考查子对象初始化的方法和含有子对象时构造函数和析构函数的调用顺序。 【要点提示】 ◆当建立X类的对象时，先调用子对象的构造函数，初始化子对象，然后才执行X类的构造函数，初始化X类中的其他成员。 ◆对子对象构造函数的调用顺序取决于这些子对象在类中的说明顺序，与它们在成员初始化列表中给出的顺序无关。 ◆如果X类的构造函数没有给出成员初始化列表，表明子对象将使用默认构造函数进行初始化。◆析构函数的调用顺序与构造函数的调用顺序正好相反。【结果分析】 程序的Whole类中出现了类Part的3个对象p1、p2和p3，作为该类的数据成员，则p1、p2和p3被称为子对象。当建立Whole类的对象w时，子对象p1、p2和p3被建立，相应的构造函数被执行。由于p1在Whole类中先说明，所以先执行它所使用的构造函数，即类Part的默认构造函数，接着p2执行它所使用的有参构造函数，紧接着初始化p3，由于Whole类构造函数的成员初始化列表中没有子对象p3进行初始化的选项，所以执行类Part的默认构造函数，当所有子对象被构造完之后，对象w的构造函数才被执行，从而得到前4行输出结果，而后4行是执行相应析构函数的输出结果。（4） #include using namespace std; class Book { public: Book（int w）; static int sumnum; private: int num;}; Book∷Book（int w） { num=w; sumnum-=w;} int Book∷sumnum=120;// 语句1 int main（） { Book b1（20）;// 语句2 Book b2（70）;// 语句3 cout< return 0;} 【输出结果】 【问题分析】 本题主要考查“在类的范围内所有对象共享静态成员的数据”的含义。【结果分析】 程序中语句1对静态成员sumnum进行初始化，sumnum得到初值120。执行语句2时，调用构造函数，sumnum变为100。接着语句3，再调用构造函数，sumnum变为30。 五、程序设计题 （1）声明一个Circle类，有数据成员radius（半径）、成员函数area（），计算圆的面积，构造一个Circle的对象进行测试。【问题分析】 本题主要考查类定义的形式、对象成员访问和对象初始化的方法。要求理解类和构造函数的真正含义，特别注意如何将客观事物的属性和行为抽象为类的成员。【解题思路】 ① 题目中已给出了类的基本部分，需要增加一个构造函数来初始化数据成员radius。 ② 为了程序的通用性，圆的半径由键盘输入。【参考程序】 // xt3_1.cpp #include 面向对象程序设计大作业实验报告 计算机2000<4>班 周博慧 学号 *** 2001年 12月 5日 一，功能介绍 程序采用C++为设计语言，使用VISUAL C++提供的头文件，操作平台基于dos平台，适用的分辨率为600*480。 程序的设计目的是为一家船工厂建立库存清单。它能够实现的功能有： 1，输入库存（船，零件）的基本情况； 2，改变船或者零件的库存量； 3，查询现存的零件数量； 4，显示库存的基本情况。 二，基本结构 1，类的说明 程序共定义了四个类类型，它们分别是：stock（库存）类，part（零件）类，ship（船）类，stocklist类（库存链表类）。 其中，stock作为基类被part类和ship类公有继承，part类和ship类分别作为stock的派生类存在，两者无其它联系；stock-list类作为一个独立的类而存在。 2，成员说明 stock类定义了两类成员： A）保护成员：包括current-level（当前库存量）和price（价格；对于零件而言是厂商的成本；对于船而已是销售给销售商的价格）。 B）公有成员：包括stock（）；get-level（）；change-level（）；get-price（）；change-price（）；~stock（）六个成员函数。 其中，get-level（）返回当前的库存量；change-level（）改变库存量；get-price（）得到库存价格； change-price（）改变商品价格；~stock（）显示目前某型号零件或某种船模型的库存量。change-level（）和~stock（）被设置为虚函数。 part类除了自stock类继承的成员以外，还定义了两类成员，分别是： A）私有成员：reorder-level（零件的定货量）和part-num（零件的型号）；在这里要求零件的型号由一个字母两个数字组成。 B）公有成员：part（）；get-part（）；set-reorder（）；~part（）四个成员函数。 其中，get-part（）返回零件型号；set-reorder（）设置定货量；~part（）显示零件型号。 ship类除了自stock类继承的成员以外，还定义了两类成员，分别是： A）私有成员：model（船的型号，要求输入字符）；engine-size（引擎规格，要求输入数字）；max-speed（船的最高速度）。 B）公有成员：ship（）；get-model（）；~ship（）三个成员函数。 其中，get-model（）返回船的型号，与零件型号不同，这里要求的是全字符；~ship（）显示型号名称。 stock-list类包含了一个“指针对节点”类型的实例变量，程序运行的时候，指针将接收到一个part类对象或者ship类对象的地址，它也定义了两类成员： A）私有成员：只定义了一个返回类型为stock-node结构（自定义的库存结点结构）的指针head-ptr。 B）公有成员：包括stock-list（）；insert-stock（）；find-part（）；find-ship（）；display-list（）；~stock-list（）五个成员函数。 其中，stock-list（）把库存清单的首地址设置为空，为以后建立库存清单做准备；insert-stock（）输入零件或者船的基本数据；find-part（）查找零件数据；find-ship（）查找船数据；display-list显示库存情况；~stock-list（）释放旧地址占用的空间。 3，结构说明 本程序包括两个c++ header file和三个c++ source file。c++ header file包括shipparts.h和stocklist.h；c++ source file包括shipparts.cpp，stocklist.cpp和mainstock.cpp。 三，心得体会 通过这次大作业的设计，我对C++熟悉了很多，更深刻的体会到C++编程序的优点，加深了对类封装性和继承的理解，熟悉了vc的操作，也丰富了自己的编程经验。 同时，我也深深体会到自己的很多不足，没有很彻底的领会面向对象程序设计的优点，不能很好的构建层次清晰而且分类详细的继承体系，没有建立良好的辨认错误输入发出警告的防御系统，不能检查出一般的输入错误，程序能够实现的功能很少。而且，由于个人编程经验的严重缺乏，程序的适用性极低。 以后要进一步学习c++的编程技巧，增强自己的编程能力。 Java面向对象程序设计课后答案 Java面向对象程序设计 清华大学出版社 （编著 耿祥义 张跃平）习题解答 建议使用文档结构图 （选择Word菜单→视图→文档结构图）习题1 1．James Gosling、、、、2． （1）使用一个文本编辑器编写源文件。 （2）使用Java编译器（javac.exe）编译Java源程序，得到字节码文件。（3）使用Java解释器（java.exe）运行Java程序 3．Java的源文件是由若干个书写形式互相独立的类组成的。应用程序中可以没有public类，若有的话至多可以有一个public类。4．系统环境path Djdkbin;系统环境classpath Djdkjrelibrt.jar;.;5． B 6． Java源文件的扩展名是.java。Java字节码的扩展名是.class。 7．D 8．（1）Speak.java（2）生成两个字节码文件，这些字节码文件的名字Speak.class 和 Xiti8.class（3）java Xiti8（4）执行java Speak的错误提示 Exception in thread “main” java.lang.NoSuchMethodError: main 执行java xiti8得到的错误提示 Exception in thread “main” java.lang.NoClassDefFoundError: xiti8(wrong name: Xiti8)执行java Xiti8.class得到的错误提示 Exception in thread “main” java.lang.NoClassDefFoundError: Xiti8/class 执行java Xiti8得到的输出结果 I'm glad to meet you 9．属于操作题，解答略。习题2 1． D 2．【代码1】 【代码2】 错误 //【代码3】更正为 float z=6.89F;3．float型常量后面必须要有后缀“f”或“F”。 对于double常量，后面可以有后缀“d”或“D”，但允许省略该后缀。4．public class Xiti4{ public static void main(String args[ ]){ char ch1='你',ch2='我',ch3='他';System.out.println(“”“+ch1+”“的位置:”+(int)ch1);System.out.println(“”“+ch2+”“的位置:”+(int)ch2);System.out.println(“”“+ch3+”“的位置:”+(int)ch3);} } 5．数组名字.length 6．数组名字.length 7． 【代码1】A,65 【代码2】-127 【代码3】 123456.783,123456.78312 8． 【代码1】false 【代码2】true 【代码3】false 【代码4】3 【代码5】4.4 【代码6】8.8习题3 输出110 if-else语句书写的不够规范，复合语句缺少大括号“{}”，代码不够清晰。2．你好好酷！3． public class Xiti3_3 { public static void main(String args[ ]){ int startPosition=0,endPosition=0;char cStart='а',cEnd='я';startPosition=(int)cStart;//cStart做int型转换据运算，并将结果赋值给startPosition endPosition=(int)cEnd; //cEnd做int型转换运算，并将结果赋值给endPosition System.out.println(“俄文字母表：”);for(int i=startPosition;i<=endPosition;i++){ char c=' ';c=(char)i; //i做char型转换运算，并将结果赋值给c System.out.print(“ ”+c);if((i-startPosition+1)%10==0)System.out.println(“"); } } } 4． public class Xiti4 { public static void main(String args[]){ double sum=0,a=1;int i=1;while(i<=20){ sum=sum+a;i++;a=a*i;} System.out.println(”sum=“+sum);} } 5． class Xiti5 { public static void main(String args[]){ int i,j;for(j=2;j<=100;j++) { for(i=2;i<=j/2;i++){ if(j%i==0)break;} if(i>j/2){ System.out.print(” “+j);} } } } 6． class Xiti6 { public static void main(String args[]){ double sum=0,a=1,i=1;while(i<=20){ sum=sum+a;i++;a=(1.0/i)*a;} System.out.println(”使用while循环计算的sum=“+sum); for(sum=0,i=1,a=1;i<=20;i++){ a=a*(1.0/i);sum=sum+a;} System.out.println(”使用for循环计算的sum=“+sum);} } 7． public class Xiti7 { public static void main(String args[]){ int sum=0,i,j;for(i=1;i<=1000;i++){ for(j=1,sum=0;j import java.util.Scanner;public class Xiti8 { public static void main(String args[ ]){ System.out.println(”请输入两个非零正整数，每输入一个数回车确认“);Scanner reader=new Scanner(System.in);int m=0,n=0,temp=0,gy=0,gb=0,a,b;a=m = reader.nextInt();b=n = reader.nextInt();if(m import java.util.Scanner;public class Xiti8 { public static void main(String args[ ]){ System.out.println(”请输入两个非零正整数，每输入一个数回车确认“);Scanner reader=new Scanner(System.in);int m=0,n=0,t=0,gy=0,gb=0;m = reader.nextInt();n = reader.nextInt();if(m>n){ t=m;m=n;n=t;} for(int i=1;i<=m;i++){ if(m%i==0 && n%i==0){ gy=i;} } gb=m*n/gy;System.out.println(m+”,“+n+”的最大公约数为 “+gy);System.out.println(m+”,“+n+”的最小公倍数为 “+gb); } } 9． public class Xiti9 { public static void main(String args[]){ int n=1;long sum=0,t=1;t=n*t;while(true){ sum=sum+t;if(sum>9999)break;n++;t=n*t;} System.out.println(” 满足条件的最大整数:“+(n-1));} }// 1至7的阶乘和是sum=5913.0 // 1至8的阶乘和是sum=46233.0习题4 1．用该类创建对象时。 2．所谓方法重载是在一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。构造方法可以重载。3． 可以。不可以。4．不可以。 5．成员变量又分为实例变量和类变量，用static修饰的变量是类变量。那么类变量和实例变量有什么区别呢？一个类通过使用new运算符可以创建多个不同的对象，不同的对象的实例变量将被分配不同的内存空间；如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其它对象的这个类变量。也就是说对象共享类变量。6．C，D 7．【代码1】，【代码4】 8．sum=-100 9．27 10.**20 ##100习题5 1． 如果子类和父类在同一个包中，那么子类自然地继承了其父类中不是private的成员变量作为自己的成员变量，并且也自然地继承了父类中不是private的方法作为自己的方法。继承的成员或方法的访问权限保持不变。如果子类和父类不在同一个包中，那么子类继承了父类的protected、public成员变量做为子类的成员变量，并且继承了父类的protected、public方法为子类的方法，继承的成员或方法的访问权限保持不变。如果子类和父类不在同一个包里，子类不能继承父类的友好变量和友好方法。 只要子类中声明的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量。子类中定义一个方法，这个方法的类型和父类的方法的类型一致或者是父类的方法的类型的子类型，并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同，子类如此定义的方法称作子类重写的方法。子类通过方法的重写可以隐藏继承的方法。2．不可以。3．abstract类。 4．假设B类是A类子类或间接子类，当我们用子类B创建一个对象，并把这个对象的引用放到A类的对象中时，称这个A类对象是子类对象的上转型对象。 5．可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中。那么该接口变量就可以调用被类实现的接口中的方法。6．A，C，D 7．15.0 8.0 8．98.0 12 9． class A { public final void f(){ char cStart='a',cEnd='z';for(char c=cStart;c<=cEnd;c++){ System.out.print(” “+c);} } } class B extends A { public void g(){ char cStart='α',cEnd='ω';for(char c=cStart;c<=cEnd;c++){ System.out.print(” “+c);} } } public class Xiti9 { public static void main(String args[ ]) { B b=new B();b.f();b.g();} } 10． class A { public int f(int a,int b){ if(b 4．大家好，祝工作顺利！5． 96 乘数超过99习题7 1． （1）Strategy是接口。（2）Army不是抽象类。 （3）Army和Strategy是关联关系。 （4）StrategyA, StrategyB、StrategyC与Strategy是实现关系。2． 3．4．例子13的设计符合开-闭原则。5．例子17的设计符合开-闭原则。习题8 采用新增的策略为选手计算得分。 增加新的具体策略StrategyFour。StrategyFour类将double computeScore(double [] a)方法实现为去掉数组a的元素中的一个最大值和一个最小值，然后计算剩余元素的几何平均值。import java.util.Arrays;public class StrategyFour implements ComputableStrategy { public double computeScore(double [] a){ if(a.length<=2)return 0;double score=0,multi=1;Arrays.sort(a);int n=a.length-2;for(int i=1;i (1)策略（Strategy）PrintCharacter.java public interface PrintCharacter{ public abstract void printTable(char [] a,char[] b);}(2)具体策略 PrintStrategyOne.java public class PrintStrategyOne implements PrintCharacter { public void printTable(char [] a,char[] b){ for(int i=0;i for(int i=0;i public void getPersonScore(char[] a,char[] b){ if(strategy==null)System.out.println(”sorry!“);else strategy.printTable(a,b);} } 应用以 上策略: public class Application { public static void main(String args[]){ char [] a=new char[26];char [] b=new char[26];for(int i=0;i<=25;i++){ a[i]=(char)('a'+i);} for(int i=0;i<=25;i++){ b[i]=(char)('A'+i);} PrintGame game=new PrintGame();//上下文对象 game.setStrategy(new PrintStrategyOne()); //上下文对象使用策略一 System.out.println(”方案1:“);game.getPersonScore(a,b); game.setStrategy(new PrintStrategyTwo()); //上下文对象使用策略二 System.out.println(”方案2:“);game.getPersonScore(a,b); } } 3．参照本章8.3.3自主完成。9 1．A，B，D 2． Love:Game 3．13 abc夏日 4．13579 5．9javaHello 6． public class Xiti6 { public static void main(String args[ ]){ String s1,s2,s3,t1=”ABCDabcd“;System.out.println(”字符串原来是这个样子: “+t1);s1=t1.toUpperCase();System.out.println(”字符串中的小写字母变成大写是这个样子: “+s1);s2=t1.toLowerCase(); System.out.println(”字符串中的大写字母变成小写是这个样子: “+s2);s3=s1.concat(s2); System.out.println(”大写字符串连接小写字符串是这个样子: “+s3);} } 7． class Xiti7 { public static void main(String args[ ]){ String s =”中华人民共和国“;char a=s.charAt(0);char b=s.charAt(6);System.out.println(”第一个字符: “+a);System.out.println(”最后一个字符: “+b);} } 8． import java.util.*;class Xiti8 { public static void main(String args[]){ int year,month;System.out.println(”请输入年份和月份，每输入一个数回车确认“);Scanner reader=new Scanner(System.in);year= reader.nextInt();month= reader.nextInt();String [] day=new String[42];System.out.println(” 日 一 二 三 四 五 六“);Calendar rili=Calendar.getInstance();rili.set(year,month-1,1);//将日历翻到year年month月1日,注意0表示一月...11表示十二月 int 星期几=rili.get(Calendar.DAY_OF_WEEK)-1;int dayAmount=0;if(month==1||month==3||month==5||month==7||month==8||month==10||month==12)dayAmount=31;if(month==4||month==6||month==9||month==11)dayAmount=30;if(month==2)if(((year%4==0)&&(year%100!=0))||(year%400==0))dayAmount=29;else dayAmount=28;for(int i=0;i<星期几;i++)day[i]=”“;for(int i=星期几,n=1;i<星期几+dayAmount;i++){ if(n<=9)day[i]=String.valueOf(n)+” “;else day[i]=String.valueOf(n);n++;} for(int i=星期几+dayAmount;i<42;i++)day[i]=”“;for(int i=0;i<星期 几;i++){ day[i]=”**“;} for(int i=0;i { if(i%7==0){ System.out.println(”“);} System.out.print(” “+day[i]);} } } 9． import java.util.*;class Xiti9 { public static void main(String args[]){ int year1,month1,day1,year2,month2,day2;Scanner reader=new Scanner(System.in);System.out.println(”请输入第一个日期的年份 月份 日期，每输入一个数回车确认“);year1= reader.nextInt();month1= reader.nextInt();day1= reader.nextInt();System.out.println(”请输入第二个日期的年份 月份 日期，每输入一个数回车确认“);year2= reader.nextInt();month2= reader.nextInt();day2= reader.nextInt();Calendar calendar=Calendar.getInstance();calendar.set(year1,month1,day1); long timeYear1=calendar.getTimeInMillis();calendar.set(year2,month2,day2); long timeYear2=calendar.getTimeInMillis();long 相隔天数=Math.abs((timeYear1-timeYear2)/(1000*60*60*24));System.out.println(”“+year1+”年“+month1+”月“+day1+”日和“+ year2+”年“+month2+”月“+day2+”日相隔“+相隔天数+”天“);} } 10． public class Xiti10 { public static void main(String args[]){ double a=0,b=0,c=0;a=12;b=24;c=Math.max(a,b);System.out.println(c);c=Math.min(a,b);System.out.println(c);c=Math.pow(2,3);System.out.println(c);c=Math.abs(-0.123);System.out.println(c);c=Math.asin(0.56);System.out.println(c);c=Math.cos(3.14);System.out.println(c);c=Math.exp(1);System.out.println(c);c=Math.log(8);System.out.println(c);} }习题10 1．BorderLayout布局。2．不可以。3．A,C。4． import java.util.StringTokenizer;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Xiti4 { public static void main(String args[]){ ComputerFrame fr=new ComputerFrame();fr.setTitle(”计算的窗口“);} } class ComputerFrame extends JFrame implements TextListener { TextArea text1,text2;int count=1;double sum=0,aver=0;public ComputerFrame(){ setLayout(new FlowLayout());text1=new TextArea(6,20);text2=new TextArea(6,20);add(text1);add(text2); text2.setEditable(false);text1.addTextListener(this);setSize(300,320);setVisible(true);addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0);} });validate();} public void textValueChanged(TextEvent e){ String s=text1.getText();sum=0;aver=0; StringTokenizer fenxi=new StringTokenizer(s,” ,'n'“);int n=fenx i.countTokens();count=n;double a[]=new double[n];for(int i=0;i<=n-1;i++){ String temp=fenxi.nextToken(); try { a[i]=Double.parseDouble(temp);sum=sum+a[i];} catch(Exception ee){ count--;} } aver=sum/count;text2.setText(null); text2.append(”n和:“+sum);text2.append(”n平均值:“+aver);} } 5． import java.applet.*;import java.awt.*;import java.awt.event.*;public class Xiti5 { public static void main(String args[]){ ComputerFrame fr=new ComputerFrame();fr.setTitle(”计算“);} } class ComputerFrame extends Frame implements ActionListener { TextField text1,text2,text3;Button button1,button2,button3,button4;Label label;public ComputerFrame(){setLayout(new FlowLayout());text1=new TextField(10);text2=new TextField(10);text3=new TextField(10);label=new Label(” “,Label.CENTER);label.setBackground(Color.green);add(text1);add(label);add(text2);add(text3);button1=new Button(”加“); button2=new Button(”减“);button3=new Button(”乘“);button4=new Button(”除“);add(button1);add(button2);add(button3);add(button4); button1.addActionListener(this);button2.addActionListener(this);button3.addActionListener(this); button4.addActionListener(this);setSize(300,320);setVisible(true);addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0);} });validate();} public void actionPerformed(ActionEvent e){ double n;if(e.getSource()==button1){ double n1,n2; try{ n1=Double.parseDouble(text1.getText());n2=Double.parseDouble(text2.getText());n=n1+n2;text3.setText(String.valueOf(n));label.setText(”+“);} catch(NumberFormatException ee){ text3.setText(”请输入数字字符“);} } else if(e.getSource()==button2){ double n1,n2; try{ n1=Double.parseDouble(text1.getText());n2=Double.parseDouble(text2.getText());n=n1-n2;text3.setText(String.valueOf(n));label.setText(”-“);} catch(NumberFormatException ee){ text3.setText(”请输入数字字符“);} } else if(e.getSource()==button3){double n1,n2; try{ n1=Double.parseDouble(text1.getText());n2=Double.parseDouble(text2.getText());n=n1*n2;text3.setText(String.valueOf(n));label.setText(”*“);} catch(NumberFormatException ee){ text3.setText(”请输入数字字符“);} } else if(e.getSource()==button4){double n1,n 2; try{ n1=Double.parseDouble(text1.getText());n2=Double.parseDouble(text2.getText());n=n1/n2;text3.setText(String.valueOf(n));label.setText(”/“);} catch(NumberFormatException ee){ text3.setText(”请输入数字字符“);} } validate();} } 6． import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Xiti6 { public static void main(String args[]){ new WindowPanel();} } class Mypanel extends JPanel implements ActionListener { Button button; TextField text;Mypanel() { button=new Button(” “);text=new TextField(12);add(button);add(text);button.addActionListener(this);} public void actionPerformed(ActionEvent e){ String name=text.getText();if(name.length()>0)button.setLabel(name);validate();} } class WindowPanel extends Frame { Mypanel panel1,panel2;WindowPanel(){ panel1=new Mypanel();panel2=new Mypanel();panel1.setBackground(Color.red);panel2.setBackground(Color.blue);add(panel1,BorderLayout.SOUTH);add(panel2,BorderLayout.NORTH);setSize(300,320);setVisible(true);addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0);} });validate();} } 7．参见10.13, 参照本章例子10.21。8． import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Xiti8 { public static void main(String args[]){ MoveFrame f=new MoveFrame();f.setBounds(12,12,300,300);f.setVisible(true);f.setTitle(”移动“); f.validate();f.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e){ System.exit(0);} });} } class MoveFrame extends JFrame implements ActionListener { JButton controlButton,movedButton; public MoveFrame(){ controlButton=new JButton(”单击我运动另一个按钮“);controlButton.addActionListener(this);movedButton=new JButton();movedButton.setBackground(new Color(12,200,34));setLayout(null);add(controlButton);add(movedButton);controlButton.setBounds(10,30,130,30);movedButton.setBounds(100,100,10,10);} public void actionPerformed(ActionEvent e){ int x=movedButton.getBounds().x;int y=movedButton.getBounds().y;x=x+5;y=y+1; movedButton.setLocation(x,y);if(x>200){ x=100;y=100;} } } 9． import java.awt.*;import java.awt.event.*;public class Xiti9 { public static void main(String args[]) { Win win=new Win();} } class Win extends Frame implements KeyListener { Button b[]=new Button[8];int x,y;Win(){ setLayout(new FlowLayout());for(int i=0;i<8;i++) { b[i]=new Button(”“+i);b[i].addKeyListener(this);add(b[i]);} addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0);} });setBounds(10,10,300,300);setVisible(true);validate();} public void keyPressed(KeyEvent e){ int moveDistance=1;Component com=(Component)e.getSource();int x=(int)com.getBounds().x;int y=(int)com.getBounds().y;Component component[]=this.getComponents();if(e.getKeyCode()==KeyEvent.VK_UP){ y=y-moveDistance;com.setLocation(x,y);Rectangle comRect=com.getBounds();for(int k=0;k y=y+moveDistance;com.setLocation(x,y);Rectangle comRect=com.getBounds();for(int k=0;k else if(e.getKeyCode()==KeyEvent.VK_RIGHT){ x=x+moveDistance;com.setLocation(x,y);Rectangle comRect=com.getBounds();for(int k=0;k ． import java.awt.event.*;import java.awt.*;import javax.swing.*;class Dwindow extends Frame implements ActionListener { TextField inputNumber;TextArea save;Dwindow(String s){ super(s);inputNumber=new TextField(22);inputNumber.addActionListener(this);save=new TextArea(12,16);setLayout(new FlowLayout());add(inputNumber);add(save); setBounds(60,60,300,300);setVisible(true);validate();addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e){ System.exit(0);} });} public void actionPerformed(ActionEvent event){ String s=inputNumber.getText();double n=0;try{ n=Double.parseDouble(s);if(n>1000){ int select=JOptionPane.showConfirmDialog(this,”已经超过1000确认正确吗？“,”确认对话框“, JOptionPane.YES_NO_OPTION);if(select==JOptionPane.YES_OPTION) { save.append(”n“+s);} else { inputNumber.setText(null);} } else { save.append(”n“+s);} } catch(NumberFormatException e){ JOptionPane.showMessageDialog(this,”您输入了非法字符“,”警告对话框“, JOptionPane.WARNING_MESSAGE);inputNumber.setText(null);} } } public class E { public static void main(String args[]){ new Dwindow(”带对话框的窗口“);} } 3．参照以下例子完成 Xiti3.java public class Xiti3 { public static void main(String args[]){ WindowColor win=new WindowColor();win.setTitle(”带颜色对话框的窗口“);} } WindowColor.java import java.awt.event.*;import java.awt.*;import javax.swing.*;public class WindowColor extends JFrame implements ActionListener { JButton button;WindowColor(){ button=new JButton(”打开颜色对话框“);button.addActionListener(this);setLayout(new FlowLayout());add(button);setBounds(60,60,300,300);setVisible(true);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);} public void actionPerformed(ActionEvent e){ Color newColor=JColorChooser.showDialog(this,”调色板“,button.getBackground());if(newColor!=null){ button.setBackground(newColor);} } }习题12 1．使用FileInputStream流。 2．FileInputStream按字节读取文件，FileReader按字符读取文件。3．不能。 4．使用对象流写入或读入对象时，要保证对象是序列化的。5．使用对象流很容易得获取一个 序列化对象的克隆，只需将该对象写入到对象输出流，那么用对象输入流读回的对象一定是原对象的一个克隆。6． import java.io.*;public class Xiti6 { public static void main(String args[]){ File f=new File(”E.java“);;try{ RandomAccessFile random=new RandomAccessFile(f,”rw“);random.seek(0);long m=random.length();while(m>=0){ m=m-1;random.seek(m);int c=random.readByte();if(c<=255&&c>=0){ System.out.print((char)c);} else { m=m-1;random.seek(m);byte cc[]=new byte[2];random.readFully(cc);System.out.print(new String(cc));} } } catch(Exception exp){} } } 7．import java.io.*;public class Xiti7 { public static void main(String args[ ]){ File file=new File(”E.java“);File tempFile=new File(”temp.txt“);try{ FileReader inOne=new FileReader(file);BufferedReader inTwo= new BufferedReader(inOne);FileWriter tofile=new FileWriter(tempFile);BufferedWriter out= new BufferedWriter(tofile);String s=null;int i=0;s=inTwo.readLine();while(s!=null){ i++;out.write(i+” “+s);out.newLine();s=inTwo.readLine();} inOne.close();inTwo.close();out.flush();out.close();tofile.close();} catch(IOException e){ System.out.println(e);} } } 8．属于操作题目，解答略。9． import java.util.*;import java.io.*;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Xiti9 { public static void main(String args[]){ EWindow w=new EWindow();w.validate();} } class EWindow extends Frame implements ActionListener,ItemListener { String str[]=new String[7],s;FileReader file;BufferedReader in; Button start,next;Checkbox checkbox[];TextField 题目,分数;int score=0; CheckboxGroup age=new CheckboxGroup();EWindow(){ super(”英语单词学习“);分数=new TextField(10);题目=new TextField(70);start=new Button(”重新练习“);start.addActionListener(this);next=new Button(”下一题目“);next.addActionListener(this);checkbox=new Checkbox[4];for(int i=0;i<=3;i++){ checkbox[i]=new Checkbox(”“,false,age);checkbox[i].addItemListener(this);} try { file=new FileReader(”English.txt“);in=new BufferedReader(file);} catch(IOException e){} setBoun ds(20,100,660,300);setVisible(true);Box box=Box.createVerticalBox();Panel p1=new Panel(),p2=new Panel(), p3=new Panel(),p4=new Panel(),p5=new Panel();p1.add(new Label(”题目:“));p1.add(题目);p2.add(new Label(”选择答案：“));for(int i=0;i<=3;i++){ p2.add(checkbox[i]);} p3.add(new Label(”您的得分:“));p3.add(分数);p4.add(start);p4.add(next);box.add(p1);box.add(p2);box.add(p3);box.add(p4);addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){ System.exit(0);} });add(box,BorderLayout.CENTER);reading();} public void reading(){ int i=0;try { s=in.readLine();if(!(s.startsWith(”endend“))){ StringTokenizer tokenizer=new StringTokenizer(s,”#“);while(tokenizer.hasMoreTokens()){ str[i]=tokenizer.nextToken();i++;} 题目.setText(str[0]);for(int j=1;j<=4;j++){ checkbox[j-1].setLabel(str[j]);} } else if(s.startsWith(”endend“)){ 题目.setText(”学习完毕“);for(int j=0;j<4;j++){ checkbox[j].setLabel(”end“);in.close();file.close();} } } catch(Exception exp){ 题目.setText(”无试题文件“);} } public void actionPerformed(ActionEvent event){ if(event.getSource()==start){ score=0;分数.setText(”得分： “+score);try { file=new FileReader(”English.txt“);in=new BufferedReader(file);} catch(IOException e){} reading();} if(event.getSource()==next){ reading();for(int j=0;j<4;j++){ checkbox[j].setEnabled(true); } } } public void itemStateChanged(ItemEvent e){ for(int j=0;j<4;j++){ if(checkbox[j].getLabel().equals(str[5])&&checkbox[j].getState()){ score++;分数.setText(”得分： “+score);} checkbox[j].setEnabled(false); } } }习题13 1．一个使用链式结构，一个使用顺序结构。 2．8。3．ABCD。 4．选用HashMap import java.util.*;class UFlashKey implements Comparable { double d=0;UFlashKey(double d){ this.d=d;} public int compareTo(Object b){ UFlashKey st=(UFlashKey)b;if((this.d-st.d)==0)return-1;else retu rn(int)((this.d-st.d)*1000);} } class UFlash { String name=null;double capacity,price;UFlash(String s,double m,double e){ name=s;capacity=m;price=e;} } public class Xiti5 { public static void main(String args[ ]){ TreeMap } int number=treemap.size();System.out.println(”树映射中有“+number+”个对象,按容量成绩排序:“);Collection 习题14 1． (1)创建数据源 选择“控制面板”→“管理工具”→“ODBC数据源”（某些window/xp系统，需选择“控制面板”→“性能和维护”→“管理工具”→“ODBC数据源”）。双击ODBC数据源图标，选择“系统DSN”或“用户DSN”，单击“添加”按钮，可以创建新的数据源。(2)数据源选择驱动程序 选择单击“添加”按钮，出现为新增的数据源选择驱动程序界面，如果要访问Access数据库，选择Microsoft Acess Driver（*.mdb）。单击完成按钮。(3)数据源名称及对应数据库的所在位置 在设置数据源具体项目的对话框，在名称栏里为数据源起一个自己喜欢的名字。这个数据源就是指某个数据库。在“数据库选择”栏中选择一个已经准备好的数据库。2．参照本章例子14.2。3．参照本章例子14.3。4．参照本章例子14.4。 5．使用预处理语句不仅减轻了数据库的负担，而且也提高了访问数据库 的速度。 6．事务由一组SQL语句组成，所谓事务处理是指：应用程序保证事务中的SQL语句要么全部都执行，要么一个都不执行。步骤:(1)使用setAutoCommit(boolean autoCommit)方法 con对象首先调用setAutoCommit(boolean autoCommit)方法，将参数autoCommit取值false来关闭默认设置： con.setAutoCommit(false);(2)使用commit()方法。con调用commit()方法就是让事务中的SQL语句全部生效。 (3)使用rollback()方法。con调用rollback()方法撤消事务中成功执行过的SQL语句对数据库数据所做的更新、插入或删除操作，即撤消引起数据发生变化的SQL语句操作，将数据库中的数据恢复到commi()方法执行之前的状态。7．参照本章例子14.2。习题15 1．4种状态：新建、运行、中断和死亡。2．有4种原因的中断： JVM将CPU资源从当前线程切换给其他线程，使本线程让出CPU的使用权处于中断状态。线程使用CPU资源期间，执行了sleep(int millsecond)方法，使当前线程进入休眠状态。经过参数millsecond指定的豪秒数之后，该线程就重新进到线程队列中排队等待CPU资源，以便从中断处继续运行。 线程使用CPU资源期间，执行了wait()方法，使得当前线程进入等待状态。等待状态的线程不会主动进到线程队列中排队等待CPU资源，必须由其他线程调用notify()方法通知它，使得它重新进到线程队列中排队等待CPU资源，以便从中断处继续运行。 线程使用CPU资源期间，执行某个操作进入阻塞状态，比如执行读/写操作引起阻塞。进入阻塞状态时线程不能进入排队队列，只有当引起阻塞的原因消除时，线程才重新进到线程队列中排队等待CPU资源，以便从原来中断处开始继续运行。3．死亡状态，不能再调用start()方法。4．新建和死亡状态。 5．两种方法：用Thread类或其子类。6．使用 setPrority(int grade)方法。 7．Java使我们可以创建多个线程，在处理多线程问题时，我们必须注意这样一个问题：当两个或多个线程同时访问同一个变量，并且一个线程需要修改这个变量。我们应对这样的问题作出处理，否则可能发生混乱。 8．当一个线程使用的同步方法中用到某个变量，而此变量又需要其它线程修改后才能符合本线程的需要，那么可以在同步方法中使用wait()方法。使用wait方法可以中断方法的执行，使本线程等待，暂时让出CPU的使用权，并允许其它线程使用这个同步方法。其它线程如果在使用这个同步方法时不需要等待，那么它使用完这个同步方法的同时，应当用notifyAll()方法通知所有的由于使用这个同步方法而处于等待的线程结束等待 9．不合理。 10．“吵醒”休眠的线程。一个占有CPU资源的线程可以让休眠的线程调用i nterrupt 方法“吵醒”自己，即导致休眠的线程发生InterruptedException异常，从而结束休眠，重新排队等待CPU资源。11． public class Xiti11 { public static void main(String args[]){ Cinema a=new Cinema();a.zhang.start();a.sun.start();a.zhao.start();} } class TicketSeller //负责卖票的类。 { int fiveNumber=3,tenNumber=0,twentyNumber=0;public synchronized void sellTicket(int receiveMoney){ if(receiveMoney==5){ fiveNumber=fiveNumber+1; System.out.println(Thread.currentThread().getName()+ ”给我5元钱，这是您的1张入场卷“);} else if(receiveMoney==10) { while(fiveNumber<1){ try { System.out.println(Thread.currentThread().getName()+”靠边等“);wait(); System.out.println(Thread.currentThread().getName()+”结束等待“);} catch(InterruptedException e){} } fiveNumber=fiveNumber-1;tenNumber=tenNumber+1;System.out.println(Thread.currentThread().getName()+ ”给我10元钱,找您5元,这是您的1张入场卷“); } else if(receiveMoney==20) { while(fiveNumber<1||tenNumber<1){ try { System.out.println(Thread.currentThread().getName()+”靠边等“);wait(); System.out.println(Thread.currentThread().getName()+”结束等待“);} catch(InterruptedException e){} } fiveNumber=fiveNumber-1;tenNumber=tenNumber-1;twentyNumber=twentyNumber+1; System.out.println(Thread.currentThread().getName()+ ”给20元钱，找您一张5元和一张10元，这是您的1张入场卷“);} notifyAll();} } class Cinema implements Runnable { Thread zhang,sun,zhao;TicketSeller seller;Cinema(){ zhang=new Thread(this);sun=new Thread(this);zhao=new Thread(this);zhang.setName(”张小有“);sun.setName(”孙大名“);zhao.setName(”赵中堂“);seller=new TicketSeller();} public void run(){ if(Thread.currentThread()==zhang){ seller.sellTicket(20);} else if(Thread.currentThread()==sun){ seller.sellTicket(10);} else if(Thread.currentThread()==zhao){ seller.sellTicket(5);} } } 12．参照本章例子9。13．参照本章例子19。14．BA习题16 1．URL对象调用InputStream openStream()方法可以返回一个输入流。 2．客户端的程序使用Socket类建立负责连接到服务器的套接字对象称为socket对象。使用Socket的构造方法Socket(String host,int port)，建立连接到服务器的套接字对象。 参考16.3.2 3．JEditorPane 4．会返回一个和客户端Socket对象相连接的Socket对象。5． 域名/IP 地址 例如，www.xiexiebang.com/202.108.35.210 6．(1)客户端 import java.net.*;import java.io.*;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Client { public static void main(String args[]){ new ComputerClient();} } class ComputerClient extends Frame implements Runnable,ActionListener { Button connection,send;TextField inputText,showResult;Socket socket=null;DataInputStream in=null;DataOutputStream out=null;Thread thread;ComputerClient(){ socket=new Socket();setLayout(new FlowLayout());Box box=Box.createVerticalBox();connection=new Button(”连接服务器“);send=new Button(”发送“);send.setEnabled(false);inputText=new TextField(12);showResult=new TextField(12);box.add(connection);box.add(new Label(”输入三角形三边的长度,用逗号或空格分隔:“));box.add(inputText);box.add(send);box.add(new Label(”收到的结果：“));box.add(showResult);connection.addActionListener(this);send.addActionListener(this);thread=new Thread(this);add(box);setBounds(10,30,300,400);setVisible(true);validate();addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0);} });} public void actionPerformed(ActionEvent e){ if(e.getSource()==connection){ try //请求和服务器建立套接字连接： { if(socket.isConnected()){} else { InetAddress address=InetAddress.getByName(”127.0.0.1“);InetSocketAddress socketAddress=new InetSocketAddress(address,4331);socket.connect(socketAddress); in =new DataInputStream(socket.getInputStream());out = new DataOutputStream(socket.getOutputStream());send.setEnabled(true);thread.start();} } catch(IOException ee){} } if(e.getSource()==send){ String s=inputText.getText();if(s!=null){ try { out.writeUTF(s);} catch(IOException e1){} } } } public void run(){ String s=null;while(true){ try{ s=in.readUTF();showResult.setText(s);} catch(IOException e) { showResult.setText(”与服务器已断开“);break;} } } }（2）服务器端 import java.io.*;import java.net.*;import java.util.*;public class Server { public static void main(String args[]){ ServerSocket server=null;Server_thread thread;Socket you=null;while(true) { try{ server=new ServerSocket(4331);} catch(IOException e1) { System.out.println(”正在监听“);//ServerSocket对象不能重复创建 } try{ System.out.println(” 等待客户呼叫“);you=server.accept();System.out.println(”客户的地址:“+you.getInetAddress());} catch(IOException e){ System.out.println(”正在等待客户“);} if(you!=null) { new Server_thread(you).start();//为每个客户启动一个专门的线程 } } } } class Server_thread extends Thread { Socket socket;DataOutputStream out=null;DataInputStream in=null;String s=null;boolean quesion=false;Server_thread(Socket t){ socket=t;try { out=new DataOutputStream(socket.getOutputStream());in=new DataInputStream(socket.getInputStream());} catch(IOException e){} } public void run() { while(true){ double a[]=new double[3];int i=0;try{ s=in.readUTF();//堵塞状态，除非读取到信息 quesion=false;StringTokenizer fenxi=new StringTokenizer(s,” ,“);while(fenxi.hasMoreTokens()){ String temp=fenxi.nextToken();try{ a[i]=Double.valueOf(temp).doubleValue();i++;} catch(NumberFormatException e){ out.writeUTF(”请输入数字字符“);quesion=true;} } if(quesion==false){ double p=(a[0]+a[1]+a[2])/2.0;out.writeUTF(” “+Math.sqrt(p*(p-a[0])*(p-a[1])*(p-a[2])));} } catch(IOException e) { System.out.println(”客户离开“);return;} } } } 7．参照本章例子16.6及以下代码。（1）服务器 Server.java import java.io.*;import java.net.*;import java.util.zip.*;public class Server { public static void main(String args[]){ ServerSocket server=null;ServerThread thread;Socket you=null;while(true) { try{ server=new ServerSocket(4331);} catch(IOException e1) { System.out.println(”正在监听“); } try{ you=server.accept();System.out.println(”客户的地址:“+you.getInetAddress());} catch(IOException e){ System.out.println(”正在等待客户“);} if(you!=null){ new ServerThread(you).start(); } } } } class ServerThread extends Thread { Socket socket;ZipOutputStream out;String s=null;ServerThread(Socket t){ socket=t;try { out=new ZipOutputStream(socket.getOutputStream());} catch(IOException e){} } public void run() { try{out.putNextEntry(new ZipEntry(”Example.java“));FileInputStream reader=new FileInputStream(”Example.java“);byte b[]=new byte[1024];int n=-1;while((n=reader.read(b,0,1024))!=-1){ out.write(b,0,n); //发送压缩后的数据到客户端。} out.putNextEntry(new ZipEntry(”E.java“));reader=new FileInputStream(”E.java“);n=-1;while((n=reader.read(b,0,1024))!=-1){ out.write(b,0,n); //发送压缩后的数据到客户端。} reader.close();out.close();} catch(IOException e){} } }（2）客户端 Client.java import java.net.*;import java.io.*;import java.awt.*;import java.awt.event.*;import java.util.zip.*;public class Client extends Frame implements Runnable,ActionListener { Button connection,getFile;TextArea showResult;Socket socket=null;ZipInputStream in;Thread thread;public Client(){ socket=new Socket(); connection=new Button(”连接服务器,获取文件内容“);setLayout(new FlowLayout());showResult=new TextArea(10,28);add(connection);add(showResult);connection.addActionListener(this);thread=new Thread(this);setBounds(100,100,460,410);setVisible(true);addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0);} });} public void run(){ byte b[]=new byte[1024];ZipEntry zipEntry=null;while(true){ try{ while((zipEntry=in.getNextEntry())!=null){ showResult.append(”n“+zipEntry.toString()+”:n“);int n=-1;while((n=in.read(b,0,1024))!=-1){ String str=new String(b,0,n);showResult.append(str);} } } catch(IOException e){ } } } public void actionPerformed(ActionEvent e){ if(e.getSource()==connection){ try { if(socket.isConnected()){} else { InetAddress address=InetAddress.getByName(”127.0.0.1“);InetSocketAddress socketAddress=new InetSocketAddress(address,4331);socket.connect(socketAddress); in=new ZipInputStream(socket.getInputStream()); thread.start();} } catch(IOException ee){ System.out.println(ee);} } } public static void main(String args[]){ Client win=new Client();} }习题17 1． import java.applet.*;import java.awt.*;import java.awt.event.*;public class Xiti1 extends Applet implements ActionListener{ Button button;TextField text;int sum;public void init(){ button=new Button(”点点看...“);text=new TextField(20); add(button);add(text); button.addActionListener(this); } public void actionPerformed(ActionEvent e){ String str=button.getLabel();text.setText(”按钮上写着:“+str);} } 超文本文件： 2． import java.applet.*;import java.awt.*;import java.awt.event.*; import javax.swing.*; public class Xiti2 extends Applet implements ActionListener { TextField text1,text2;Label label;public void init() { text1=new TextField(10);text2=new TextField(20);Box box1=Box.createHorizontalBox();Box box2=Box.createHorizontalBox();Box boxV=Box.createVerticalBox();box1.add(new Label(”输入一个数回车确定:“));box1.add(text1);label=new Label(”数的平方:“);box2.add(label);box2.add(text2);boxV.add(box1);boxV.add(box2);add(boxV);text2.setEditable(false);text1.addActionListener(this);} public void actionPerformed(ActionEvent e){ String number=e.getActionCommand();try{ double n=Double.parseDouble(number);double m=n*n;label.setText(n+”的平方:“);text2.setText(”“+m);text1.setText(”“);validate();} catch(NumberFormatException exp){ text2.setText(”"+exp);} } } 3．参照本章例子17.2，17.3。第四篇：面向对象程序设计大作业实验报告
第五篇：Java面向对象程序设计课后答案
点击咨询 