Corejava上机实验

第一章：开始

一）基础实验：

1. 在Linux下安装JDK，配置环境变量

安装JDK：

sudo chmod 777 /opt

cp jdk-6u24-linux-i586.bin /opt cd /opt

chmod a+x jdk-6u24-linux-i586.bin ./jdk-6u24-linux-i586.bin 配置环境变量：

cp ~/.bahsrc ~/.bashrc.bak vi ~/.bashrc

G==>到文件结尾 o==>下一行输入

JAVA_HOME=/opt/jdk1.6.0_24 PATH=JAVA_HOME$/bin:$PATH CLASSPATH=.

export JAVA_HOME PATH CLASSPATH :wq . ~/.bashrc javac

echo $JAVA_HOME

2. 编辑、编译、运行一个带有包名的Hello.java，输出Hello World！

vi Hello.java（example/chap01/src/Hello.java） javac –d bin src/Hello.java

java –cp bin com.briup.chap01.Hello

3. 编辑、编译、运行一个带有包名的MymathTest.java，完成整数的加减运算 vi MymathTest.java（example/chap01/src/MymathTest.java） javac –d bin src/ MymathTest.java

java –cp bin com.briup.chap01. MymathTest 二）扩展实验： 1. JVM组成

类装载器：将java字节码加载到内存 运行时数据区： 方法区：类型信息 堆区：对象 栈区：保存方法调用状态，如局部变量、参数、返回值 PC寄存器：指向下一条将要执行的指令 本地方法栈：保存本地方法调用状态 执行引擎：运行类方法中的指令 三）作业：

1. 什么是JDK，其包括哪些内容

Java Development Kit(Java开发工具包)，JDK主要包括内容： a. Java虚拟机：负责解析和执行Java程序，Java虚拟机可运行在各种平台上；

b. JDK类库：提供最基础的Java类及各种实用类，java.lang、java.io、java.util,、javax.swing、java.sql等包中的类都位于JDK类库中。 c. 开发工具：这些开发工具都是可执行程序，主要包括：

javac编译工具； java运行工具；

javadoc生成JavaDoc文档的工具 jar打包工具

2. 和java相关的环境变量有那几个，它们有什么作用

JAVA_HOME：简化其它变量设置过程中的内容输入。可先行将JDK的安装路径定义为一变量，以后凡使用到JDK安装路径的地方均使用该变量进行替换。 PATH：指定执行外部命令时找寻对应可执行文件的路径范围。

CLASSPATH：代表Java类的根路径，java命令会从CLASSPATH中寻找所需的Java类；Java编译器编译Java类时，也会从CLASSPATH中寻找所需的Java类；classpath的默认值为当前路径。 3. java的优秀特性

跨平台：字节码跨平台，在任何平台上字节码都一样，但不同平台有不同平台的JVM

易编程：没有指针（垃圾回收器）、面向对象（符合人类思考方式） 代码安全：有字节码校验器，适合在网络传输 4. 字节码校验器验证哪些内容 代码和jvm规范一致

代码不能破坏系统的完整性 没有堆栈的上溢和下溢 参数类型是正确的 类型转换是正确的

5. java程序编辑、编译、运行过程 vi xxx.java?javac xxx.java?java xxx 6. java中包的作用

将有关联关系的类组织在一起，便于管理；解决命名冲突问题 7. 什么是API，如何查看API

Application Programming Interface

先查看package?class/interface?field/constructor/method

8. 修正Test1.java、Test2.java、Test3.java、Test4.java四个java源文件中的错误，使其能够编译和运行（exercise/chap01）

第二章：标识符、关键字、类型

1） 基础实验：

1. 单行、多行注释例子

example/chap02/src/CommentTest.java

2. 写一java程序添加文档注释，通过javadoc产生API文档（包含作者、版本等信息）

example/chap02/src/CommentTest2.java

javadoc -d ./doc -author -version src/CommentTest2.java 3. 数据类型测试例子

example/chap02/src/TypeTest.java

4. 类、对象测试例子

example/chap02/src/Teacher.java example/chap02/src/TeacherTest.java 二）扩展实验：

1. 找零问题：有2元，买东西花了1.1元，问找零多少? System.out.println(2.00-1.10);

注意：在需要精确答案的地方，要避免使用float或double；

对于货币计算，要使用int、long或BigDecima(用于浮点数计算)属于math

Import java.util.*; . . .

BigDecima a=new

2. 长整除问题： long micros_per_day = 24 * 60 * 60 * 1000 * 1000; long millis_per_day = 24 * 60 * 60 * 1000; System.out.println(micros_per_day / millis_per_day);

输出结果。

注意：当你操作很大的数字时，一定要提防溢出；较大整数运算可使用BigInteger 3. 初级问题 System.out.println(12345 + 5432l)输出结果。 注意：做题要细心；在long类型字面常量中，一定要用大写的L 三）作业：

1. java中注释的分类 java中注释分三类

//：单行注释，如描述一个变量的作用 /* */：多行注释，如描述类的作用、方法的作用、复杂算法的描述 /** */：文档注释，需产生API文档时使用 2. java中标示符的命名规则

1) 以字母、_和$开头，不能以数字开头，后跟字母、数字、“_”和“$”的组合

2) 大小写敏感 3) 没有长度限制 4) 不能使用关键字

3. java中有哪些常用的基本数据类型

boolean、整型族（byte、short、int、long）、浮点型（float、double）、字符型（char）

4. 类和对象的概念 类是现实世界中，具有相同属性和行为的事物的抽象（如鸟类、鱼类、人类）。 对象是类的具体化（万物皆对象、每个对象都是唯一的）。 5. 基本数据类型和引用类型的区别

1) 基本类型代表简单的数据类型，比如整数和字符。

引用类型代表复杂数据类型，引用类型所引用的实例包括操纵这种数据类型的行为。通过\运算符，就能访问引用变量所引用的实例的方法. 2) 基本类型Java虚拟机会为其分配数据类型实际占用的内存空间； 引用类型仅是一个指向堆区中某个实例的指针。 例：public class Counter {

int count = 13; }

Counter counter = new Counter();

counter引用变量-------------> Counter实例 count变量(占4个字节,值为13)

counter引用变量的取值为Counter实例的内存地址。 counter引用变量本身也占一定的内存空间，到底占用多少内存空间取决于Java虚拟机的实现，这对Java程序是透明的。

注：counter引用变量到底位于Java虚拟机的运行时数据区的哪个区？取决于counter变量的作用域，如果是局部变量，则位于Java栈区；静态成员变量，则位于方法区；实例成员变量，则位于堆区； 6. 编程（exercise/chap02/exercise1）

1）模仿Teacher类创建Student类

要求：Student类要描述姓名、性别、年龄 2）模仿TeacherTest类创建StudentTest类 要求：

a) 在StudentTest类中创建Student的对象

b) 为该对象的属性（姓名、性别、年龄）赋值 c) 将该对象的属性（姓名、性别、年龄）输出 7. 编程（exercise/chap02/exercise2）

1）为Teacher类添加一个方法，用于在教师原有薪水的基础上增加5000

2）修改TeacherTest类，增加对教师增加薪水方法的调用，并将增加后的薪水值输出

8. 编程（exercise/chap02/exercise3）

已知类MyPoint表示一个二维的点，其定义如下： public class MyPoint { public int x; public int y;

public String toString() {

return (\ } }

使用上面已提供的MyPoint类，建立一个TestMyPoint程序，该程序执行下列操作：

1）定义两个类型为MyPoint的变量，变量名为：start 和 end。每个变量赋

值一个新的MyPoint的对象。

2）将start 的 x 和 y 值设置为10，end的 x值设置为20，y值为30。 3）打印输出这两点变量，使用类似于如下的代码：System.out.println(“Start point is ”+start);

4）编译运行TestMyPoint。

5）声明一个类型为MyPoint的新变量，名为stray 将现有变量end 的引用值赋值给stray。

6）打印输出stray 和 end 。

7）将新值赋值给stray 变量的 x 和 y成员。打印输出stray end start。 8）编译运行TestMyPoint。end报告的值反映了stray中的变化，说明这两个变量引用的似同一个MyPoint对象。但是，start并没有改变，说明start与另两个变量无关。

输出结果应与下面类似： Start point is 【10，10】 End point is 【20，30】

Stray point is 【20，30】 End point is 【20，30】

Stray point is 【47，50】 End point is 【47，50】 Start point is 【10，10】

第三章：表达式和流程控制

一）基础实验：

1. 局部变量和实例变量测试例子

example/chap03/src/VariableTest.java 2. 操作符测试例子

example/chap03/src/OperatorTest.java example/chap03/src/BitTest.java?位运算 3. if语句测试例子

example/chap03/src/IfTest1.java

example/chap03/src/IfTest2.java?判断闰年 4. switch语句测试例子

example/chap03/src/SwitchTest.java

example/chap03/src/Days.java?某一年月有多少天 5. for、while、do while循环语句测试例子

example/chap03/src/LoopTest.java?三种循环实训1累加到100

example/chap03/src/LoopRandom.java?产生10个[200,500]间的随机数 example/chap03/src/GcdLcm.java?求两个数的最大公约数和最小公倍数 6. break、continue关键字测试例子

example/chap03/src/BreakContinueTest.java 2） 扩展实验： 1. 复合赋值

short x = 0; int i = 123456;

x += i;//编译通过，x = -7616

x = x + i;//编译错误 i的范围比x大，不能自动转换，需强制x = （int）（x + i）

注意：复合赋值表达式自动地将所执行计算的结果转型为其左侧变量的类型 2. 判断奇数

public boolean isOdd(int i){ return i % 2 == 1; //return i % 2 != 0; }

注意：当取余操作返回一个非零的结果时，它与左操作数具有相同的正负符号

3. 逻辑操作符&&和位运算符&区别

注意：&是位运算符，可以进行逻辑运算，但不会逻辑短路 4. 条件运算符

int a = 20; int b = 10; char c = 'x'; int i = 0;

System.out.println(a > b ? c : 0); System.out.println(a < b ? i : c);

注意：除非彻底理解表达式行为的复杂规范，通常最好在条件表达式中使用类型相同的第二和第三操作数 5. 类型转换

System.out.println((int)(char)(byte) - 1);

注意：计算机中，数都以补码的形式存放，正数的补码是其本身，负数的补码是其绝对值取反加1；

如果补码的符号位为“0”,表示是一个正数,所以补码就是该数的原码；

如果补码的符号位为“1”,表示是一个负数,求原码的操作可以是:符号位为1,其余各位取反,然后再整个数加1.

类型转换时，如果最初的数值类型是有符号的，那么就执行符号扩展；如果它是char，那么不管将要被转换成什么类型，都执行零扩展 三）作业： 1. 编程

exercise/chap03

第四章：数组

一）基础实验：

1. 数组基础（声明、创建、初始化、赋值）测试例子 example/chap04/src/ArrayTest.java example/chap04/src/ArrayTest2.java 2. 求一组数的平均值

example/chap04/src/ArrayAvgTest.java 3. 求一组数的最大值

example/chap04/src/ArrayMaxTest.java 4. 冒泡排序

example/chap04/src/ArraySortTest.java

5. java辅助类?java.util.Arrays辅助类的sort(int[] n)以及binarySearch(int[] n,int key)

example/chap04/src/ArraySortTest2.java 6. 随机抽取中奖手机号码

example/chap04/src/RandomTelphone.java 7. 产生4位验证码

example/chap04/src/ValidateCode.java 8. 多维数组测试例子

example/chap04/src/MultiArray.java 9. 填充二维方阵

example/chap04/src/Martrix.java 10. 数组拷贝

example/chap04/src/ArrayCopy.java 二）扩展实验：

1. 产生100个[1,6]的整数，并统计每个整数出现的频率 example/chap04/src/Frequency.java 三）作业： 1. 编程

exercise/chap04

第五章：面向对象编程

1） 基础实验：

1） java的三大特性是哪些?每个特性的具体含义是什么? 2） 范围修饰符有几种?分别代表什么范围? 3） 什么是构造器?

a) 构造器就是和类名相同但无返回类型的方法 4） 重写和重载的区别?

a) 重写是子类的方法覆盖父类的方法，要求方法名和参数都相同 b) 重载是在同一个类中的两个或两个以上的方法，拥有相同的方法

名，但是参数却不相同，方法体也不相同，最常见的重载的例子就是类的构造函数

5） 类的创建和初始化

i.example/chap05/Employee.java ii.example/chap05/EmployeeTest.java

6） 参数传递

i. example/ch05/ParamterTest.java ii. example/chap05/Student.java 7） this关键字的使用

a) example/ch05/Student.java b) example/ch05/StudentTest.java 8） 类的创建顺序

a) example/ch05/ObjectInit.java 9） 重载的构建

a) example/ch05/OverloadTest.java 10） 继承的使用

a) example/ch05/Person.java b) example/ch05/Employee.java c) example/ch05/EmployeeTest.java 11） 说明super关键字的使用情况

a) 可以调用父类的属性和方法

b) 可以区分子类和父类的属性和方法 c) 调用父类构造器 12） 多态的练习

a) example/ch05/Shape.java b) example/ch05/ShapeTest.java

2） 扩展实验：

a) 参考值传递和引用传递的不同方式来分析书上ParamterTest.java程序 i. 前两个输出i值都为2 基本类型参数值传递的过程是参数拷贝过程 ii. 第三个输出是”zhao”,”male”,20,第四个输出是”larry”,”male”,20

引用类型参数值传递的过程是堆区地址传递的过程

iii. 最后两个输出都是”zhao”,”male”,20.最后一个的参数又重新开辟的 一段内存,与原来的不是同一个地址,所以互不影响.

b) 通过实例说明一下重载的二义性，提出解决办法 i. 处理结果存在不确定性

eg:add(int a,float b) add(float a,int b) add(10,10)

ii. 强制类型转换或者精确对应参数 c) 什么时候使用instanceof关键字

i. 当一个变量没办法说明在哪一个类域时,通过使用instanceof关键字

可以进行判断

ii. if(kevin instanceof Manager) {

Manager manager = (Manager)kevin; }.

三）作业： 1.编程

exercise/chap05

第六章：高级语言特性

1） 基础实验：

1).static变量和实例变量的区别?

a) static变量对于每个类而言在内存中只有一个，能被类的所有实

例所共享；实例变量对于每个类的每个实例都有一份，它们之间互不影响；

b) Java虚拟机在加载类的过程中为static变量分配内存，实例变量

在加载完类后创建对象时分配内存；

c) static变量存在方法区，实例变量存在堆区；

d) static变量可以直接通过类名访问，实例变量通过引用类型变量

访问；

2） 分析Count.java代码，说明里面所对应的值.

a) 第一次count值为1 serialName值为1 b) 第二次count值为2，serialName值为2 3） Static的使用

a) example/ch06/DogTest.java

4) 利用static实现单例模式 example/ch06/SingletonTest.java

4） Final修饰符的作用?

a) Final修饰的变量是不能被更改 b) Final修饰的class不能被继承 c) Final修饰的方法不能被重写 5） Final的使用

a) examle/ch06/FinalTest.java 6） abstract修饰符的作用?

a) 可用来修饰类和成员方法。

i. 用abstract修饰的类表示抽象类，抽象类不能实例化，即不允许

创建抽象类本身的实例。没有用abstract修饰的类称为具 体类，具体类可以被实例化。

ii. 用abstract修饰的方法表示抽象方法，抽象方法没有方法体。

抽象方法用来描述系统具有什么功能，但不提供具体的实现。 iii. 没有abstract修饰的方法称为具体方法，具体方法具有方法体。 b) 语法规则；

1) 抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类；

2) 没有抽象构造方法，也没有抽象静态方法；

3) 抽象类中可以有非抽象的构造方法；

4) 抽象类及抽象方法不能被final修饰符修饰。

7） abstract的使用

example/ch06/AnimalTest.java 8） 描述接口

a) 一个类只能继承一个直接的父类，但能实现多个接口

b) 接口是抽象类的抽象，抽象类可存在有方法体的方法，接口中的

方法全部为抽象方法

c) 接口中的所有方法均是抽象方法， 默认都是public、abstract类

型的

d) 接口中的成员变量默认都是public, static, final类型，必须被显式

初始化

e) 接口中没有构造方法，不能被实例化 9） 接口的使用

a) example/ch06/Runner.java b) example/ch06/PersonTest.java c) example/ch06/Test.java d) example/ch06/CatTest.java e) example/ch06/DriverTest.java 10） 内部类的使用

a)

静态内部类：

i. 静态内部类的实例不会自动持有外部类的特定实例的引用，在创

建内部类的实例时，不必创建外部类的实例 ii. 静态内部类可以直接访问外部类的静态成员，如果访问外部类的

实例成员，就必须通过外部类的实例去访问。 iii. 在静态内部类中可以定义静态成员和实例成员

iv. 可以通过完整的类名直接访问静态内部类的静态成员 b) 实例内部类：

i. 在创建实例内部类的实例时，外部类的实例必须已经存在

ii. 实例内部类的实例自动持有外部类的实例的引用。在内部类中，

可以直接访问外部类的所有成员，包括

成员变量和成员方法

iii. 外部类实例与内部类实例之间是一对多的关系，一个内部类实例

只会引用一个外部类实例，而一个外部类实例

对应零个或多个内部类实例。在外部类中不能直接访问内部类的成员，必须通过内部类的实例去访问。

iv. 实例内部类中不能定义静态成员，而只能定义实例成员 v. 如果实例内部类B与外部类A包含同名的成员，那么在类B中，

this.v表示类B的成员， A.this.v表示类A的成员。 vi. 局部内部类和实例内部类一样，可以访问外部类的所有成员，此

外，局部内部类还可以访问所在方法中的final类型

的参数和变量

c) 局部内部类；

i. 在一个方法中定义的内部类，它的可见范围是当前方法。和局部

变量一样，局部内部类不能用访问控制修饰符

(public, private和protected)及static修饰符来修饰

ii. 局部内部类和实例内部类一样，不能包含静态成员 11） 内部类的使用

a) 实例内部类：

example/ch06/InstanceInnerClass.java b) 静态内部类：

example/ch06/StaticInnerClass.java c) 局部内部类

example/ch06/LocalInnerClass.java d) 匿名内部类

example/ch06/AnonymousInnerClass.java e) 内部类

example/ch06/ RobotTest.java

12） 封装类的作用

1) 用引用类型表示数值；例如表示一个缺考学生的成绩； 2) 有些场合必须要引用类型；例如集合中只能存储引用类型； 3) 实现基本类型间以及与字符串间转换； example/ch06/IntegerTest.java

13) 集合 a) Collection和Iterator接口 1).在Collection接口中声明了适用于Set和List的通用方法： boolean add(Object o): 向集合中加入一个对象的引用； void clear(): 删除集合中的所有对象引用，即不再持有这些 对象的引用；

boolean contains(Object o): 判断在集合中是否持有特定对象

的引用；

boolean isEmpty(): 判断集合是否为空；

Iterator iterator(): 返回一个Iterator对象，可用它来遍历

集合中的元素；

boolean remove(Object o): 从集合中删除一个对象的引用； int size(): 返回集合中元素的数目；

Object[] toAttray(): 返回一个数组，该数组包含集合中的所

有元素；

2) Iterator接口隐藏底层集合的数据结构，向客户程序提供了

遍历各种类型的集合的统一方法。Iterator接口中声明方法：

hasNext(): 判断集合中的元素是否遍历完毕，如没有，就返

回true;

next(): 返回下一个元素；

remove(): 从集合中删除上一个由next()方法返回的元素； b) List接口及其实现类的使用

主要特征是其元素以线性方式存储，集合中允许存放重复对象。 主要实现类包括：

1）ArrayList: 代表长度可变的数组。允许对元素进行快速的 随机访问，但是向ArrayList中插入与删除元素的速度较慢； 2）LinkedList: 在实现中采用链表结构。对顺序访问进行了优化，向List中插入和删除元素的速度较快，随机访问速度则相对较慢。随机访问是指检索位于特定索引位置的元素。 3）Vector类：与ArrayList一样也实现了List接口，表示一个可变的对象数组；

与ArrayList的差别：Vector是同步（线程安全）的，占用的资源多一些，运行效率要低一些，主要用在多线程环境下，ArrayList是不同步的，适合在单线程环境下使用 4）使用：

example/ch06/ArrayListTest.java

c) Set接口及其实现类的使用 Set集合中存放的是对象的引用，并且没有重复对象。 主要实现类包括： 1）HashSet: 按照哈希算法来存取集合中的对象，存取速度比较快； 2）LinkedHashSet: HashSet子类，不仅实现Hash算法，还实现

链表数据结构，链表数据结构能提高插入和删除元素的性能；

3）TreeSet: 实现SortedSet接口，具有排序功能； 4)使用： example/ch06/HashSetTest.java example/ch06/Student.java example/ch06/HashSetTest2.java example/ch06/TreeSetTest.java

example/ch06/TreeSetTest1.java

d)Map接口及其实现类的使用 Map是一种把键对象和值对象进行映射的集合，它的每一个元

素都包含一对键对象和值对象。向Map集合中加入元素时，必须提供一对键对象和值对象，从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。

主要实现类包括： 1）HashMap

按哈希算法来存取键对象，有很好的存取性能，为了保证

HashMap能正常工作，和HashSet一样，要求当两个键对象

通过equals()方法比较为true时，这两个键对象的hashCode()

方法返回的哈希码也一样。

2）TreeMap

实现了SortedMap接口，能对键对象进行排序。和TreeSet

一样，TreeMap也支持自然排序和客户化排序两种方式。

3)使用 example/ch06/HashMapTest.java 14) 反射 a)一个对象或者类获得自身的Class对象的过程称为反射。

b)有两种方法可以获得自身的Class对象引用(对每一个被装载的类 型(类或接口)，虚拟机都会为它创建一个 java.lang.Class的实例)：

i) Class c = Class.forName(“com.briup.ch06.Student”); //虚拟机中没有该类的Class的实例对象 ii) Class c = stu.getClass(); //虚拟机已经存在Class的实例对象

Class c = this.getClass(); //虚拟机已经存在Class的实例对象 c) 利用反射编程的基本步骤 i) 获得Class对象； ii) 利用Class对象的方法获得类型的相关信息； iii) 访问/操作类型成员。 d)使用

example/ch06/ReflectTest1.java example/ch06/User.java

example/ch06/ReflectTest2.java example/ch06/ReflectTest3.java

2） 扩展实验：

1）抽象类和接口比较

1. 相同点：

a. 都不能被实例化； b. 都能包含抽象方法；

2. 不同点；

a. 抽象类中可以为部分方法提供默认的实现，从而避免子类中重

复实现它们，提高代码的可重用性，而接口中只能包含抽象方法；

b. 一个类只能继承一个直接的父类，这个父类有可能是抽象类；但一个类

可以实现多个接口，这是接口的优势所在。 2)几种内部类的区别

a. 声明的位置:

静态内部类：类的内部，方法的外部，用static关键字修饰； 实例内部类：类的内部，方法的外部，不用static关键字修饰； 局部内部类：方法的内部；

匿名内部类：既可以在类的内部，方法的外部，也可以在方法的内部；

b. 实例化方式:

静态内部类：new Outer.Inner(); //在外部类外创建； new Inner(); //在外部类

内内部类外创建

实例内部类：new Outer().new Inner(); //在外部类外创建； this.new Inner(); //在外部类

内内部类外创建

局部内部类：new Inner(); //只能在方法内部创建； 匿名内部类：new 类名() {}; 强制类型转换或者精确对应参数

c) HashMap和HashTable的区别

i).hashMap去掉了HashTable 的contains方法，但是加上了 containsValue（）和containsKey（）方法。

ii).hashTable同步的，而HashMap是非同步的，效率上逼hashTable要高。

iii).hashMap允许空键值，而hashTable不允许。

三）作业： 1.编程

exercise/chap06

第七章：异常

一）基础实验：

1.异常基本概念

a). 异常产生的条件, 或者称为异常情况。在Java代码中哪些是异常情况呢？ 例如：

i. 整数相除运算中，分母为0;

ii. 通过一个没有指向任何具体对象的引用去访问对象的方法； iii. 使用数组长度作为下标访问数组元素； iv. 将一个引用强制转化成不相干的对象；

等等；

b). 异常会改变正常程序流程;

异常产生后，正常的程序流程被打破了，要么程序中止，要么程序

被转向异常处理的语句； c). 当一个异常的事件发生后，该异常被虚拟机封装形成异常对象抛出。 d). 用来负责处理异常的代码被称为异常处理器 f). 通过异常处理器来捕获异常 2.try…catch语句

在Java语言中，用try...catch语句来捕获处理异常。格式如下： try {

可能会出现异常情况的代码； } catch(异常类型 异常参数) { 异常处理代码

} catch(异常类型 异常参数) { 异常处理代码 }

1). 如果try代码块中没有抛出异常，try代码块中语句会顺序执行完，catch代码块内容不会被执行；

2). 如果try代码块中抛出catch代码块所声明的异常类型对象，程序跳过try代码块中接下来代码，直接执行catch代码块中对应内容;

a. 可以存在多个catch代码块，究竟执行哪个，看抛出的异常对象是否是catch代码块中异常类型；

b. 异常只能被一个异常处理器所处理, 不能声明两个异常处理器处理相同类型的异常；

c. 多个catch语句块所声明的异常类型不能越来越小； d. 不能捕获一个在try语句块中没有抛出的异常；

3). 如果try代码块中抛出catch代码块未声明的异常类型对象，异常被抛给调用者；哪个调用了这段语句块哪个负责处理这个异常；

4)使用 example/ch07/PropertiesTest.java 3.finally语句

任何情况下都必须执行的代码 Example/ch07/ExceptionTest.java

4.异常层级关系

所有异常类的祖先类为java.lang.Throwable类。它有两个直接的子类： 1). Error类：表示仅靠程序本身无法恢复的严重错误，比如内存空间不足，或者Java虚拟机的方法调用栈溢出。在大多数情况下，遇到这样的错误时，建议让程序终止。

2). Exception类：表示程序本身可以处理的异常。Exception还可以分为两种：运行时异常和受检查异常。 a).运行时异常 RuntimeException类及其子类都被称为运行时异常，这种异

常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常时，即使没有用try...catch语句捕获它，也没有用throws子句声明抛出它，还是会编译通过。例如divide()方法的参数b为0, 执行a/b操作时会出现ArithmeticException异常，它属于运行时异常，Java编译器不会检查它。

b). 受检查异常 除了RuntimeException及其子类以外， 其他的Exception

类及其子类都属于受检查异常(Checked Exception)。 这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常时，要么用try...catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

5. 异常声明和处理

1). 使用throw声明代码会倒致异常；

2). 使用try-catch-finally语句结构处理或在方法声明上声明throws继续抛出；

异常处理语句的语法规则：

i). try代码块不能脱离catch代码块或finally代码块而单独存在。try代码块后面至少有一个catch代码块或finally代码块。

ii). try代码块后面可以有零个或多个catch代码块，还可以有零个或至多一个finally代码块。如果catch代码块和finally代码块并存，finally代码块必须在catch代码块后面。

iii). try代码块后面可以只跟finally代码块。

iv). 在try代码块中定义的变量的作用域为try代码块，在catch代码块和finally代码块中不能访问该变量。

v). 当try代码块后面有多个catch代码块时，Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常或其子类的实例，就执行这个catch代码块，而不会再执行其他的catch代码块。

vi). 如果一个方法可能出现受检查异常，要么用try...catch语句捕获，要么用throws子句声明将它抛出。

vii). throw语句后面不允许紧跟其它语句，因为这些语句永远不会被执行。

6.自定义异常

可以定义自己的异常类，继承Exception，必须人工抛出； example/ch07/SelfException

7.断言

JDK1.4引入，在java程序中加入检查语句，主要用于程序调试； 断言机制

在程序中定义的boolean表达式（假定条件）不成立时（即返回false），系统将产生一个Error对象，类型为AssertionError类型； 在约定条件不成立的情况下需要终止程序操作时使用断言；

断言作为Error的一种，断言失败不必进行铺获处理或者声明抛出，一旦出现终止程序，不必进行补救和恢复。 使用

assert boolean表达式[:表达式]

断言用于程序调试，java运行时环境默认关闭断言功能； 开启断言功能：

java -ea classname 或者

java -enableassertions classname

关闭断言功能：

java -da classname 或者

java -disableassertions classname

二）扩展实验： 1. 异常调用栈 异常处理时所经过的一系列方法调用过程被称为异常调用栈。 1). 异常的传播

哪个调用，哪个处理；

a. 异常情况发生后，发生异常所在的方法可以处理；

b. 异常所在的方法内部没有处理，该异常将被抛给该方法调用

者，调用者可以处理；

c. 如调用者没有处理，异常将被继续抛出；如一直没有对异常

处理，异常将被抛至虚拟机；

2). 如果异常没有被捕获，那么异常将使你的程序将被停止。 异常产生后，如果一直没有进行捕获处理，该异常被抛给虚拟

机。程序将被终止。

3). 经常会使用的异常API

getCause()：返回类型是Throwable，该方法获得Throwable的 异常原因或者null。

getMessage()：获得具体的异常出错信息，可能为null。 printStatckTrace()：打印异常在传播过程中所经过的一系列方

法的信息，简称异常处理方法调用栈信息；在程序调试阶段，此方法可用于跟踪错误。

举例：example/ch07/CallStackTraceTest 2.常见的未检查的异常RuntimeException有哪些？分别代表什么含义？ 1). java.lang.ArithmeticException 算术异常 如：除0;

2). java.lang.NullPointerException

空指针引用 如：没初始化一个References便使用; 3). java.lang.ArrayIndexoutofBoundsException

数组越界 如：调用一个有十个元素的Array的第十一个元素

的内容;

4). java.lang.SecurityException 违反了java定义的安全规则

5). java.lang.NumberFormatException

数据格式异常 如：Integer.parseInt(\

6). java.lang.NegativeArraySizeException 数组长度为负数异常 三）作业： 1.编程

exercise/chap07

第八章：GUI

一）基础实验： 1.基础概念 1).GUI:Graphics User Interface 图形用户界面，与用户交互的窗口；

2).AWT：Abstract Window ToolKit抽象窗口工具集

AWT是JDK的一部分，可以说是Java API的子集，其中包括组件、容器和布局管理器等要素；AWT支持Java GUI事件处理；使用AWT可以进行Java GUI的开发； 3). 相关软件包：

java.awt.*：GUI基本组件包；

java.awt.event.*:java GUI事件处理包（用于实现与用户交互）； javax.swing.*:图形界面升级包；

2.组件component

1).组件是图形用户界面的基本组成元素；凡是能够显示在屏幕上并且

能够和用户交互的对象称为组件，例如：菜单、按钮、标签、文本框和滚动条等；

2).组件不能单独的显示出来，必须放在一定的容器中才能显示出来； 3).在java.awt.*包中定义了很多组件类：Button、Menu、Lable、TextField； 4).在java.awt.*包中有一个抽象类java.awt.Component，该类是除了Menu类之外所有组件类的功能父类，其中定义了GUI组件的基本特征，例如：尺寸、位置、颜色等；还实现了作为GUI组件应该具备的基本功能； 3.容器Container 1).容器本身也是一个组件，所以Container是Component的子类；具

有组件具有的所有性质，只是容器组件可以容纳其他组件或者容器； 2). 容器具有add()方法用于添加其他组件到容器中； 3). 容器分类： a)java.awt.Window 可以自由停泊的顶级窗口；例如：Frame

b)java.awt.Panel

可以作为容器容纳其他组件，但是不能独立存在，必须添加到其他容器；例如：添加到Frame中；

4).使用

example/ch08/FrameTest.java 4.布局管理器 用来控制组件在容器中的排列风格；包括组件的位置和大小的设定；

每个容器都有一个默认的布局管理器，当容器需要对某一组件进行定位或者判断其大小尺寸时，就会调用对应的布局管理器； 一个容器只能有一种排列风格； 1).FlowLayout FlowLayout是Panel容器的默认布局管理器

布局效果：

a).组件在容器中逐行加入，行内自左向右，排满一行后换行； b).不改变组件大小，按原始大小加入；

c).组件在容器中默认居中对齐，也可以通过构造方法设置对齐方式，行间距，组件间距； d)使用：

example/ch08/FlowLayoutTest.java 2).BorderLayout BorderLayout布局管理器是Frame默认的布局管理器； 布局效果：

a).BorderLayout将容器划分为东西南北中五个区域，组件只能被添加到指定的区域；

b).添加组件时如果没有指定添加区域，默认添加到Center区域； 一个区域只能放一个组件，如果在一个区域添加多个组件，则先前添加的组件将作废；

c).组件大小被强行控制，大小与指定区域大小相同； d).使用

example/ch08/BorderLayoutTest.java 3).GridLayout GridLayout布局效果：

a).将容器划分为规则的矩形网格，按照组件的加入顺序自左向右逐行 加入，行间自上而下，将组件放入单元格；

b).组件大小被强行控制，和单元格大小相同，随着容器的大小变化，组件大小自动调整，但相对位置不变； c).使用

example/ch08/GridLayoutTest.java 4).CardLayout a).将多个组件放在容器的同一区域内交替显示，就像落在一起的扑克牌只显示最上面的一张；

b).CardLayout可以按照名称显示某一张卡片，或者按照顺序依次显

示每一张卡片，也可以直接定位到第一张、下一张、上一张或者最后一张；

c).使用：

example/ch08/CardLayoutTest.java

5. 容器嵌套

容器嵌套可以使得原本只能显示一个组件的区域可以显示多个组件； example/ch08/ContainerNestTest.java

6.GUI程序开发步骤 1).选择容器 2).设置布局管理器 3).向容器中添加组件 4).添加事件处理器 二）扩展实验:

1. 组件定位

1）Java组件在容器中的定位由布局管理器决定； 2）如果人工控制组件的定位，可取消布局管理器； 3）使用Component的方法进行组件定位; setLocation(),setSize()，setBounds()

void setBounds(int x, int y, int width, int height) void setSize(int width, int height) void setLocation(int x, int y)

GUI的坐标系：窗体以屏幕的左上角为原点，容器中的组件以容器的左上角为原点

2. 1)Frame窗体： Frame的类层次结构：java API java.lang.Object java.awt.Component java.awt.Container java.awt.Window java.awt.Frame

a)、Frame对象的显示效果是一个可以自由停泊的“顶级”窗体；带有标题和尺寸重置角标；

b)、Frame默认是不可见得，可以调用Frame的setVisible(true)方法设置为可见；

c)、作为容器Frame可以使用add()方法添加组件； 2).Panel面板： 提供容纳组件的空间，不能独立存在，必须添加到其他容器中； 可以采用与所在容器不同的布局管理器； 三）作业: 1.编程

exercise/chap08

第九章：GUI事件处理模型

一） 基础实验 1.GUI事件处理机制

GUI事件处理机制和异常处理机制类似，JDK为GUI组件的各种可能操作预先定义了事件类，如果用户触发了组件的某一操作，组件将产生对应事件类的事件对象，此时将根据事件对象执行注册在该组件上的监听器与事件对象相对应的方法（当然提是对于关心的组件事件，已经在组件上注册了对应的监听器并实现了事件处理方法）。

当用户与GUI交互，比如移动鼠标、按下鼠标键、单击Button按钮、在文本框内输入文本、选择菜单项或者关闭窗口时, GUI会接收到相应的事件，即各种可能的操作。 事件（用户做了什么操作）---》事件对象（针对组件的）---》执行监

听器对应方法。

2. GUI事件处理三要素：

1) 事件对象：事件就是描述发生了什么事，也可以说是对组件进行了什么操作，在Java中，用事件对象来描述事件，事件一旦被触发组件就产生对应的事件对象，事件对象对应的类一般均是Java API直接提供，自已很少构建事件象类；例如：用户对按钮进行了单击操作，被单击的按钮组件将产生ActionEvent事件对象；

2) 事件源：能够接收用户事件（用户操作）并产生事件对象的GUI组件都被当做事件源，事件源产生事件对象；如按钮、文本框等；

3) 事件监听器：对事件进行处理的对象；该对象定义了能够接收、解析和处理事件的方法，该方法实现与用户交互；

3. GUI事件处理编程

1)定义监听器类，该类实现特定的接口中的对应方法实现即编写自己的程序处理逻辑；

2)组件上添加该监听器对象；从此监听器将对该组件发生的某一操作进行监听，若发生对应事件将执行对应监听器的事件处理方法； 3)使用

example/ch08/EventTest1.java 4. 适配器类：Adapter

1)Adapter是针对大部分的事件监听器接口所定义的对应的实现类，适配器类实现了相应的监听器接口中的所有方法，只不过所有的方法都是空实现即什么事情都不做。

2)为什么要有适配器类？

通过前述实例可以看出，如果要实现GUI的事件处理，要在定义监听器类时实现监听器接口，既然是实现接口必须实现其中所有方法，在实现的方法中可能有些在程序中根本用不到（多重监听器实例中实现了7个方法，只用到3个），当然用不到的方法也只是空实现，尽管是这样这也是程序员十分讨厌的事情。所以出现了Adapter。 3)主要适配器类介绍：

适配器类 实现的接口 MouseAdapter MouseListener

MouseMotionAdapter MouseMotionListener FocusAdapter FocusListener WindowAdapter WindowListener KeyAdapter KeyListener

ComponentAdapter ComponentListener ContainerAdapter ContainerListener

4)在JDK中定义的适配器类都是abstract的，其实这不是必须的，只是怕程序员误用；

5)适配器类不能完全替代监听器接口； 6)监听器类经常使用内部类实现； 7)使用

example/ch08/AdapterTest.java 二） 扩展实验

1. 多重监听器

1)、同一事件源可以注册多个监听器；

2)、同一事件源的同一种事件对象可以注册多个监听器； 3)、一个监听器可以被多个事件源注册。 example/ch08/ MutiListenerTest.java

2. GUI事件类型

1)事件类型

java.util.EventObject

ActionEvent：描述鼠标在菜单、按钮等组件上进行点击的事件。

AdjustmentEvent：描述组件或者容器的大小发生变化或者重置事件。 ItemEvent：描述组件条目发生变化事件，例如当列表框中条目发生变化或者被选中。

TextEvent：描述当文本框或者文本域中内容发生变化事件。

ContainerEvent：描述当向容器加入组件或者从容器移除组件事件。 FocusEvent：描述焦点事件，例如组件获得或者失去焦点时触发的事件。 InputEvent：描述用鼠标、键盘进行输入事件。 KeyEvent：描述键盘按键被按下或释放事件。

MouseEvent：描述鼠标按下、移动、单击、双击等事件。

WindowEvent：描述当窗口初始化、最大化、最小化、关闭或者销毁事件。 三） 作业 1.编程

exercise/chap09

第十章：线程

一）基础实验：

1.线程和进程的区别?

线程与进程的主要区别在于：每个进程都需要操作系统为其分配独立的内存地址空间，而同一进程中的所有线程在同一块地址空间中工作，这些线程可以共享同一块内存和系统资源。比如共享一个对象或者共享已经打开的一个文件。

2.线程的有几个部分组成,每个部分的作用是什么? . 方法区: 存放了线程所执行的字节码指令;

. 堆 区: 存放了线程所操纵的数据(以对象的形式存放); . 栈 区: 保存了线程的工作状态；

3.如何创建和启动线程?

1). 扩展java.lang.Thread类

Thread类代表线程类，它的最主要的两个方法是： . run()——包含线程运行时所执行的代码； . start()——用于启动线程； 2). 实现Runnable接口 public void run();

启动：Thread(Runnable runnable) //当线程启动时，将执行参数runnable所引用对象的run()方法

4.线程的创建和启动

/ example/ch10/Machine.java

/example/ch10/MachineOfStart.java

5.熟悉API中有关Thread的使用

Java.lang.Object，Java.lang.Thread，Java.util.Concurrent 6.简述线程的几种状态? 1). 新建状态(New)

用new语句创建的线程对象处于新建状态， 此时它和其他Java对象一样；仅在堆区中被分配了内存； 2). 就绪状态(Runnable)

当一个线程对象创建后，其他线程调用它的start()方法， 该线程就进入就绪状态，Java虚拟机会为它创建方法调用栈。

处于这个状态的线程位于可运行池中， 等待获得CPU的使用权。 3). 运行状态(Running)

处于这个状态的线程占用CPU，执行程序代码。在并发运行环境

中， 如果计算机只有一个CPU, 那么任何时刻只会有一个.线程处于这个状态。如果计算机有多个CPU, 那么同一时刻可以让几个线程占用不同的CPU，使它们都处于运行状态。只有处于就绪状态的线程才有机会转到运行状态。

4). 阻塞状态(Blocked)

指线程因为某些原因放弃CPU， 暂时停止运行。当线程处于阻塞

状态时，Java虚拟机不会给线程分配CPU，直到线程重新进入就绪状态，它才有机会转到运行状态。

5). 死亡状态(Dead)

当线程退出run()方法时，就进入死亡状态，该线程结束生命周期。线程有可能是正常执行完run()方法退出，也有可能是遇到异常而退出。不管线程正常结束还是异常结束，都不会对其他线程造成影响。

7.线程状态的使用 /example/ch10/ MachineOfBlockStatus.java

8.什么是线程调度?线程如何调度?

线程的调度是指按照特定的机制为多个线程分配CPU的使用权。

有两种调度模型：

a.分时调度模型：让所有线程轮流获得CPU的使用权，并且平均分配每个线程占用CPU的时间片。

b.抢占式调度模型：优先让可运行池中优先级高的线程占用CPU，如果可运行池中线程的优先级相同，那么就随机选择一个线程，使其占用CPU。处于可运行状态的线程会一直运行，直至它不得不放弃CPU描述接口

9.线程调度的使用 /example/ch10/ MachineOfAttemper.java

10.线程同步有哪些特性?

1). 如果一个同步代码块和非同步代码块同时操纵共享资源，仍然会造成对共享资源的竞争。因为当一个线程执行一个对象的同步代码块时，其他线程仍然可以执行对象的非同步代码块。 2). 每个对象都有唯一的同步锁。

3). 在静态方法前面也可以使用synchronized修饰符。此时该同步锁的对象为类对象。静态内部类可以直接访问外部类的静态成员，如果访问外部类的实例成员，就必须通过外部类的实例去访问。 4). 当一个线程开始执行同步代码块时，并不意味着必须以不中断的方式运行。进入同步代码块的线程也可以执行Thread.sleep()或者执行Thread.yield()方法，此时它并没有释放锁，只是把运行机会(即CPU)让给了其他的线程。 5)synchnozied声明不会被继承。

11.线程同步的使用

/example/ch10/Account.java /example/ch10/AccountTest.java 12.线程的死锁的含义？

A线程等待B线程持有的锁，而B线程正在等待A持有的锁 13.简述线程的优先级

所有处于就绪状态的线程根据优先级存放在可运行池中，优先级低的线程获得较少的运行机会，优先级高的线程获得较多的运行机会。Thread类的setPriority(int)和getPriority()方法分别用来设置优先级和读取优先级。优先级用整数来表示，取值范围是1-10，Thread类有以下3个静态常量。

MAX_PRIORITY: 10, 最高;

. MIN_PRIORITY: 1, 最低;

. NORM_PRIORITY: 5, 默认优先级 二）扩展实验：

1)分析Transitioning between Thread States中的那幅图 (page312) 2)什么是银行家算法? 我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家

管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。为保证资金的安全，银行家规定：

1.当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客；

2.顾客可以分期贷款，但贷款的总数不能超过最大需求量； 3.当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付，但总能使顾客在有限的时间里得到贷款；

4.当顾客得到所需的全部资金后一定能在有限的时间里归还所有的资金. 操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。若超过则拒绝分配资源，若能满足则按当前的申请量分配资源，否则也要推迟分配 三）作业： 编程

exercise/chap10

第十一章：I/O流

13） 基础实验：

1.简述流以及字节流和字符流

在Java中，把一组有序的数据序列称为流。根据操作的方向，可以把流分为输入流和 输出流两种。

如果数据流中最小的数据单元是字节，那么称这种流为字节流；如果数据流中最小的数据单元是字符，那么称这种流

为字符流。在I/O类库中，java.io.InputStream和java.io.OutputStream分别表示字节输入流和字节输出流，

java.io.Reader和java.io.Writer分别表示字符输入流和字符输出流。

2.详细介绍InputStream和OutputStream 1.InputStream类提供了一系列和读取数据有关的方法 1).read(): 从输入流读取数据

1. void close(): 关闭输入流，InputStream类本身的close()方 法不

执行任何操作。它的一些子类覆盖了close()方法，在 close()方法中释放和流有关的系统资源。

2. int available(): 返回可以从输入流中读取的字节数目 3. skip(long): 从输入流中跳过参数n指定数目的字节 ii. OuputStream类提供了一系列和写数据有关的方法

1. write(): 向输出流写入数据

2. void close(): 关闭输出流，OutputStream类本身的close()方法不

执行任何操作。它的一些子类覆盖了close()方法，

在close()方法中释放和流有关的系统资源

3. void flush():通过带缓冲区的输出流写数据时，数据先保存在缓

冲区中，积累到

一定程度才会真正写到输出流中。缓冲区通常用字节数组实现，实际上是指一块内存空间

3.分析流的层次结构

1. ByteArrayInputStream: 把字节数组转换为输入流；

2. FileInputStream: 从文件中读取数据；

3. PipedInputStream: 连接一个PipedOutputStream;

4. SequenceInputStream: 把几个输入流转换为一个输入流；

5. ObjectInputStream: 对象输入流；

6. FilterInputStream: 过滤器，扩展其它输入流功能； 4.Buffered的使用

/ example/ch11/BufferedReaderTest.java /example/ch11/BufferedWriterTest.java

5.DataInputStream的使用 DataInputStream 实现了DataInput接口，用于读取基本类型数 据，如int, float, long, double和boolean

readByte():从输入流中读取1个字节，指它转换为byte类型的数 readLong():从输入流中读取8个字节，转换为long类型的数据； readFloat():从输入流中读取4个字节，转换为float类型的数据； readUTF():从输入流中读取1到3个字节，指它转换为UTF-8字符编码的字符串

/example/ch11/FormatDataIO.java 6.PipedInputStream的使用

/example/ch11/PipeTest.java 7.Reader and Writer的使用 /example/ch11/ReaderObject.java /example/ch11/WriterObject.java 8.FileReader and FileWriter的使用 /example/ch11/FileStringTest.java用FileReader修改一下

9.简述File类的作用 File类提供管理文件或目录的方法 构造方法

1. . File(String pathname): 参数pathname表示文件路 径或

者目录路径

2. . File(String parent, String child): 参数parent表示根路径，

参数child表示子路径

3. . File(File parent, String child): 参数parent表示根路径，参

数child表示子路径；

普通方法

4. . boolean createNewFile()：创建一个新的文件，如果文件已

经存在，则创建失败（返回false），否则创建

5. 成功（返回true）

6. .boolean delete()：删除文件或者空目录

7. .boolean mkdir()/mkdirs()：创建一个或者多个目录（连续

创建）->如果该目录的父目录不存在话，那么还会创建所 8. 有的父目录；

9. . boolean renameTo(File destination)：文件的改名

10. . boolean canRead()/canWrite()：判断指定的文件是否能读

取或者写入数据

11. . boolean exists()：判断指定的文件或者目录是否存在 12. . String[] list()：返回指定目录下所有文件名或者子目录名所

组成的字符串数组

13. . String getPath()/getAbsolutePath()：返回指定文件或者目

录的路径和绝对路径

14. . String getCanonicalPath(): 获取该File对象所代表的文件

或者目录的正规路径

15. . String getParent()/getName()：返回指定文件或者目录的父

目录（没有返回null）和名字

10.FileInputStream and FileOutputStream的使用

/example/ch11/Copy.java /example/ch11/Copy2.java

11. ObjectInputStream 和ObjectOutputStream的使用 /example/ch11/Student.java /example/ch11/ReaderObject.java /example/ch11/WriterObject.java 二）扩展实验：

1)简述RandomAccessFile的特点？ 1.实现数据的输入和输出 2. 用它能够提供读写文件的功能 3. 提供通过一个文件指针从文件的某一个断点开始读写数据的功能 /example/ch11/ExpressCopy.java 2)dest文件可以输出多少个字节? try{

FileOutputStream fos = new FileOutputStream(“dest”);

DataOutputStream dos = new DataOutputStream(fos);

dos.writelnt(3);

dos.writeDouble(0.001);

dos.close();

fos.close();

}catch(IOException e){}

A.2

B.8

C.12

D.16

E.它依赖于所存在的操作系统 答：C 三）作业： 编程

exercise/chap11 第十二章：网络编程 14） 基础实验：

1.简述计算机网络的作用 2.简述Ip和Port的作用

3.简述ftp,telnet,http,smtp,pop的端口号和相关协议的作用 4.简述OSI参考模型,作用和相关协议 5.学会使用有关网络的API 6.基于TCP的Socket编程步骤 1)服务器程序编写 2)客户端程序编写

7.基于TCP的Socket编程的使用 /example/chap12/ConcurrencyTimeTcpServer.java /example/chap12/TimeTcpClient.java /example/chap12/TimeTcpServer.java 8.基于UDP的Socket编程步骤： 1)服务器程序编写 2)客户端程序编写

9.基于UDP的Socket编程的使用 /example/chap12/TimeUdpClient.java /example/chap12/TimeUdpServer.java /example/chap12/URLConnectionTest.java 二）扩展实验：

)简述TCP和UDP网络编程的不同?

三）作业： 编程

exercise/chap12

本文来源：https://www.bwwdw.com/article/53ep.html