5. 安全性面向网络 分布式环境的 Java 语言是目前安全性最佳的编程语言 6. 跨平台性 Java 解释器采用与体系结构无关的字节代码指令技术, 只需安装 Java 运行系统就可以保证 Java 程序在网络上的任何地方运行 7. 可移植性跨平台性保证了软件的可移植性,Java 类库具有可移植性,

Transcription

1 全国计算机等级考试二级教程 Java 语言程序设计基本要求 1 掌握 Java 语言的特点, 实现机制和体系结构 2 掌握 Java 语言中面向对象的特性 3 掌握 Java 语言提供的数据类型和结构 4 掌握 Java 语言编程的基本技术 5 会编写 Java 用户界面程序 6 会编写 Java 简单应用程序 7 会编写 Java 小应用程序 (Applet) 8 了解 Java 的应用 主要内容第 1 章 Java 语言概述第 2 章简单数据类型第 3 章运算符和表达式第 4 章流程控制第 5 章类 数组和字符串操作第 6 章异常处理第 7 章输入输出及文件操作第 8 章线程与对象串行化第 9 章编写图形用户界面第 10 章 Applet 程序设计 第一章 Java 语言概论 大纲要求 (1)Java 语言的特点及实现机制 (2)JDK 目录结构 (3)Java 的 API 结构 (4) 开发环境设置 (5)Java 源程序结构重要考点提示根据对历年真题的分析可知, 本章考核内容约占 13%, 主要包括以下几个方面 : (1)Java 语言与其他语言 (2)JDK 目录结构和 API 结构 (3)Java 源程序的程序结构 (4)JDK 工具的使用, 如编译器 解释器 调试器等 1.1 Java 语言的特点及优势 Java 是一种网络编程语言, 与其他编程语言相比, 具有以下特点 : 1. 简单易学其基本语法与 C++ 类似, 但除去 C++ 中的指针操作 运算符重载 多重继承等难以理解的内容, 大大降低了学习的难度 2. 利用面向对象技术 Java 把所有的 Java 应用和 Applet 都看作对象, 按类进行封装, 与其他面向对象程序设计语言相比, Java 对面向对象技术的利用更加彻底 3. 分布式计算 Java 类库支持 TCP/IP 协议, 应用程序可以通过 URL 地址访问网络上的任何对象 4. 健壮性 ( 鲁棒性 ) (1)Java 是一种强类型语言 ;(2)Java 不允许使用指针访问内存, 更不允许使用指针数组访问内存 ; (3) 有自动收集垃圾功能

2 5. 安全性面向网络 分布式环境的 Java 语言是目前安全性最佳的编程语言 6. 跨平台性 Java 解释器采用与体系结构无关的字节代码指令技术, 只需安装 Java 运行系统就可以保证 Java 程序在网络上的任何地方运行 7. 可移植性跨平台性保证了软件的可移植性,Java 类库具有可移植性,Java 本身也具有可移植性 8. 解释执行 Java 语言用字节码进行解释执行, 使其连接过程更加简单 9. 多线程多线程是 Java 程序的并发机制, 能同步共享数据 处理不同的事件 10. 动态性 Java 类库可以自由的增加新方法或实例 通过接口实现多重继承, 使类继承具有更灵活的扩展性, 可以随时插入构件和数据库 11. 高性能字节码易直接转换成一些特定 CPU 的机器码 12.Applet 的特点 Applet 是 Java 的一类特殊应用程序, 它嵌入 HTML 中, 实现多媒体的用户界面或复杂的计算 Applet 要求在支持 Java 的浏览器上运行, 使得互联网上的信息能够很容易的实现动态性和交互性 考题 : 1.Java 语言与 C++ 相比, 其最突出的特点是 ( C ) (2007 年 4 月 ) A) 面向对象 B) 高性能 C) 跨平台 D) 有类库 2. 在 Java 语言中, 不允许使用指针体现的 Java 特性是 ( D ) (2006-4) A) 可移植性 B) 解释执行 C) 健壮性 D) 安全性 3. 下列关于 Java 语言的特点, 错误的是 ( A ) (2006 年 9 月 ) A)Java 是面向过程的编程语言 B)Java 支持分布式计算 C)Java 是跨平台的编程语言 D)Java 支持多线程 4.Applet 是能够嵌入 ( HTML ) 格式文件中, 并在浏览器中运行的 Java 类 1.2 Java 语言的实现机制 (1)Java 虚拟机 Java 语言的执行模式是半编译和半解释型 Java 程序首先由编译器转换为标准字节码, 然后由 Java 虚拟机来解释执行 虚拟机 (VM) 的执行过程有 3 个特点 : 1) 多线程 2) 动态连接 3) 异常处理 (2) 垃圾回收机制 Java 有一个系统级的线程, 对内存的使用进行跟踪, 使程序员从繁忙的内存管理中解放出来 (3) 代码安全机制

3 Java 程序的安全性体现在多个层次上, 如编译层 解释层 平台层上都有相应的安全检测机制 1.3 Java 的体系结构 (1)Java 体系结构 (2)JDK 的目录结构 bin 目录下有编译器 解释器和许多工具 demo 目录下有各种演示例子 include 目录下是 win32 子目录, 包含本地方法文件 jre 目录是 Java 运行环境的根目录 lib 目录下都是库文件 src.zip 是源码压缩文件 考题 : 1. 运行 Java 程序需要的工具软件所在的目录是 ( A ) A)JDK 的 bin 目录 B)JDK 的 demo 目录 C)JDK 的 lib 目录 D)JDK 的 jre 目录 1.4 Java 的 API 结构 Java 的类库包括核心 Java 包 Javax 扩展包和 Org 包 (1)Java 核心包 java.lang 包 : 封装所有编程应用的基本类, 如 Object Class System String Integer Thread 等 Object 是所有类的根, 它所包含的属性和方法被所有类继承 Class 类是由编译器自动生成对象的一个特殊类, 它伴随每个类 Class 对象包含所属类的所有信息, 可以通过 Class 类的方法来访问这些信息 System 类是一个特殊类, 它是一个 final 类, 所有的方法都用类变量来调用, 即对 System 类不能实例化, 主要提供标准输入 / 输出和系统环境信息的访问 设置 System.out

4 考题 : 2. 下列关于 System 类的叙述, 错误的是 ( C ) System 类是一个 final 类 B) System 类不能实例化 C) System 类中未定义属性 D) System 类中主要提供系统环境参数的访问 3. 任何 Java 程序都默认引入一个包, 这个包的名字称为 java. Lang 4. 在 Java 语言中, 有一个类是所有类或接口的父类, 这个类的名称是 Object 5. Class 类是 Java 编译器自动生成的, 它伴随每个类 (1)Java 核心包 java.awt 包 封装抽象窗口工具包, 提供构建和管理用户图形界面的功能 java.applet 包 为 Applet 提供执行需要的所有类 java.io 包 提供程序输入 / 输出文件操作的类 java.net 包 提供程序执行网络通信应用及 URL 处理的类 java.rmi 包 提供程序远程方法调用所需的类 java.math 包 提供程序常用的整数算术以及十进制算术的基本方法类 java.util 包 提供实用程序类和集合类, 如日期方法类 集合 数组类 java.sql 包 提供访问和处理标准数据源数据的类 java.security 包 提供网络安全操作类 java.text 包 提供所有处理文本 日期 数字以及非自然语言的消息操作类 java.bean 包 提供开发编写 java bean 所需的类 (2) 扩展包 Javax javax.naming 包 提供命名服务所需的类和接口 javax.swing 包 提供构建和管理应用程序的图形界面的轻量级构件 javax.rmi 包 提供远程方法调用的应用程序接口 javax.transaction 包 提供事务处理所需的类 javax.sound 包 提供多媒体声音要求的 MIDI 输入 / 输出以及合成操作的基本类 javax.accessibility 包 提供用户界面构件之间相互访问机制的基本类 (3)Org 包 Org 包是一些有关国际组织的标准 考题 : 6. 在下列 Java 语言的包中, 提供图形界面的包是 ( B ) A) java.io B) javax.swing C) java.net D) java.rmi 7.Java 的核心包中, 提供编程应用的基本类的包是 ( A ) A) java.lang B) java.util C) java.applet D) java.rmi 1.5 Java 源程序结构 Java 程序包括源代码, 由编译器生成的类文件, 有归档工具 jar 生成的.jar 文件 对象状态序列化.ser 文件 其中源代码的结构如下 : (1)package 语句 0 或多个, 用于使文件存入指定包中, 这条语句必须置于文件之首 (2)import 语句 0 或多个 必须在所有类定义之前引入标准类 (3)public class Definition( 公共类定义 ),0 或 1 个, 指定应用程序类名, 需与源文件名一致 (4)class Definition,0 或多个, 类定义 (5)interface Definition,0 或多个, 接口定义 Java 是区分字母大小写的 源文件与程序类 ( 即公共类 ) 名字相同 其扩展名为.java 源文件中最多只能有一个 public 类, 其他类的个数不限 考题 : 8. 用来导入已定义好的类或包的语句是 ( B )

5 A) main B) import C) public class D) class 9. 下列关于 Java 对 import 语句规定的叙述中, 错误的是 ( C ) A) Java 程序中的 import 语句可以有多条 B) Java 程序中可以没有 import 语句 C) Java 程序中必须有一条 import 语句 D) Java 程序中的 import 语句必须引入在所有类定义之前 1.6 Java 程序编写及运行的过程 (1) 编写和运行 Java Application 程序的步骤 : 1) 选用一个文本编辑器, 不要用 word 带格式的编辑器 2) 用编译器 javac.exe 对 Java 程序进行编译 3) 用解释器 java.exe 解释执行所生成的.class 文件 (2) 编写和运行 Java Applet 应用程序的步骤 : 1) 编写源代码 此程序不含 main() 方法 2) 编写 HTML 文件来调用这个小程序 3) 编译过程与 Java Application 应用程序相同 4) 解释命令为 appletviewer filename.html Java 应用程序 (Java Application) 举例 Java Applet 实例 (3)JDK 工具 1) javac.exe Java 编译器 命令格式 : javac [ 选项 ] 文件名 ( 全名 ) 选项 : -g 输出文件中的行号及局部变量信息, 用于调试程序 -o 对类文件进行优化编译 -nowarn 关闭警告信息, 只显示错误信息 -verbose 显示源代码文件和字节码文件的相关信息 -d< 目录 > 指定生成的类文件的存放位置 - 路径 / 目录 2) java.exe Java 解释器, 执行字节码程序 命令格式 : java [ 选项 ] 类名 [ 程序参数 ] 选项 : -debug 将程序连接到调试器 -ms 分配内存初值 -mx 分配内存的最大值, 默认值为 16MB -noverify 不进行字节代码验证 -v 每装载一个类, 就打印一条消息 3) javadoc.exe Java 文档生成器, 对 Java 源文件和包以 MML 格式产生 AP 文档 制作源文件类结 构的 HTML 格式文档 命令格式 :javadoc [ 选项 ] 包名或 javadoc[ 选项 ] 文件名 选项 : -verbose 显示行为信息 - 路径 / 目录 指明包的路径 /HTML 文件所存目录 使用 javadoc 时, 也可以使用参数 -d 指定生成文档所在的目录, 如 :javadoc d C:\lx test.java 4) Javap.exe Java 类分解器, 对.class 文件提供字节代码的反汇编并打印 查看源码类中的 public 方法名字和 public 成员变量了名字 命令格式 :javap [ 选项 ] 类名 选项 : -c 打印出每个类中方法的 JVM 指令

6 -l 在原来的打印信息上增加私有及保护方法和变量例 :javap java.awt.button 将列出 Button 中的 public 方法和 public 成员变量 5) jdb.exe Java 调试器 命令格式 :jdb [ 解释器选项 ] 类名或 jdb[-host 主机名 ] -password 选项 : 重复上一次输入的命令 catch[ 异常类 ] 在激活异常时, 将自动产生一个断点 ignore[ 异常类 ] 关闭一条 catch 命令 cont 继续指向行 dump[ 标识 ] 打印对象的所有域值 help? 显示所有 jdb 命令 method[ 类名 ] 列出此类中的所有方法 run[ 类 ] [ 参数 ] 将参数传递给 main() 方法, 并执行它 use[ 源文件路径 ] 给出 jdb 调试类所对应的源代码文件的路径 6) javaprof.exe Java 剖析工具, 提供解释器剖析信息 命令格式 :javaprof [ 选项 ] 选项 : -v 打印额外信息 7) appletviewer.exe Java Applet 浏览器 命令格式 :appletviewer[-debug] URL 选项 : -debug 表示在 jdb 中启动 URL 指定所嵌入 Applet 的 HTML 文件名 考题 : 10. 以下叙述中, 错误的是 ( D ) A) javac.exe 是 Java 的编译器 B) javadoc.exe 是 Java 的文档生成器 C) javaprof.exe 是 Java 解释器的剖析工具 D) javap.exe 是 Java 的解释器 11.JDK 中所提供的文档生成器是 ( C ) A) java.exe B) javap.exe C) javadoc.exe D) javaprof.exe 12. 在执行 Java 程序时, 将应用程序连接到调试器的选项是 ( B )07-4 A) D B) debug C) verbosegc D) -mx 13. 在编译 Java 程序时, 用于指定生成 class 文件位置的选项是 ( B ) A) g B) d C) -verbose D) -nowarn 第 2 章简单数据类型概论 大纲要求 (1) 变量和常量 (2) 基本数据类型及类型转换 (3)Java 类库中对简单数据类型的类包装重要考点提示根据对历年真题的分析可知, 本章考核内容约占 5%, 主要包括以下几个方面 : (1)Java 标识符的命名规则 (2) 整型变量的 3 种表示方法 (3) 转义字符的表示方法及常见转义字符的含义 (4) 浮点型数据的 float 和 double 两种类型 (5) 数据类型转换 (6) 各数据类型的表示范围

7 2.1 Java 标识符的命名规则 标识符是用来标识类名 变量名 方法名 类型名 数组名 文件名的有序字符序列 简单地说, 标识符就是一个名字 例如 : Test MyIsAClass username _user $dollar myname a b flag up12 CHANG_LIANG (1) 标识符是以字母 下划线 (_) 美元符($) 作为首字符的字符串序列, 在首字符后面可以跟字 母 下划线 (_) 美元符($) 和数字 (2) 标识符区分大小写 Boy 与 boy 是不同的 (3) 标识符的字符数目没有限制, 但为了便于阅读和记忆, 不宜太长 Java 语言使用 Unicode 字符集, 它的字母 : A -- Z a z 以及序号大于 0xC0 的所有 符号 有关 Unicode 字符集的详细信息, 可在 网站上查到 Java 中的保留字不允许作为一般标识符应用 常用的保留字有 abstract,boolean,break,byte,catch,class,continue,final,new 等 Java 语言中的关键字 abstract boolean break byte case catch char class continue default do double else extends false final finally float for if implements import instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient true try void while 合法标识符 :username ituser _sysvar $den $_app 非法标识符 :2unit #room 401room Java 的一般命名规则 : (1)_ $ 不能作为变量名和方法名的开头 ; (2) 变量名 方法名的首字母小写, 直至第一个完整的单词结束, 其余单词首字母大写 ;myname (3) 接口名 类名单词的第一个字母均大写 ;IsAClass (4) 常量名完全大写 CHANG_LIANG 考题 : 1. 下列属于合法 Java 标识符的是 ( D ) A) ABC B) &5678 C) +rriwo D) saler 2. 下列标识符命名规则中, 正确的是 ( D ) A) 类名的首字母小写 B) 变量和方法名的首字母大写 C) 接口名的首字母小写 D) 常量名完全大写 3. 在 Java 中, 所有数据类型的长度都是固定的, 因此没有保留字 ( sizeof ) 注释是程序中的说明性文字, 是程序的非执行部分 在程序中加注释的目的是为了使程序更加易读易理解, 有助于修改程序以及他人阅读 (1) // 注释内容 表示从 // 开头直到此行末尾均作为注释 例如 : //comment line (2) /* 注释内容 */ 表示从 /* 开头, 直到 */ 结束均作为注释, 可占多行 例如 :

8 /* comment on one or more line */ (3) /** 注释内容 */ 表示从 /** 开头, 直到 */ 结束均作为注释, 可占多行 例如 : /** documenting comment having many line */ public class HelloWorld { public static void main(string args[]) { System.out.println( Hello World! ); /* 在屏幕上输出 Hello World!*/ } } 2.2 常量与变量变量定义 : 变量是在程序的运行过程中其值可以被改变的量 变量有变量名 变量类型 变量属性 变量初值组成 变量名是合法的标识符 变量类型有两大类 : 基本类型和复合类型 变量属性是描述变量的作用域, 按作用域分类有局部变量 类变量 方法参数和异常处理参数 变量初值是该变量的默认值 Java 中的变量遵循先声明后使用的原则 声明的作用有两点 : 一是确定该变量的标识符 ( 即名称 ), 以便系统为它指定存储地址和识别它, 这便是 按名访问 原则 ; 二是为该变量指定数据类型, 以便系统为它分配足够的存储单元 常量定义 : 是指在程序的整个运行过程中其值始终保持不变的量 Java 语言用 final 关键字来定义常量 常量与变量一样也有各种类型 常量和变量举例 : int a1,b1,c1; //a1,b1,c1 变量为整数型 int d1,d2=10; //d1,d2 变量为整数型,d2 的初值为 10 char ch1,ch5; //ch1,ch5 变量为字符型 final float PI=3.1416; //PI 常量为浮点型, 值为 Java 语言的数据类型 : 提示 :Java 语言没有无符号整数类型 指针类型 结构类型 联合类型 枚举类型, 这使得 Java 编程简单易学

9 2.3 简单数据类型 整型数据 1. 整型常量整数型常量有 3 种表示形式 : (1) 十进制整数 如 :56,-24,0 (2) 八进制整数 以零开头的数是八进制整数 如 :017,0,0123 (3) 十六进制整数 以 0x 开头的数是十六进制整数 如 :0x17,ox0,0xf,0xD 十六进制整数可以包含数字 0~9 字母 a~f 或 A~F 整型常量在计算机中默认值占 32 位, 分 byte,short,int 和 long 4 类, 分别占 8,16,32,64 位, 对于 long 类型整型常量书写表示时, 要在数字后面加 l 或 L 2. 整型变量 Java 语言提供了 byte,short,int,long 4 类型的整型变量 Java 语言提供了 4 个整型常值变量 提示 :int 类型是最常用的整数类型,long 类型用于大型计算 整型变量的默认值为 0. 整型变量举例 : byte a, d, h; // 定义 a,d,h 为字节型变量 short ss,ff; // 定义 ss 和 ff 为 short 型的变量 int i, x, y; // 定义 i,x,y 为 int 型变量 long u1,u2; // 定义 u1,u2 为 long 型的变量 2.4 简单数据类型 浮点型数据浮点型数据属于实型数据, 分 float 和 double 两种 浮点型数据有数字和小数组成, 必须有小数点, 小数位数越多, 表示越精确 1. 实型常量十进制书写格式 : 如 等 ; 科学计算格式 : 256e3 或 256E3. 要求 e/e 之前必须有数字, e/e 必须是整数 实型常量在计算机中存储分 float 和 double 型, 如 E2f 或 E2F 表示 float 浮点数, 在

10 计算机内存储占 32 位 ; 如 E2D 或 E2d 或 E2 表示 double 双精度浮点数, 在计算机内存储占 64 位 提示 : 如数字后没有任何字母, 计算机默认为 double 型 2. 实型变量 实型变量举例 : float f1,y1; // 定义 f1,y1 变量是单精度 float 实型 double s1,p1; // 定义 s1,p1 变量是双精度 double 实型 2.5 简单数据类型 布尔型数据布尔型数据只有两个值 :true( 真 ) 和 false( 假 ) 一般用于逻辑判断, 在计算机内存占一个字节 默认值为 false 布尔型变量举例 : boolean tt=true; // 定义 tt 变量为布尔型, 初值为 true. 2.6 简单数据类型 字符型数据用单引号括起的单个字符 这个字符可以是 Unicode 字符集中的任何字符 例如 : s, * 用单引号括起的转义字符 用反斜线 \ 开头, 后面跟一个字母来表示某个特定的控制符, 这便是转义字符 字符串常量是用双引号括起的 0 个或多个字符串序列 字符串中可以包括转义字符 如 : he","two \n","124\n"," " Java 语言中转义字符的描述 : \ddd 表示 1-3 位的八进制数据 (ddd) 所代表的字符

11 \uxxxx 表示 1-4 位的十六进制数据 (xxxx) 所代表的字符 \ 表示单撇号字符 \ 表示双撇号字符 \\ 表示反斜杠字符 \r 表示回车 \n 表示换行 \b 表示退格 \f 表示走纸换页 \t 表示横向跳格 提示 :Unicode 字符集比 ASCII 字符集更丰富, 它们是 16 位无符号数据, 如 \141 和 \u0061 都表示字符常量 a. 字符变量 : 2.7 各类数据之间的转换 Java 语言的各种数据之间转换有两种 : 自动转换和强制转换 (1) 自动转换只能将位数少的数据类型向位数多的数据类型转换 自动转换的优先级次序如下 : byte,short,char >int >long >float >double (2) 将较长的数据类型转换成较短的数据类型时, 只能使用强制转换, 通常用赋值语句来实现, 在要施加强制转换的变量名前用 () 括上所要强制转换的类型符 例如 : short s; byte b=(byte)s; 不同类型数据之间的转换规则 :

12 2.8Java 类库中对简单类型数据的类包装在 Java 语言中, 简单数据类型是类包装在类库中的 Boolean,Character,Byte,Double,Float,Integer,Long,Short 类都声明为 final 属性, 不能被其他子类继承,

13 利用这些类, 可用变量值作为参数来创建对象, 并使用它们 例如 : Integer int1 = new Integer(66); int a1 = int1.intvalue(); 考题 : 4. 下列布尔型变量的定义中, 正确且规范的是 ( B ) A)BOOLEAN canceled=false; B)boolean canceled=false; C)Boolean CANCELED=false; D)boolean canceled=false; 5. 下列叙述中, 正确的是 ( A ) A) 声明变量时必须指定一个数据类型 ; B)Java 认为变量 number 和 Number 相同 ; C)Java 中唯一的注释方式是 // ; D) 源文件中的 public 类可以有 0 或多个 6. 下列代表十六进制整数的是 ( D ) A)0123 B)1900 C)fa00 D)0xa2 7. 在 Java 中, 转义字符 \n 表示 ( 换行 ) 在 Java 中, D 表示的是 ( 双精度浮点 ) 数 第 3 章运算符与表达式 大纲要求 (1) 运算符 (2) 表达式运算 (3) 表达式语句重要考点提示根据对历年真题的分析可知, 本章考核内容约占 7%, 主要包括以下几个方面 : (1) 运算符的分类及相互之间的优先级关系 (2) 操作数的类型转换 (3) 表达式结果的处理 3.1 运算符运算 : 对各种类型的数据进行加工的过程 运算符 : 表示各种运算的符号 操作数 : 参与运算的数据 按运算符所涉及的操作数的数目划分 : (1) 一元运算符 :++,--,+,- 如 ++a (2) 二元运算符 :+,-,> 如 a+b; a>b; (3) 三元运算符 :?: 如 a>b?1:0; 按运算符的功能划分 : (1) 算术运算符 :+, -, *, /, %,++,-- 例如 : 3+2 a-b i++ --I (2) 关系运算符 :>, <, >=, <=, ==,!=, 例如 : count>3 i==0 n!=1 (3) 布尔逻辑运算符 :!, &&,, 例如 : flag=true!(flag) flag&&false (4) 位运算符 :>>, <<, >>>,&,, ^, ~, 例如 : a= ; b= ; 有如下结果 : a<<3= ; a>>3= ; a>>>3= ; a&b= ;

14 a b= ; ~a= ; a^b= ; (5) 赋值运算符 = 及扩展 +=, -=, *=, /= 等例如 : i=3; i+=3 等效于 i=i+3; (6) 条件运算符 :?:, 例如 : result=(sum==0?1:num/sum); (7) 其他运算符 3.2 表达式表达式是由操作数和运算符按一定的语法形式组成的符号序列 表达式的类型是指表达式运算结束后的结果的类型 例如 : 1. x,y,z 都是布尔型变量, 则表达式 x&&y z 就是布尔表达式 2.num1,num2 都是整型变量, 则表达式 num1+num2 就是整型表达式 3.3 算术运算符和算术表达式算术表达式由操作数和算术运算符组成 在算术表达式中, 操作数只能是整型或浮点型数据 (1) 一元算术运算符 1) 一元加 (+) 和一元减 (-) 表示针对某个操作数的符号, 其结果为此操作数的正值或负值 2) 增量运算符 (++) 将操作数加 1, 减量运算符 (--) 将操作数减 1.

15 ++x,--x 表示在使用 x 之前, 先使 x 的值加 ( 减 )1 x++,x-- 表示在使用 x 之后, 使 x 的值加 ( 减 )1 注意 : 粗略的看,++x 和 x++ 的作用相当于 x=x+1 但 ++x 和 x++ 的不同之处在于,++x 是先执行 x=x+1 再使用 x 的值, 而 x++ 是先使用 x 的值再执行 x=x+1 如果 x 的原值是 5, 则 : 对于 y=++x;y 的值是 6 对于 y=x++;y 的值是 5, 然后 x 的值变为 6 (2) 二元算术运算符二元算术运算符有两个操作数, 由两个操作数加一个二元算术运算符可构成一个算术表达式 二元算术运算符共有 5 个

16 二元算术运算符适用于所有数值型数据类型, 包括整型和浮点型 如果操作数全为整型, 只要其中有一个是 long 型, 表达式结果也为 long 型 两个操作数全是 byte 或 short 型, 表达式结果是 int 型 两个操作数是浮点型, 只要其中一个为 double 型, 表达式结果为 double 型, 否则为 float 型

17 Java 对 + 进行了扩展, 使它能够进行字符串的连接 如 abc + de 得到字符串 abcde ; + 能够将字符串和其他类型的数据进行连接, 其结果是字符串 如 abc +3 得到字符串 abc3, 3.0+ abc 得到字符串 3.0abc ; 如果 + 运算符的第一个操作数是字符串, 则 Java 系统会自动将后续的操作数类型转换为字符串类型, 然后再进行连接 ; abc 结果是 abc345 ; 如果 + 运算符的第一个操作数不是字符串, 则运算结果由后续的操作数决定 如 abc 结果是 12abc, 而不是 345abc (3) 算术运算符的优先级在稍微复杂一些的算术表达式中, 算术运算符的优先级的次序排列为 : 1)++ 和 -- 的级别最高 ; 2)* / % 次之 ; 3)+ 和 - 级别最低另外, 通过括号可以明显地改变运算的顺序

18

19 3.4 关系运算符和关系表达式关系运算符用来比较两个操作数的关系 关系运算符的运算结果是 boolean 型 当运算符对应的关系成立时, 运算结果是 true, 否则是 false 不能用 0 或 1 来代替 false 或 true 结果为数值型的变量或表达式可以通过关系运算符形成关系表达式, 例如,4>8,(x+y)>80.

20 例如 : 表达式 15>18 的值为 false 表达式 15<18 的值为 true 表达式 15>=18 的值为 false 表达式 15<=18 的值为 true 表达式 15==18 的值为 false 表达式 15!=18 的值为 true 对于复合数据类型数据的 == 运算, 其比较的目标是两个操作数是否是同一个对象 要比较两个对象的值是否相同, 则用 equals() 方法 equals() 方法在在 Java 的根类 Object 中其功能跟 == 运算符一样, 是比较两个操作数是否是一个对

21 象 equals() 方法在自己定义的类中, 功能也是跟 == 运算符一样, 除非自己定义的类中重写了 equals() 方法 Java 类库中许多子类都重写了 equals() 方法, 使其功能变为比较两个操作数的内容是否一样 如 String 考题 :

22 3.5 布尔逻辑运算符和布尔逻辑表达式布尔逻辑表达式有关系表达式和布尔运算符组成 实现对关系表达式的值进行布尔逻辑运算, 运算结果也是布尔型 && 是二元运算符,! 为一元运算符 &&, 运算采用 短路 的方式计算 先计算出左侧表达式的值 (1) 运算符 && 左边的表达式值若为 false, 则不用计算右边的表达式的值, 整个表达式的值为 false

23 (2) 运算符 左边的表达式值若为 true, 则不用计算右边的表达式的值, 整个表达式的值为 true 关系运算符和布尔逻辑运算符的优先级关系 :! 优先级最高其次是 > >= < <= 再次是 == 和!= 然后 && 优先级最低的是 使用括号可以改变优先级次序 3.6 位运算符和位运算表达式位运算表达式由操作数和位运算符组成, 实现对整数类型的二进制进行位运算

24 1. 按位取反 : ~ 例如 : 取反后变为 按位与 :& (1) 按位与可以用来屏蔽特定的位 (2) 可以用来取某个数中某些指定的位例如 :int thebit=i&16; //16 的二进制为 按位或 : (1) 按位或可以用来置某些特定的位为 1 例如 : 将整型变量 i 的第 4 位和第 5 位置 1, 可用语句 int setbit=i 24; //24 的二进制为 按位异或 : ^ 两个相应位相同则为 0, 否则为 1. (1) 可以使某个整型数的特定位的值翻转 例如 : 对整型变量 i 的第 4 位翻转 int revert=i^8; //8 的二进制为 1000 (2) 可以不用临时变量完成两个值的交换例如 :int a=15,b=24; //a( ), b( ) a=a^b; //a( ),a=23 b=b^a; //b( ),b=15 a=a^b; //a( ),a=24 5. 不同长度的数据进行位逻辑运算例如 :x y 其中 x 为 long 型,y 为 int 型 (char) 则系统首先会将 y 的左侧 32 位 (48 位 ) 填满 (1) 若 y 为正数, 则左侧填满 0; (2) 若 y 为负数, 则左侧填满 1; 位逻辑运算表达式返回两个操作数中数据长度较长的数据类型 6. 补码的概念在 Java 语言中, 二进制数用补码表示, 最高位为符号位, 正数的符号位为 0, 负数为 1 补码的规定如下 :

25 (1) 正数的最高位为 0, 其余各位代表数值本身 ( 以二进制表示 ) 如 42 的补码为 (2) 对于负数, 把该数绝对值的补码按位取反, 然后对整个数加 1 如-1 的补码为 计算过程 :1 的补码 : 按位取反 : 加 1: 算术右移 :>> 用来将一个数的二进制序列右移若干位 规则 : 低位舍弃, 高位补入原来高位的值 右移一位相当于除 2 取商, 用右移实现除法比除法运算速度要快 例如 : a= //a=55 a>>2= //a>>2=13 8. 算术左移 :<< 用来将一个数的二进制序列左移若干位 规则 : 高位舍弃, 低位补 0 不溢出情况下, 左移一位相当于乘 2, 用左移实现乘法比乘法运算速度要快 9. 逻辑右移 :>>> >>> 和 >> 的区别是 : 执行运算时,>>> 的操作数高位补 0, 而 >> 的操作数高位移入原来高位的值 10. 位运算符的优先级 : 从高到低依次为 : ~ >> << >>> & ^ 例 3.11 int a=-67,b=116,c=78; //a= , b= , c= int d= ~a b&c; int e= ~c>>2&(a ~b); int f= a^b&c; System.out.println("d="+d); System.out.println("e="+e); System.out.println("f="+f); 解析 : int a=-67,b=116,c=78; //a= , b= , c= int f= a^b&c; 计算过程 : b c b&c f // 最高位为 1, 所以是一个负数负数求补码的反过程 : 减 1: 取反 : // 十进制为 7 因为是负数, 所以最后结果为 :-7

26 3.7 赋值运算符和赋值表达式赋值运算符 (=) 用于把一个表达式的值赋给某个变量 < 变量 >< 赋值运算符 >< 表达式 > 在赋值运算符两侧的数据类型不一致时, 如果左侧变量数据类型的级别高, 则右侧的数据被转化为与左侧相同的高级数据类型后赋给左侧变量 ; 否则, 应强制转换类型使之与左侧的数据类型一致 高级 = 低级 ( 自动 ) 低级 = 高级 ( 强制 ) 允许连续赋值, 如 :a=b=c=10;

27 例如 : byte b=121; int i=b; // = 左边是 int 型, 右边是 byte, 自动转换 int a=13; byte b=(byte)a; // = 左边是 byte 型, 右边是 int 型, 需强制类型转换 int j=i+1; 在赋值符 = 前加上其它运算符, 即构成扩展赋值运算符

28 3.8 条件运算符和条件表达式条件运算符是三元运算符, 用? 和 : 表示 一般形式为 : expression1?expression2:expression3 expression1 是关系或布尔逻辑表达式, 计算结果为布尔值 如果 expression1 的值为 true, expression2 的值为整个条件表达式的结果 ; 如果 expression1 的值为 false, expression3 的值为整个条件表达式的结果

29 3.9 运算符的优先级和复杂表达最简单的表达式是一个常量或一个变量当表达式中含有两个或两个以上运算符时, 就被称为复杂表达式 复杂表达式运算时, 要按运算符的优先顺序从高到低进行, 同级的运算符则按照在表达式中出现的位置从左到右的方向进行

30 说明 instanceof 是 Java 的一个二元操作符, 和 ==,>,< 是同一类东西 由于它是由字母组成的, 所以也是 Java 的保留关键字 它的作用是测试它左边的对象是否是它右边的类的实例, 返回 boolean 类型的数据 举个例子 : String s = "I AM an Object!"; boolean isobject = s instanceof Object; 3.10 表达式语句表达式语句是指由表达式直接构成的语句 通常包括 3 种 : (1) 一元算术表达式 ( 由 ++ 或 构成 ) (2) 在赋值表达式后面加上分号 (3) 无返回值的方法调用语句例如 i++; z=x+y; System.out.println( );

31 第 4 章流程控制 大纲要求 (1) 条件语句 (2) 循环语句 (3) 注释语句重要考点提示根据对历年真题的分析可知, 本章考核内容约占 5%, 主要包括以下几个方面 : (1) 对程序中循环体执行次数的判断 (2) 对包含分支语句 循环语句 跳转语句的程序流程的判断 (3) 条件语句的执行的结果 (4)switch 语句中的表达式类型 4.1 概述 Java 的程序流程有若干条语句组成, 每一条语句以分号结束 语句可以是单一的一条语句, 可以是用大括号 {} 括起来的语句块或称符合语句 Java 流程控制包括分支语句 循环语句 跳转语句 异常处理语句等 Java 中没有 goto 语句 4.2 分支语句分支语句的控制机制是 : 根据条件值或表达式值的结果选择执行不同的语句序列, 其他与条件值或表达式值不匹配的语句序列则被跳过不执行 分支语句分为条件语句和多分支语句 (1) 条件语句条件语句根据判定条件的真假来决定执行那一种操作 if 结构 if( 条件 ) statement; 或者 if( 条件 ) { block } 上述 条件 为关系表达式或布尔逻辑表达式, 其值为布尔值 (Java 语言中, 最简单的条件语句是 if 结构 )

32 (2)if-else 结构 if( 条件 ) statement1; 或 { block1} else statement2; 或 { block2} 执行过程 : 若条件为真, 执行 statement1 或 block1, 然后跳过 else 和 statement2 或 block2 执行下面的语句 ; 若条件为假, 跳过 statement1 或 block1, 执行 else 后面的 statement2 或 block2, 然后继续执行下面的语句 注意 :else 子句不能单独作为语句使用, 必须和 if 子句配对使用 三元条件运算符有时可以代替 if-else 结构 result=expression1?expression2:expression3 相当于下列语句 : if(expression1) result=expression2; else result=expression3; (3)if-else if 结构 if( 条件 1) statement1; 或 { block1} else if( 条件 2) statement2; 或 { block2} else if( 条件 N) statementn; 或 { blockn} [else statementn+1; 或 { blockn+1}] 执行过程 : 按照条件 1 条件 2 条件 N 的顺序依次判断条件 I 是否为真, 则执行 statementi; 或 { blocki}, 否则继续判断条件 I+1 如此重复直到条件 N, 最后的 else 语句可有可无

33 (4) 嵌套使用的条件结构条件语句的嵌套可以通过在上述 3 种基本条件语句结构中的代码段 (block) 中嵌入另外的条件语句结构 编写程序时, 需要注意 if 和 else 的匹配 2. 多分支语句多分支语句根据表达式的不同值决定多分支中的哪一个应该执行 switch(expression){ case value1: statement1; break; case value2: statement2; break; case valuen: statementn; break; [default:defaultstatement;] } 使用 switch 多分支语句编写程序应该注意一下几点 :

34 表达式 expression 只能返回几个数据类型的值 :int short byte char case 子句中的值 valuen 必须是常量, 而且所有 case 子句中的值是不同的 default 语句是任选的 break 语句用来在执行完某一 case 分支后, 使程序跳出 switch 语句 statementn 可以是语句序列, 不需要用 {} 括起来 可以使用 if-else 结构实现 switch 语句, 但当所比较的数据类型是 double, 则不能使用 switch 结构 多个相邻的 case 语句执行一组相同的操作, 为了简化编程, 可以使用下面的格式 : switch(expression){ case value1:statement1;break; case valuei: case valuei+1: case valuei+2:statementi+2;break; case valuei+3: statementi+3;break; } // 结束 4.3 循环语句循环语句的控制机制 : 反复执行同一段代码, 直到满足结束条件 一个循环语句一般包括 4 部分 : 初始化部分 (initialization) 循环体部分 (body) 迭代部分 (iteration) 判断部分 (termination) Java 语言提供了 3 种循环结构 :while 循环 do-while 循环和 for 循环 (1)while 循环 while 循环又称为 当型 循环 [initialization] while(termination){ body; [iteration;] }

35 1) 首先初始化控制条件, 这部分是任选的 2) 当布尔表达式 termination 的值为 true, 循环执行大括号的语句,iteration 是任选的, 当某次判断为 false 时, 结束循环 3) while 循环的大括号中的语句块有可能一次都不执行 4) while 循环通常用于循环次数不确定的情况, 也可以用于循环次数确定的情况 (2)do-while 循环 do-while 循环又称为 直到型 循环 [initialization] do{ body; [iteration;] } while(termination); 1) do-while 结构首先执行循环体, 然后计算终止条件表达式的值, 若结果为 true, 则执行循环体中的语句, 直到布尔表达式的结果为 false. 2) 与 while 循环不同的是,do-while 结构的循环体至少被执行一次, 这是 直到型 循环的一个特点

36 (3)for 循环 for 循环可以确定将被执行多少次 for(initialization;termination;iteration) { body; } 1) for 循环执行时, 首先执行初始化操作, 然后判断终止条件是否被满足, 如果满足执行循环体, 最后执行迭代运算 完成一次循环后, 重新判断终止条件 2) 可以在 for 循环的初始化部分声明一个变量, 其作用域为整个 for 循环体 for(int i=0;i<10;i++) { } 3) 在初始化部分和迭代部分可以用带逗号的语句来执行多个操作 for(i=0, j=0; i<j; i++, j++){ } 4) 初始化部分 终止部分以及迭代部分都可以是空语句 ( 但分号不能省略 ) 三者均为空时, 相当于一个无限循环 for(;;){ } 5) for 循环与 while 循环是可以相互转换的 如 :for(i=0,j=10; i<j; i++,j--) { } 等同于 : int i=0; int j=10; while(i<j){ i++; j--; } 乘法表 1 1=1 2 1=2 2 2=4 3 1=3 3 2=6 3 3=9 4 1=4 4 2=8 4 3=12 4 4=16 5 1=5 5 2=10 5 3=15 5 4=20 5 5=25 9 1=9 9 2=18 9 3=27 9 4=36 9 5=45 9 9=81

37

38 注 :1*5,5*4,20*3,60*2,120*1; 第一轮 5>=1, 先执行循环体 4.4 跳转语句 (1)break 语句 break 语句的作用是退出循环, 并从紧跟着该循环语句的第一条语句开始继续执行 一般分为 3 种情况 退出 switch 语句, 执行 break 语句之后, 程序从紧跟着 switch 语句的语句接着往下执行 退出循环 在循环体内执行 break 语句之后, 程序从紧跟着该循环的语句接着往下执行 通过提供一个 标签化中断 的语句实现退出多重循环 格式为 : 标签 :{ 代码块 } break 标签 ; 程序使用 break 语句跳出由标签指定的代码块, 然后从紧跟着该代码块之后的语句接着往下执行 break 标签化中断 举例 : outer: for(int i=0;i<10;i++){ // 外层循环 inner: for(int j=0;j<10;j++){ // 内层循环 if( 条件 ){ break outer;

39 } }// 内层循环结束 }// 外层循环结束 // 跳出块后从这里开始执行 (2)continue 语句 continue 语句的作用是跳过循环体内 continue 语句以下还未执行的语句, 回到循环体的开始重新执行下一轮循环 一般分为两种情况 1) 在单个循环结构中, 跳过循环体下面的语句, 并开始新的一轮循环 2) 在多重嵌套循环中, 通过标签化的 continue 语句跳转到标签指定的外层循环中 基本格式和 break 语句的相似

40 (3)return 语句 return 语句的作用是从当前方法中退出, 回到调用该方法处, 并执行紧接着的下一条语句 一般格式为 : return expression; 或 return; 4.5 循环语句与分支语句的嵌套一个循环体内可以包含另一个完整的循环体, 从而构成多重循环 循环语句也可以与分支语句相互嵌套, 以实现复杂的算法

41 第 5 章类 数组和字符串操作 大纲要求 (1) 面向对象编程的基本概念和特征 (2) 类的基本组成和使用 (3) 对象的生成 使用和删除 (4) 接口与包 (5)Java 类库的常用类和接口 (6) 数组和字符串 (7) 汇集接口重要考点提示根据对历年真题的分析可知, 本章考核内容约占 12%, 主要包括以下几个方面 : (1) 面向对象的含义 (2) 构造方法的特点 (3) 抽象类的特点 内部类的使用方法 (4) 继承 接口的概念 (5) 一维数组 二维数组的定义与数组元素的访问 (6) 字符串与字符数组之间的联系和区别 (7) 常见的字符串处理函数面向对象特性 Java 是一种完全面向对象的程序设计语言, 它的所有数据类型和函数都封装在类中 编写 Java 程序的过程就是从现实世界中抽象出 Java 可实现的类并用合适的语句定义它们的过程 例如 : 现实生活中, 可以看到小汽车 搬运车 公交车等它们都有大小 重量 颜色等属性前进 后退 转弯等功能因而可以将具有这些属性和功能的实体抽象为一类事物, 即汽车类 小汽车 搬运车 公交车等都是汽车类的实例

42 对象的共性抽象出来就是类, 类中定义一类对象共有的属性和方法, 把一个类实例化就生成该类的一个对象 通过对类的定义实现代码的复用 类是一个型, 而对象则是这个型的实例 类是静态的概念, 而对象则是一个动态的概念, 因为只有运行时才给对象分配空间, 对象才真正存在 类定义类是变量和方法的集合体, 是 Java 中基本的结构单元 所有的 Java 语句均出现在类中, 所有的方法均在类中定义 类的成员变量可以是基本数据类型的数据 数组或类的实例 成员方法只在类中定义, 用来处理此类的数据 通常, 类成员数据都是私有的, 而方法都是公有的, 外界只可能访问成员方法 类定义由类声明和类体组成 类必须先定义后使用

43 (1) 类声明的格式 [ 修饰符 ] class 类名 [extends 父类名 ][implements 接口名 ]{ } 说明如下 : 关键字 class 是类定义的开始 ; 类名应符合标识符命名规则, 每个单词的首字母大写并具有类功能特征 ; 修饰符指明类的访问控制符和类型说明符 ; 关键字 extends 指明该类所继承的父类 ; 关键字 implements 指明所实现的接口列表 ; 用 [] 括起来的内容为可选项 类修饰符 : public 访问控制符指明此类为公共类, 可以由其他类访问或引用其成员变量和成员方法 并且 Java 规定包含 main() 方法的主类必须是公共类 默认 friendly 表示此类只能被同一个包的类所访问和引用, 也不用 import 语句引入 在一个.java 文件中只能有一个 public 公共类, 其他类就只能是 friendly 了 abstract 抽象类指明此类不能被实例化 常常为改变其子类而定义 final 最终类指明此类不能有子类 不能被实例化 如 System 类 System.out.println( hello ); (2) 类体的格式 class 类名 { 成员变量声明成员方法声明 } (3) 成员变量声明的格式 [ 修饰符 ] 类型变量名 ; 修饰符有 : public 指明变量为公有, 即程序中的其他类均可访问此类中的变量 protected. 指明变量为受保护访问 可被同一个包中的其他类 不同包中此类的子类以及此类自身所访问和引用 private 指明变量为私有访问 只能被此类自己访问或调用, 是对成员变量的最高级保护 static 指明变量为静态变量, 否则为实例变量 静态变量不需要类的实例化就可以被类直接调用 final 指明变量为常量 常量名要全部大写 transient 指明变量为暂时性变量, 用于实现不同对象的存档功能 volatile 指明多个线程所共享的变量 保证各线程对此变量访问的一致性 成员变量举例 public class JuLi{ public int j=3; private float f=1.0f; char c; final int CHANG_L=100; static doule d; // 以上都为成员变量 public void f(){ } // 成员方法 int f2(){ } // 成员方法

44 } (4) 成员方法是指作为类的成员的方法 方法的定义由方法声明和方法体所组成 方法定义的形式 如下 : returntype methodname( paramlist ) [throws exception] 返回类型 方法名 ( 参数列表 ) 方法声明格式如下 : [ 修饰符 ] returntype methodname( [paramlist] ) [throws exception] { } 修饰符 public, protected, private, static, final 与成员变量声明意义相同, 都是定义方法访问权限 abstract 指明方法是否可以重写 ;native 指明代码是由各种语言集成 ;synchronized 指明多线程可并发 共享访问 Java 方法中的参数传递是传值调用而非地址调用, 因此方法不可以改变参数的值 考题 : 第 3 题知识要点 : abstract 类可以有 abstract 方法, 也可以没有 abstract 方法 对于 abstract 方法, 只允许声明, 不允许

45 实现, 而且不允许使用 final 修饰 abstract 方法 例如 : abstract class Test{ abstract int ftest(int x,int y); int max(int x,int y) return x>y?x:y; } 对于 abstract 类, 不能使用 new 运算符创建对象, 需产生其子类, 由子类创建对象, 如果一个类是 abstract 类的子类, 它必须具体实现父类的 abstract 方法 (5) 方法重载方法的重载是指多个方法可以共享相同的名字, 但参数的个数或数据类型必须不完全相同, 即方法体有所不同, 它实现了 Java 编译时的多态 方法的重载是因为方法在类的继承链中的位置有所不同, 是子类对父类方法的重写 例如下面的程序

46 片段 : (6) 构造方法构造方法是指在使用 new 运算符创建对象时, 有系统自动调用的一种特殊方法, 其主要作用是完成对象的初始化工作 构造方法具有以下特点 : 构造方法名与类名必须相同, 所以方法首字母小写不适用 构造方法是给对象赋值, 没有返回值, 但不用 void 来声明 构造方法不能被程序直接调用 Java 语言默认自动生成一个空的构造方法, 也可以由程序员在类中定义 重载构造方法, 可以在调用时通过参数确定调用哪个方法 若在类中定义了自定义的构造方法, 则必须使用自定义的构造方法初始化, 默认的构造方法无效 构造方法中只能使用成员变量, 而且当参数与成员变量同名时, 只能用关键字 this 指明当前对象 小提示 : 如果程序定义了一个或多个构造方法, 在创建对象时必须用已定义的构造方法来初始化 如 Java 解释器按参数没有找到相应构造方法, 只会报错而不会自动生成空的构造方法 构造方法举例 1----Java 默认构造方法 class A{ private int i; private int j; public static void main(string args[]) { A a=new A(); // 创建对象 a, 但 a 中成员变量未初始化 a.method(); // 调用 method 初始化成员变量 } public void method(){ j=4;i=5; System.out.println("i="+i+"j="+j); } }

47 5.1.2 对象 接口与包 (1) 对象的生成 使用和清除

48 实例化一个类就得到一个对象, 一个对象的生命周期分为 3 个阶段 : 生成 使用和清除 对象的生成 : 对象的生成包括声明 实例化和初始化 3 方面内容 一般格式是先定义一个对象变量, 再用关键字 new 生成一个对象, 并为对象中的变量赋初值 如下所示 : type objectname=new type( [ 参数 ] ); 说明 1)type 声明定义对象的类型, 包括类和接口的复合类型 2)new 实例化一个对象, 调用该类的构造方法, 并为对象分配内存空间 3) 当一个类通过重载定义了几个构造方法时, 用户通过使用不同的参数调用相应的构造方法 对象的生成例如 : Employee em1=new Employee( Harry,40000); Employee em2=new Employee(60000); Employee em3=new Employee(); 对象的使用原则 : 先定义后使用 对象的使用包括访问类成员变量和方法的调用 对象作为类成员使用和作为方法参数 ( 或返回值 ) 使用 1). 运算符实现对成员变量的访问和方法的调用, 格式为 : 对象名. 所调用的方法或变量名 2) 对象作为类成员使用时, 必须首先分配内存, 并且可以用 private 修饰符保证数据安全 3) 对象作为方法的参数时, 采用引用调用 知识点扩展 对象的引用和实体当用类创建一个对象时, 类中的成员变量和方法被分配内存空间, 这些内存空间称为该对象的实体 而对象中存放着引用, 以确保实体由该对象操作使用

49 当方法被调用时, 如果方法有参数, 参数必须要实例化, 即参数变量必须有具体的值 在 Java 中, 方法的所有参数都是 传值 的 也就是说, 方法中参数变量的值是调用者指定的值的副本 1. 基本数据类型参数的传值向该参数传递的值的级别不可以高于该参数的级别, 比如不可以向 int 型参数传递一个 float 值, 但可以向 double 型参数传递一个 float 值 2. 引用类型参数的传值 Java 的引用型数据包括对象 数组以及接口

50 当参数是引用类型时, 传值 传递的是变量的引用而不是变量所引用的实体 两个同类型的引用型变量如果具有同样的引用, 就会用同样的实体 改变参数的引用不会影响向其传值的变量的引用 对象的清除对象的清除是指释放对象所占用的内存空间 Java 语言有自动收集垃圾的功能, 但其操作的优先级较低 程序中可以自定义其他方法来释放对象所占用的内存空间 归纳起来, 对象清除的途径有 : (1) 依靠 Java 的垃圾回收机制回收内存空间 (2) 调用 System.gc() 方法, 请求垃圾回收 (3) Java 系统开始运行时, 自动调用 java.lang.object.finalize() 方法释放内存空间 (4) 在程序中重写的 finalize() 方法释放系统资源, 格式为 : protected void finalize() throws throwable{ super.finalize(); } (2) 接口接口是只含抽象方法或常量的一种特殊的抽象类 接口不包含成员变量和成员方法的实现, 只包含常量和方法的定义 抽象类的概念复习 : 在 Java 语言中, 用 abstract 修饰定义的类称为抽象类, 抽象类不能被实例化, 必须被继承 接口的功能 : (1) 不管类的层次, 可实现互不相关的类具有相同的行为 (2) 通过接口说明多个类所需实现的方法 (3) 通过接口可以了解对象的交互界面, 无需了解对象所对应的类 接口定义有接口声明和接口体所组成 例如 : interface ActionListener // 接口声明 { void actionperformed(actionevent); // 方法定义 } 特别注意 :

51 (1) 接口中的方法默认是 public abstract 方法 (2) 接口中的常量默认是 public static 常量 接口的实现用到关键字 implements 一个类可实现多个接口 例如 : private class InterestAddr implements ActionListener { public void actionperformed(actionevent event ) { double interest=balance*rate/100; NumberFormat fmat=numberformat.getcurrencyinstance(); System.out.println(fMat.format(balance)); } } 特别注意 : (1) 类在实现接口方法时必须给出方法体, 一定要用 public 修饰 (2) 常量可以被类的对象调用, 也可以用类名或接口名直接调用 如果父类使用了某个接口, 则子类也就自然使用了该接口, 子类不必再使用 implements 声明自己使用这个接口 接口可以被继续, 可以通过关键字 extends 声明一个接口是另一个接口的子接口 字接口将继承父接口中的全部方法和常量 接口可以作为一种引用来使用 用接口类型变量将实现该接口的类的实例存入, 通过这些变量去访问类所实现接口中的方法 这样可以对与对象所对应的类无需了解, 把重点放在交互界面上 看下面的程序

52 如果一个类声明实现一个接口, 但没有实现接口中的所有方法, 那么这个类必须是抽象类

53 (3) 包为了同名类发生冲突,Java 采用包来管理类名空间 包为编程提供了一种命名机制, 是一种面向对象方法的封装机制 包将类和接口封装在一起, 便于大量类和接口的管理, 并有利于类和接口的安全 定义一个包要用 package 关键字 包名可以是一个合法的标识符, 也可以是若干个标识符加. 分割而成 package sunny; package com.cwch.gzb; // 与文件目录的层次相同提示 : 用 package 语句说明一个包时, 该包的层次结构必须与文件目录的层次相同 否则在编译时可能出现查找不到的问题 提示 : 使用一个包中的类时, 首先要用关键字 import 导入这些类所在的包 import com.cwch.gzb.*; 提示 : 当包中有相同名字的类, 使用其中类时, 不用 import 导入例如 :Date 类在 java.util 包中, 可编写直接引入类 : class mydate extends java.util.date { } 提示 :Java 语言的 java.lang 包是编译器自动导入的, 编程时不用 import 导入 但使用其他包中的类, 必须用 import 导入 提示 : 在源文件的开始指定包声明, 每个源文件只能有一个包声明 ; 如果没有包声明, 则该类属于 默认包 提示 :import 语句位于所有的类声明之前, 每个源文件可以有多个 import 语句

54

55

56

57

58 5.1.3 类成员修饰符 继承 内部类 类库 (1) 类及类成员修饰符修饰符可分为访问限定符和非访问限定符两类 访问限定符有 public protected private default 等 非访问限定符有 static final abstract synchronized 等下面的表格标出了常用的类成员修饰符 :

59 (2) 继承继承性是面向对象方法的一个重要特征, 它使代码可重用, 可降低程序复杂性 对一个类的继承是指在现有类 ( 父类 ) 基础上构建一个新类 ( 子类 ), 子类重用 ( 继承 ) 父类的方法和属性, 同时还可以向新类中增添新的方法和状态 在 Java 语言中, 继承是通过关键字 extends 实现的 格式为 :class SubClass extends SuperClass{ } 在 Java 中不支持多重继承, 即不可接多条 extends 子句 对类继承的说明 : 用 extends 指明新定义的子类的父类, 在两个类之间建立继承关系 子类可以从父类继承所有非 private 的属性和方法作为自己的成员 Java 语言的类都是直接或间接继承 java.lang.object 得到的 若子类成员变量和父类成员变量名字相同, 则子类成员隐藏父类成员 若子类成员方法与父类成员方法名字 参数列表和返回值类型都相同, 则子类方法是父类方法的重写 方法重写的原则 : 子类方法的访问权限高于父类, 子类方法不能产生比父类更多的异常 对类继承的说明 : (7)super 用来引用当前对象的父类, 有 3 种情况 : 用于访问被隐藏的父类成员变量 super. 变量名 ; 用于调用被重写的父类方法 super. 方法名 ; 用于调用父类的构造方法 super([ 参数列表 ]);

60 多态性多态性是面向对象的另一个重要特性 在 Java 语言中, 体现多态性有两个方面 : 静态和动态静态多态性是指编译时调用重写方法的一种机制, 即同一个方法用不同参数体现程序不同的调用, 这是编译器在编译时自动确定实现的 方法重载体现了静态的多态性 多态的多态性是指运行时, 利用子类继承父类的所有变量和方法功能, 凡是程序使用父类的对象都可用子类的对象来代替 运行时,Java 解释器会按照调用对象类型确定调用子类或父类的方法去执行 (3) 内部类在一个类的内部嵌套定义的类称为内部类 (Inner Class). 内部类具有成员变量和成员方法, 也可以实例化 内部类有它自身的特点 :

61 (1) 内部类的类名只能在定义它的类或程序段中或在表达式中使用, 外部使用它时必须给出全名 (2) 内部类的类名不允许与包含它的类名相同 (3) 内部类可以使用它所在类的静态变量和实例变量, 所在类的方法中的局部变量 (4) 内部类可用 abstract private 或 protected 定义 (5) 内部类可以作为其他类的成员, 而且可以访问它所在类的成员 (3) 除 static 内部类外, 不能在类内声明 static 成员 一旦内部类声明为 static, 就变为顶层类, 不能再使用局部变量

62 考题 : (4) 类库类库以包的形式组织, 是包的集合 J2SE 标准平台有工具软件和 Java 类库 (APIs) 组成 其中 Java 编程所必需的默认引用包为 lang 包, 实用工具包在 util 包中, 用户界面工具在 Swing 包和 AWT 包中 1) Java 中基本的包为 java.lang, 它包括的主要类有 : Object 类是 Java 所有类的根类, 其他类都由它扩展而来 Class 类是用于类操作的类,Class 对象有 Java 编译器自动生成, 隐藏于.class 文件中, 它在运行时为用户提供信息, 还提供运行时装入环境的操作类 ClassLoader System 类是一个 final 类, 不能实例化 主要提供标准输入 输出和系统环境信息 它有 3 个很有用的成员变量 :int out 和 err Thread 类是提供线程操作和管理的类 2)java.util 包包括许多常用功能的复杂接口 : GregorianCalendar 日历类提供日期和时间的表示 Vector 类实现动态分配对象列表, 适用于可变对象数组的类, 它的内存容量可按照需要自动增加 Stack 类是实现先进后出的对象栈, 是 Vector 类的子类 栈中的对象不能直接被访问, 只能从栈顶压入或弹出 Dictionary 类是抽象类, 不能实例化去创建一个对象, 它是关键字和值的数据对存储的集合 5.2 一维数组数组是一种最简单的复合数据类型, 在 Java 中, 数组是作为对象来处理的

63 数组是有限元素的有序集合 数组中的元素具有相同的数据类型, 可用统一的数组名和下标来唯一确定其元素, 元素是数组中不可分的最小单位 一维数组的定义 创建 (1) 定义一维数组的格式 type arrayname[]; 或 type[] arrayname; 说明 : type 可以是 Java 语言中任意的数据类型 数组名是合法标识符,[] 说明变量是数组变量 进行数组定义时, 不分配内存, 因此不要求给出其元素个数数组内存分配通过 new 操作符或静态初始化实现 例如 :char p[]; 声明了一个字符型数组 p[], 它的元素都是字符型数据 (2) 创建一个数组的格式 arrayname=new type[arraysize]; (3) 定义并创建一个数组的格式 : type [] arrayname=new type[arraysize]; 例如 :char w[]=new char[30]; 表示为数组 w 分配分配 30 个字符型数据空间 初始化数组初始化数组是指对已经定义好的数组元素赋值 初始化元素数目较少时采用静态初始化 例如 :int smallprimes[]={2,3,5,7,11,13}; 对简单类型数据的动态初始化, 使用 new 操作符即可 例如 :int a[]=new int[5]; for(int i=0;i<a.length;i++) a[i]=i; for(int i=0;i<a.length;i++) System.out.println( a[ +i+ ]= +a[i]); 对复杂类型数据的动态初始化, 首先使用 new 操作符为每个数组元素分配引用空间 ; 其次对每个元素分配空间并赋值 例如 :String stringarray[]; // 定义 stringarray=new String[3]; stringarray[0]=new String( We ); stringarray[1]=new String( Welcome ); stringarray[2]=new String( you );

64 5.3 多维数组 Java 中没有多维数组这种数据结构, 只有一维数组 Java 中实现的所谓多维数组, 实际上是由一维数组 焊接 成的 数组的数组 一维数组的多次嵌套定义, 构成了多维数组 多维数组的各维长度可能不同, 数组的内存空间也可以不连续 ( 同一维是连续的 ) (1) 二维数组定义 : 二维数组的定义格式为 : type arrayname[][]; 或 type[][] arrayname; 例如 :int intarray[][]; // 定义了另一个二维整型数组与一维数组相同, 在定义时对数组元素并没有分配内存空间, 要对它初始化后, 才能访问它的元素 (2) 初始化二维数组 : 静态初始化 : 即在定义数组的同时分配内存空间例如 :int intarray[][]={{23,12,44},{4,5}}: 动态初始化 ---- 可直接对每一维分配空间 int[][] a=new int[2][3]; // 分配空间 for(int i=0;i<a.length;i++) for(int j=0;j<a[i].length;j++) a[i][j]=(int)(math.random()*100); // 初始化 for(int i=0;i<a.length;i++){ for(int j=0;j<a[i].length;j++) System.out.print(a[i][j]+ ); // 打印 System.out.println(); } 动态初始化 ---- 从最高维开始对每一维分配空间 int b[][]=new int[3][]; // 高维 b[0]=new int[2]; b[1]=new int[2]; b[2]=new int[2]; // 低维 for(int i=0;i<b.length;i++) for(int j=0;j<b[i].length;j++) // 初始化 b[i][j]=(int)(math.random()*100); for(int i=0;i<b.length;i++){ for(int j=0;j<b[i].length;j++) System.out.print(b[i][j]+ ); // 打印 System.out.println(); } 多维数组的各维长度可以不同 int b[][]=new int[3][]; // 高维 b[0]=new int[2]; b[1]=new int[3]; b[2]=new int[2]; // 低维 for(int i=0;i<b.length;i++) for(int j=0;j<b[i].length;j++) // 初始化 b[i][j]=(int)(math.random()*100); for(int i=0;i<b.length;i++){ for(int j=0;j<b[i].length;j++) System.out.print(b[i][j]+ ); // 打印 System.out.println();

65 } 数组边界定义创建一个数组, 数组下标的整数范围是数组的边界 例如 :int a=new int[100]; 数组元素的下标是 0-99, 其中 0 和 99 称之为数组的边界 如果试图访问 a[100] 或任何 0-99 之外的下标时, 如 a[-1]=0; 或 a[100]=0; 都是非法下标, 程序会抛出 : IndexOutOf BoundsException 异常 复制数组数组的拷贝可利用 java.lang.system.arraycopy 方法进行 arraycopy( 源数组, 偏移量, 目标数组, 偏移量, 拷贝数量 ) public class ArrayExample{ public static void main(string args[]){ int[] smallprimes={2,3,5,7,11,13}; int[] luckynumbers={1001,1002,1003,1004,1005,1006,1007}; System.arraycopy(smallPrimes,2,luckyNumbers,3,4); for(int i=0;i<luckynumbers.length;i++)

66 System.out.println(i+" entry after copy is "+luckynumbers[i]); } } 调整数组大小 Java 语言用一种特殊的类 java.util.arraylist( 数组列表 ) 在运行时能动态自动调整数组的大小 ArrayList 类在定义数组时, 不必限定数组的大小 在数组列表初始化时, 可用 add() 方法将数组元素赋值 ArrayList staff=new ArrayList(); staff.add(new Employee( wang,75000,1987,12,1)); staff.add(new Employee( li,5000,1989,10,1)); staff.add(new Employee( zhang,7000,1990,3,15)); 考题 : 5.4 字符串操作字符串是字符的序列, 也是组织字符的基本结构 在 Java 中, 字符串是作为对象出现的, 由 java.lang.string 和 java.lang.stringbuffer 定义, 分别用来处理长度不变和可变的字符串, 这两个类都被定义为 final (1) 字符串常量的表示字符串常量用 括起来的字符序列, 如 How are you 字符串常量可以用来直接初始化一个 String 对象 例如 String s1= 我是 Java 爱好者 ; String s2= Are you student? ; Java 在编译时, 对每个字符串常量都自动生成一个 String 类的实例, 因此一个字符串常量可以直接调

67 用 String 类中的方法 int length= Are you student?.length(); 将返回 Are you student? 字符串的长度 (2) 用 String 类表示字符串在 Java 中,String 类提供构造方法可生成一个空串 String e=new String(); 也可通过字符数组或字节数组来生成一个字符串对象 String(char[] value); String(char[] chars,int startindex, int numchars); 例 5.12 char chars1[]={'t','e','s','t'}; char chars2[]={'t','e','s','t','l'}; String s1=new String(chars1); String s2=new String(chars2,0,4); System.out.println("value of s1 is: "+s1); System.out.println("value of s2 is: "+s2); (3) 用 StringBuffer 类表示字符串 StringBuffer 类提供长度可变子符串的表示, 提供下列构造方法对可变字符串对象进行初始化 StringBuffer(); // 为字符串分配 16 个字符的缓存 StringBuffer(int length) // 提供长度为 length 的缓存 StringBuffer(String str)// 用 str 给出字符串初值, 并分配 16 个字符的缓存凡生成 StringBuffer 的一个对象后, 还可以利用 setlength() 方法或 ensurecapacity() 方法来设定缓存区的大小, 并保证其数组元素的初值都为 字符串的访问 String 类包括的方法有 length() // 提取字符串的长度 charat() // 提取字符串中指定字符 public void getchars(int srcbegin, int end, char buf[],int dstbegin) //srcbegin 指定要提取的第 1 个字符在该字符串的位置 ; //end 指定要提取的最后字符在该字符串的位置 ; //buf[] 是目的字符串存储的数组 //dstbegin 指定提取字符插入目的字符串的位置 String greeting="hello"; char buf[]={'0','0','0','2','2'}; int n=greeting.length(); char last=greeting.charat(4); greeting.getchars(1,4,buf,0); System.out.println("greeting.length()="+n); System.out.println("greeting.charAt(4)="+last); System.out.print("buf="); for(int i=0;i<buf.length;i++) System.out.print(buf[i]); System.out.println(); StringBuffer 类包括的方法有 : length() // 提取字符串的长度 charat() // 提取字符串中指定字符 getchars() // 提取字符串中多个字符 capacity()// 获取字符串的缓存大小例如 : StringBuffer sb=new StringBuffer("test");

68 System.out.println("buffer="+sb); System.out.println("length="+sb.length()); System.out.print("capacity="+sb.capacity()); 查询字符 : 在字符串中查询指定字符或字串时, 可用 indexof() // 输出所查字符或子串在字符串中首次出现位置 lastindexof() // 输出所查字符或字串在字符串中末次位置不成功返回 -1 例如 : String s1=new String("Hello World"); System.out.println(s1.indexOf('o')); System.out.println(s1.lastIndexOf('o')); System.out.println(s1.lastIndexOf('z')); 输出结果为 :4,7, 字符串的修改对 String 的修改 : 通过实例修改固定长度的字符串,String 提供 concat(), replace(),substring(), tolowercase(), touppercase() 等方法 public String concat(string str) // 将当前字符串对象与 str 字符串相连 public String replace(char oldchar,char newchar) // 用新字符替换老字符 public String substring(int beginindex) // 按指定的起始位置获得子字符串 public String substring(int beginindex, int endindex)// 按指定范围去获得字符串中的子字符串 public String tolowercase() // 将字符串中所有字符变为小写 Public String toupper() // 将字符串中所有字符变为大写 String str1="abc"; String str2=str1.concat("cde"); System.out.println(str2); //abccde String str3="hello World!"; String ss=str3.replace(' ','#'); System.out.println(ss); //Hello#World#! String str4="delete"; str4=str4+str3; //Java 允许将字符串用 + 连接起来 System.out.println(str4); //deletehello World! String greeting="hello"; String s=greeting.substring(0,3); //s=hel System.out.println(s); 对 StringBuffer 的修改 : 因为 StringBuffer 类是表示可变字符串, 可以在字符串中插入字符和在字符串尾加字符 缓存不必管理,Java 解释器自动分配 它的方法包括 : append() // 用来在已有字符串末尾添加一个字符串 insert(int offset,string str) // 用来在字符串的索引 offset 位置处插入字符串 str SetCharAt(int index, char ch)// 用来设置指定索引 index 位置的字符值 其他操作 (1) 键盘读取字符串的对话框 javax.swing.joptionpane 用于从控制台键盘读入字符串 String input=joptionpane.showinputdialog( How are you? ); (2) 将字符串对象转换为基本数据类型 int age=integer.parseint(input);

69 考题 :

70 第 6 章异常处理 大纲要求异常的处理重要考点提示根据对历年真题的分析可知, 本章考核内容约占 3%, 主要包括以下几个方面 : (1) 异常处理机制 (2) 常用异常的分类 (3)try-catch 语句的用法异常 Java 语言认为, 那些可预料和不可预料的出错称为异常 (Exception) 提供统一的程序出口, 也是 Java 语言与其他语言不同的特点之一 Java 语言把异常作为一种对象, 在程序运行出错时创建它 异常控制是 Java 语言处理程序出错的一种有效机制 6.1 概述 (1) 异常的定义 : 异常是在程序编译或运行中所发生的可预料或不可预料的异常事件, 它会引起程序的中断, 影响程序正常运行 (2) 异常的处理机制 :

71 在 Java 语言中, 异常的处理机制是 : 一旦出现异常, 可以由运行的方法或虚拟机生成一个异常对象, 它包含异常事件的类型以及发生异常时程序的状态等信息 (3) 抛出异常异常对象从产生到被传递提交给 Java 运行系统的过程称为 (4) 捕获异常 : 在 Java 运行时, 如获得一个异常对象, 它会自动寻找处理该异常的代码, 它从生成异常对象的代码构件开始, 沿着方法调用栈, 按层回溯寻找, 直到找到处理该类异常方法为止 (5)Throwable 类 Throwable 类是直接从 Object 类继承而来的, 所有的异常对象都必须是其实例或其子类的实例, 即 Throwable 类是所有异常类的根 其定义为 : public class Throwable extends Object implements Serializable Throwable 类分为 Error 和 Exception 两个子类 Error 类包括动态连接失败 硬件设备和虚拟机出错等, 通常的 Java 程序不会捕获和抛出这类异常, 而是捕获和抛出 Exception 异常, 它包括运行时所出现的异常, 并对这类异常作出相应的处理 6.2 异常类异常类在 Java 程序中是一种比较特殊的类, 在使用之前必须对其先定义 按异常处理方式不同, 可分为运行异常 捕获异常 声明异常和抛出异常几种 (1) 运行异常无须在编程时定义, 运行时由系统捕获后交给默认异常自测程序, 在标准输出中显示异常的内容和位置 运行异常包括下面几种异常, 这些运行异常都能由 JVM 自动发现并指出 算术异常 (ArithmeticException) 除法分母为零或用 0 取模空指针异常 (NullPointerException) 访问一个空对象类选型异常 (ClassCastException) 当把一个对象强制为某个类, 而该对象又不属于该类 ( 或子类 ) 的实例时数组负下标异常 (NegativeArraySizeException) 数组索引越界异常 (ArrayIndexOutOfBoundsException) (2) 捕获异常要求在程序的方法中预先声明, 调用此方法时就可以捕获相应的异常 其语法格式如下 :

72 (3) 在 Java 语言中, 有时候一个方法生成一个异常, 但此方法并不能确定如何处理这个异常, 必须将异常传递给调用它的方法, 由调用方法来处理 这时方法用声明异常抛出 异常对象可以从调用栈向后传递, 直至有相应的方法捕获它为止 声明异常抛出用 throws 子句来完成声明,throws 子句包含在方法的声明之中, 其语法格式如下 : throws exceptionlist // 异常列表是用逗号分隔的多个异常 (4) 在捕获一个异常之前, 必须先有异常抛出, 才能生成一个异常对象, 即通过抛出异常来实现 抛出异常对象都是通过 throw 语句实现 例如 IOException e=new IOException; throw e; // 抛出的异常类必须是 Throwable 类或其子类

73 throws exceptionlist // 异常列表是用逗号分隔的多个异常小提示 : 利用 throw 语句还可以自定义异常类抛出, 但自定义异常类的 try 语句只包含一条抛出异常语句, 且抛出的异常也必须是 Throwable 类或其子类的实例 6.3 处理异常 (1)try 和 catch 语句在捕获异常时要使用 try-catch 语句, 此语句执行时, 解释器指示可能产生异常的代码段, 形成一个 警戒区 ( 即可能出现异常的程序段 ), 此 警戒区 由 try 引导 catch 子句引导相应的处理方法 catch 子句带有一个异常类参数, 用此参数与抛出异常对象的类进行匹配 如果匹配, 就根据后面的程序段去处理异常, 否则跳到下一个 catch 子句 catch 可同时捕获多种异常 注意 :try 内部不同的方法调用有可能产生相同的异常, 但只需一个 catch 从句

74 try 与 catch 匹配原则 : 1) 不要用一个子类去捕获父类的异常, 尽可能用一个父类去捕获其所有子类的异常 2)catch 从句的顺序排列要注意, 应该将最特殊的排在最前面, 一次逐步一般化 (2)finally 语句捕获异常的统一出口通过 finally 语句实现, 因此对于 catch 而言, 最后一定会执行 finally 语句, 保证控制流在转至其他路径之前, 程序的状态被统一管理 另外, 在系统执行时, 遇到异常就自动发生跳转, 出现在异常后面的语句就不被执行 (3) 异常处理的原则 1) 把应用程序的异常事件进行分类, 利用异常的层次来实行动态控制 在捕获或声明异常时, 应注意要选择适当的异常类, 再选择适当的地方进行处理, 是在方法内部处理还是用 throws 子句传递给调用栈的上层 2) 将异常处理的代码同正常代码区分开, 简化程序结构并增强可读性 如果不知道异常在何时何地发生, 也不知如何处理, 可交给虚拟机处理 3) 利用 finally 语句作为异常处理的统一接口 4) 能用简单测试之处就不要用异常控制, 对异常不要过分细化, 也不要压制, 不要介意对异常的传递 5) 自定义的异常类都是 Throwable 类及子类 除了在运行时所产生或不易预测的异常之外, 均定义为非运行时异常

75

76

77

78 第 7 章输入输出及文件操作 大纲要求文件文件 I/O 重要考点提示根据对历年真题的分析可知, 本章考核内容约占 7%, 主要包括以下几个方面 : (1)java.io 包中的类的层次关系 (2) 字符流 字节流 文件流所对应的类 (3)File 类的方法 随机文件流和压缩文件流所提供的方法 (4) 字节 I/O 流和字符 I/O 流各自的方法 (5) 过滤流 7.1 概述 Java 的输入输出流包括字节流 字符流 文件流 对象流以及多线程之间通信的管道流 本章介绍前 3 个 : 字节流 字符流 文件流 计算机数据的 I/O 方向 (1) 在计算机中, 流 的概念是 1984 年由 C 语言第一次引入的 (2) 流 可以看作是一个流动的数据缓冲区, 数据从数据源流向目的地, 流的传送是串行的 最常见的数据源是键盘, 最常见的数据目的地是屏幕 (3) 从外部设备 ( 如键盘 显示器 扫描仪 打印机 网络等 ) 流向中央处理器的流称为输入流 ; 反之, 称为输出流 7.1.2Java 中包含的输入 / 输出流的类 Java 的 I/O 功能主要是通过输入输出类库 java.io 包来实现的,java.io 包中包括了可以处理字节流 字符流 文件流和对象流等的类 这些类主要可以分为如下几个 : 1. 接口 : 处理字节流的 DataInput 和 DataOutput; 处理对象流的 ObjectInput 和 ObjectOutput; 筛选文件名的 FileNameFilter; 处理对象流的 Serializable 接口 凡是用于输入输出的对象在传输之前, 都要实现这个接口 此接口不含有任何抽象方法和常量, 它只是一个对象序列化的开关 2. 抽象类 : 处理字节流的 InputStream 和 OutputStream; 处理过滤流的 FilterInputStream 和 FilterOutputStream; 处理字符流的 Reader 和 Writer 类 ; 处理压缩流的是 InflaterInputStream 和 deflateroutputstream 3. 非字符输入 / 输出流分别通过继承 InputStream 和 OutputStream 实现 输入流包括 : 1) 以字节数组作为输入流的 ByteArrayInputStream. 该类对于在内存中读数据是十分有用的 2)FileInputStream 可对一个磁盘文件所涉及的数据进行处理 3) 实现线程通信的 PipeInputStream. 4) 过滤器输入流 FilterInputStream 5)SequenceInputStream 将多个输入流首尾相连, 得到一个新的输入流 6)StringBufferInputStream 从 jdk1.1 以后不再建议使用了 7)ObjectInputStream 类实现了 ObjectInput 接口, 对象在传输前首先要实现 Serializable 接口 4. 过滤字节输入输出流 : 分别通过继承 FilterInputStream 和 FilterOutputStream 实现 BufferedInputStream 类以缓冲器对输入流进行性能优化 ; CheckedInputStream 是数据校验的输入流 ;

79 DigestInputStream 以 理解 或 摘要 的方式过滤数据 ; inflaterinputstream 压缩过滤流, 对文件类型的过滤 ; LineNumberInputStream 类可以记录所读取数据的行数 ; PushBackInputStream 对字节输入流超前读入一个字节之后推回 DataInputStream 在读入字节数据时, 对 Java 基本数据类型的判断过滤 5. 压缩文件输入输出流 : 分别通过继承 InflaterInputStream 和 DeflaterOutputStream 实现, 是以字节压缩为特征的过滤流 GZIPInputStream 类在 java.util.zip 包中, 用于输入以 gzip 格式进行压缩的文件, 是对于输入文件类型的一种过滤 ; ZipInputStream 类在 java.util.zip 包中, 用于输入 zip 格式的文件, 这是对于文件格式 类型的一种过滤 ; JarInputStream 类在 java.util.jar 包中, 用于输入 JAR 文件压缩文件输出流与输入流相对应 6. 字符输入流 : 通过继承自抽象类 Reader 实现 BufferedReader 类带缓冲区字符输入流 缓冲区的大小可以指定, 又可以是默认的, 通常和 FileReader InputStreamReader 一起使用 ; LineNumberReader 类 BufferedReader 的一个子类, 增加了文本行计数功能 ; CharArrayReader, 字符数组读入器 FilterReader 是一个抽象类, 但没有一个抽象方法, 目的是禁止实例化, 是一个过渡类 PushBackReader 是 FilterReader 的子类 此类在读入一个字符流时, 超前读入一个字符再将其推回 InputStreamReader 类是以字节输入流为数据源的字符输入流 FileReader 用于从文件中读取文本 PipeReader 和 PipeWriter 相结合, 用于线程之间的通信 StringReader 用于将一个 String 对象作为一个字符输入流使用 7. 字符输出流 : 通过继承自抽象类 Writer 实现 基本与字符输入流相对应 ; OutputStreamWriter 是一个将字符翻译成字节输出的字符输出流 ; PrintWriter 类是字符输出流所特有的类, 可以将数据的字符串表示作为字符输出流 8.java.io 包中兼有输入 \ 输出功能的类 RandomAccessFile 是 java.io 包中的一个兼有输入 \ 输出功能的类, 同时实现 DataInput 和 DataOutput 接口, 而且直接继承 Object 类 由于是随机访问, 所以可以在文件的任意位置读 / 写一条记录 7.2 文件文件类 File 是 java.io 包中的一个重要的非流类 Java 通过 File 类建立与磁盘文件的联系 对 File 的理解, 需要注意如下几点 : (1)File 类不是 InputStream 类或 OutputStream 的子类, 它不负责数据的输入输出, 而是专门用来管理文件和目录 (2 在 Java 语言中, 目录也作为 File 类的对象进行处理, 目录在 Java 中作为一种特殊文件 (3) 每个 File 类的对象都表示一个文件或目录, 调用其方法就可以获得该文件或目录的属性, 完成对文件或目录的常用管理操作 (4) 流类关心的是文件的内容, 而 File 类关心的是文件在磁盘上的存储 1)File 的创建 : 创建文件, 与一般类的初始格式一样 : File name=new File(<pathname>); File name=new File(<path>,<filename>); 说明 : 构造方法的参数可以是路径文件名, 也可以是路径和文件 例如 :File f1=new File( d:\dir\test.java ); File f2=new File( d:\dir, Test2.java ); 利用 main() 的参数进行创建 :

80 File pathname=new File(args[0]); File f=new File(pathname.getPath(), filenames[i]); 2)File 类提供的方法对文件名操作提供的方法 getname() 得到一个不包含路径的文件名 ; getparent() 得到文件的上一级目录名 ; getpath() 得到文件路径名字符串, 即路径文件名 ; list() 返回一个字符串数组, 是此文件所在目录下的所有文件名列表 ; getcanonicalpath() 返回文件对象与系统平台相关的绝对路径 即返回一个绝对文件名 renameto(file newname) 返回重命名后的文件名 ; getabsolutepath() 得到一个文件的绝对路径名 ; getparentfile() 得到文件对象的父路径名 ; getabsolutefile() 等价于 new File(this.getAbsolutePath()) 例子 : File f1=new File("d:\\dir\\Test.java"); System.out.println(f1.getName()); System.out.println(f1.getPath()); File f2=new File("d:\\dir","Test2.java"); System.out.println(f2.getName());//getCanonicalPath() System.out.println(f2.getCanonicalPath()); System.out.println(f2.getAbsolutePath()); } 输出结果是 : Test.java d:\dir\test.java Test2.java d:\dir\test2.java d:\dir\test2.java

81 2) 测试文件属性操作提供的方法 isdirectory() 测定是否是目录, 返回一个布尔值 ; isabsolute() 测定是否是绝对路径 ; exists() 测定文件是否是存在 ; canread() 测定文件是否是可读文件 ; canwrite() 测定是否为可写文件 3) 为文件信息操作和工具提供的方法 delete() 删除当前文件并释放资源 ; deleteonexit() 执行完后, 删除文件 ; length() 返回文件的字节长度 ; lastmodified() 返回文件的最后修改时间 4) 为目录操作所提供的方法 mkdir() 创建目录 mkdirs() 创建包含父目录的目录 String[] list() 返回当前目录下的文件 String[] list(filenamefilter filter) 返回当前目录下经过过滤后的文件 File[] listroots() 返回根目录结构

82 随机文件流 : RandomAccessFile 类用来实现对文件的随机读写操作 它继承自 Object 类, 实现了 DataInput 和 DataOutput 接口 构造方法如下 : RandomAccessFile raf=new RandomAccessFile(< 文件名 >,< 访问模式 >); 说明如下 : 文件名参数, 可以是 File 类对象或文件名字符串的形式提供访问模式, 有 2 种取值 : r 只读, 或者 rw 读写例如 : RandomAccessFile rf1=new RandomAccessFile( d:\dir\test.txt, r ); 或者 File f=new File( d:\dir\t.txt ); RandomAccessFile rf2=new RandomAccessFile(f, rw ); 压缩文件流 : 压缩文件流被定义在 java.util.zip 包和 java.util.jar 包中 编写程序时一般使用压缩文件流的步骤如下 : (1) 将一个 Zip 文件作为 FileInputStream 构造方法的参数 ; (2) 将上述 FileInputStream 对象作为 ZipInputStream 构造方法的参数 ; (3) 再将上一步中的 ZipInputStream 对象作为 InputStreamReader 构造方法的参数 ; (4) 最后 InputStreamReader 对象作为 BufferedReader 构造方法的参数, 然后就可以使用 readline() 等方法进行操作 7.3 字节 I/O 流 1. 字节输入流字节输入流继承自 InputStream, 并且使用 DataInputStream 实现了 DataInput 接口 编程时一般的步骤如下 : (1) 字节数据的来源 ( 二进制文件 ) 作为 FileInputStream 构造方法的参数, 实例化一个 FileInputStream 对象 ; (2)FileInputStream 对象作为 DataInputStream 构造方法的参数 ; (3) 然后就可以使用 InputStream 类中的方法进行字节输入流的操作 InputStream 类的方法有 :read(),available(),skip(),close() 等 2. 字节输出流字节输出流继承自 OutputStream, 并且使用 DataOutputStream 实现了 DataOutput 接口 编程时一般的步骤和上述字节输入流相似, 只是将相应的输入流类换成输出流类即可 OutputStream 类的方法有 :

83 writedouble(), writeint(), writechar() // 写字符 (Unicode 码 ) write() flush() // 清空输出流, 并把缓冲全部内容写入输出流中 3. 内存的读写在 java.io 包中, 能够直接访问内存的类有 3 个 : (1)ByteArrayInputStream, 用于从字节数组中读取数据 主要方法有 :read(),skip(), reset(), close() 等 (2)ByteArrayOutputStream, 用于向字节数组写入数据主要方法有 :write(), writeto(), reset(), close() 以及 tobytearray 建立一个新的数组, 将缓冲区的数据拷贝到该数组中, 返回当前输出流内容的数组 size() 返回缓冲区的大小 tostring() 将缓冲区内容转换成字符串, 字符用 enc 编码 (3) StringBufferInputStream 类 7.4 字符类 I/O 流在 Java 中, 字符是以 16 位 Unicode 码的形式表示的 在 java.io 包中, 处理 Unicode 码的所有类都是从 Reader 和 Writer 两个抽象超类中衍生而来的 (1) 字符类输入流字符类输入流都是抽象类 Reader 的子类, 其中包括 InputStreamReader 及其子类 FileReader BufferedReader 及其子类 LineNumberReader FileReader 用于从一个文本文件中读取 Unicode 文本 BufferedReader 把缓冲技术用于字符输入流, 提高了字符的传送效率 (2) 字符类输出流字符类输出流都是抽象类 Writer 的子类, 其中包括 PrintWriter 类 OutputStreamWriter 及其子类 FileWriter BufferedWriter FilterWriter CharArrayWriter PipedWriter StringWriter 等 PrintWriter 是一个以打印写入者表示的字符输出流 Println() 方法负责向输出流写入字符 FileWriter 是 OutputStreamWriter 的子类, 用于向文本文件中写入字符 7.5 过滤流在 Java 中, 过滤流提供了对 I/O 的同步处理机制 Java.io 包中的 FilterInputStream 和 FilterOutputStream 抽象类实现了过滤流 在使用过滤流之前, 需要将该过滤流和一个 I/O 流相连 BufferedInputStream 和 BufferedOutputStream 类分别继承自 FilterInputStream 和 FilterOutputStream 类, 使用缓冲技术提高了效率 DataInputStream 和 DataOutputStream 是过滤流子类, 不仅能读写数据流, 还能读写 Java 语言的基本数据类型, 不用做转换 LineNumberInputStream 过滤类, 在输入数据时, 对换行 回车都处理为换行外, 还能对行计数 PushbackInputStream, 对编译的语法分析很有用 PrintStream 用来标准输出 7.6 管道流在 Java 中, 不同的 Java 程序 线程或代码段相互之间的数据交换通过管道流实现 Java.io 包中的 PipedInputStream 和 PipedOutputStream 抽象类实现了管道机制 其使用要求管道的输入流与管道的输出流必须事先连接好, 管道的输入流作为管道的接收方, 管道的输出流作为管道的发送包含的方法如下 : (1) PipedInputStream(PipedOutputStream src). (2) PipedOutputStream(PipedInputStream src). (3) public void connect(pipedoutputstream src). (4) public void connect(pipedinputstream src).

84 经典题解

85

86

87 7.7 J2SE1.4 提供的新的 IO 功能 J2se1.4 提供了一些新的输入输出功能, 称之为 New IO 这些新类收集到一个新包中即 java.nio 包 该包中的新类有 :MappedByteBuffer,FileChannel,CRC32 等 nio 包的新特点 : (1) 内存映射技术 将磁盘文件映射到内存中, 提高硬盘文件的访问速度 (2) 文件锁定 当多个线程对同一个文件进行访问时, 文件锁定实现了多个线程的同步, 避免存在可能的文件安全隐患 (3) 字符及编码 将早期分布于类库各个角落的字符处理内容集中到 java.nio.charset 类中, 统一了字符集转换, 便利了调用和管理 (4) 非阻塞 I/O 用于消除线程读 / 写时的阻塞 内存映射文件 java.nio 包中的 MappedByteBuffer( 内存映像缓冲器 ) 类表示一个磁盘文件在内存缓冲区中的一个字节映像 之所以要将磁盘文件映射到内存中, 是因为对于内存的度 / 写速度比磁盘的读 / 写要快的多 文件通道 java.nio.channels 包中的 FileChannel( 文件通道类 ) 就是为磁盘文件映入内存提供的一个通道 该通道可以通过 FileInputStream.getChannel() 方法获得 FileChannel.map() 方法用来将文件映入内存 所要映射的磁盘文件名以 FileInputStream 构造方法的参数形式出现 FileInputStream in=new FileInputStream( ch7/filea.txt ); FileChannel channel=in.getchannel();

88 MappedByteBuffer buffer=channel.map(mode,position,size); 7.8 输入输出流和正则表达式 java.util.regex 包以及 java.net.url 类相结合, 可用于网络上的字符输入流的模式字符串搜索上 Pattern 类 Pattern 类在包 java.util.regex 中 该类的 static Pattern compile(string expression,int flags) 方法用于将正则表示式字符串编译成模式对象, 来快速进行模式匹配 参数 expression 表示一个正则表达式, 参数 flags 表示表达式字符的某些属性 (1)CASE_INSENSITIVE: 不区分 ASCII 码的大小写 (2)UNICODE_CASE: 当和 CASE_INSENSITIVE 一起用时, 使用 Unicode 码 正则表达式例子 : String pstr= <a\\s+href\\s*=\\s*(\ [^\ ]*\ [^\\s>])\\s*> ; 对于模式串 <a href= > 的正则表达式字符串赋值解释 : \\s 空白字符 : 空格 制表符 换页符 + 重复一次或更多次 * 重复零次或更多次 [^\ ] 除了 \ 之外的其他字符 或运算对正则表示式编译成模式对象 : Pattern pattern=pattern.compile(pstr, Pattern.CASE_INSENSITIVE); Matcher matcher=pattern.matcher(input); 其中,matcher(input) 方法用于建立一个匹配器,input 是用于同模式串相比较的字符串 Matcher 类 Matcher( 匹配器 ) 类在包 java.util.regex 中 该类用于将一个输入字符串 input 和模式串 pattern 相比较 (1) static boolean matches(): 用于 input 和 pattern 的比较 if(matcher.matches()) System.out.println( Match ); else System.out.println( No match ); (2) boolean matcher.find() 方法用于寻找下一个模式匹配串 (3) int matcher.start() 方法用于返回匹配串的一个起始索引整数值 (4) int matcher.end() 方法用于返回匹配串的一个终止索引整数值 上面 (3) (4) 返回值用于 java.lang.stringbuffer.substring(start,end) 来取匹配串的串值 第 8 章线程与对象串行化 大纲要求线程的概念和使用同步与共享 (3) 串行化的概念和目的 (4) 串行化方法 (5) 串行化举例

89 (6) 基于文本的应用重要考点提示根据对历年真题的分析可知, 本章考核内容约占 8%, 主要包括以下几个方面 : (1) 线程与进程之间的区别 (2) 线程的模型 (3) 创建线程的两种方法 (4) 线程的各种状态 (5) 线程的优先级与基本控制 (6) 线程的同步 (7) 对象的串行化 8.1 线程的概念 1 线程的概念 (1) 线程是由表示程序运行状态的寄存器 ( 包括程序计数器和堆栈 ) 组成的 也被称为轻型进程 (2) 线程是程序执行过程中的某一时刻的状态 (3) 线程是一个用户级的实体, 在内存中驻留在普通用户级方法可以直接访问的区域中 (4) 每个线程都是一个能够独立执行自身指令的控制流程 (5) 操作系统通过对多线程的调度实现线程的并发执行 (6) 线程本身并不是一个程序, 而是运行于一个程序或者进程中的一个执行流 (7) 线程是个动态的概念, 有其自身的产生 存在和消亡的过程 (8)Java 通过在程序中提供多线程支持 (9) 线程是程序中的一个单个执行流, 多线程是程序中的多个执行流 2 程序 线程和进程 (1) 程序是一段静态的代码, 是应用软件执行的蓝本 (2) 进程是程序的一次动态执行过程, 包括程序加载 执行到结束 (3) 线程是比进程更小的执行单位, 一个进程可以包含多个线程 (4) 进程是由代码 数据 内核状态和一组寄存器组成的 (5) 线程不包含进程的地址空间中的代码和数据 3 Java 中的线程模型 (1)Java 中的线程模型包含 3 部分 : 一个虚拟的 CPU CPU 执行的代码代码所操作的数据 (2)Java 语言中, 数据和代码相互独立, 代码可以在不同的线程之间共享, 数据也可以在不同的线程之间共享 (3)java.lang.Thread 类定义了 Java 语言中的线程模型, 用户可以通过该类创建 定义和控制自己的线程 8.2 线程的创建一个具体的线程也是由虚拟的 CPU 代码和数据组成, 其中代码和数据构成线程体, 线程的行为由线程体决定 虚拟的 CPU 是在创建线程时自动封装进 Thread 类的实例中

90 线程体要通过一个对象传递给 Thread 类的构造方法 Java 中的线程体是由线程类的 run() 方法定义的, 在该方法中定义线程的具体行为 线程开始执行时, 也是从它的 run() 方法开始执行 Thread 类在 Java API 的 java.lang 包中定义 Thread 类的构造方法有多个, 一般结构表示如下 : public Thread(ThreadGroup group,runnable target,string name) 其中,group 指明线程所属的线程组 ;target 提供线程体的对象, 当线程启动时, 此对象的 run() 方法将被调用 ;name 指明线程名, 如果 name 取值为 null, 则 Java 自动向线程赋予唯一的名称 可以有两种方式实现 run() 方法 : (1) 实现 Runnable 接口 (2) 继承 Thread 类 (1) 通过实现 Runnable 接口创建线程在 java.lang 中 Runnable 接口的定义为 : public interface Runnable{ void run(); } 创建线程的过程 : 把 Runnable 的一个实例作为参数传递给 Thread 类的一个构造方法, 该实例对象提供线程体 run(). 一个线程是 Thread 类的一个实例 线程从 Runnable 实例的 run() 方法开始执行 新建的线程不会自动运行, 必须调用线程的 start() 方法

91 (2) 通过继承 Thread 类创建线程 Thread 类本身实现了 Runnable 接口, 所以在 java.lang 的 Thread 类的中可以发现 run() 方法 因此可以通过继承 Thread 类, 并重写其中的 run() 方法定义线程体, 然后创建该子类的对象创建线程 两种方法的比较 (1) 采用继承 Thread 类的方法, 代码简单, 并可直接调用线程的方法 (2) 实现 Runnable 接口的优势, 符合面向对象程序设计的思想, 它不影响 Java Thread 类的体系 因此建议采用第二种方式 但具体应用中, 可以根据具体情况确定采用哪种方法

92 8.3 线程的调度与线程控制 线程优先级与线程调度策略线程的优先级 : 在 Thread 类中提供了 3 个静态常量 : MIN_PRIORITY=1, MAX_PRIORITY=10, NORM_PRIORITY=5 来控制线程的优先级 线程的优先级是 MIN_PRIORITY 和 MAX_PRIORITY 之间的一个值, 数值越大优先级越高 新建线程将继承其父类线程的优先级 可以通过 getpriority() 方法来获得线程的优先级, 也可以通过 setpriority() 方法来设定线程调度的优先级 一般情况下, 主线程具有普通优先级 线程调度是指 : 在单个 CPU 上以某种顺序运行多个线程 Java 的线程调度策略是一种基于优先级的抢占式调度 在 Java 运行系统中可以按优先级设置多个线程等待池,JVM 先运行高优先级池中的线程, 高优先级等待池空后, 才考虑低优先级 如果线程运行中有更高优先级的线程成为可运行的, 则运行它 线程的基本控制要控制线程, 可以使用 Thread 类提供的如下方法

93 sleep() 是一个线程暂停运行一段固定时间, 使得比其优先级低的线程运行 yield(). 使具有与当前线程相同优先级的线程能够有运行的机会 如果不存在同等优先级的线程处于可运行状态,yield() 方法将什么也不做 join(). 若在当前线程中执行 t.join() 方法, 则当前线程暂停运行, 等待另一线程 t 运行结束, 才恢复到可运行状态 interrupt(). 如果一个线程 t 在调用 sleep(),join(),wait() 等方法被阻塞时, 则 t.interrupt() 方法使 t 的中断状态被清除, 中断 t 的阻塞状态, 并且 t 将接收到 InterruptException 异常 (5)currentThread(). 是一个静态方法, 用于返回当前线程的引用 (6)isAlive(). 用于判断线程是否还处于活动状态 (7)stop(). 强行终止线程 (8)suspend(). 使线程暂停, 如果要恢复线程, 则必须由其他线程调用 t.resume() 方法