Microsoft PowerPoint - JavaSE_all.ppt

Transcription

1 第一章 Java 技术入门 Java 学习路线图 第四阶段第三阶段第二阶段第一阶段 Java 企业级应用开发 Java Web 应用开发 数据库 ( Oracle ) 面向对象 ( 类, 继承及多态性, 抽象类, 接口, 内部类 ) 异常处理 I/O 流式编程 集合框架 GUI 程序设计 Socket 编程 多线程编程 对象序列化 程序国际化 Structs 架构应用开发 Hibernate XML J2EE/EJB WebService UML/Rose Spring Ajax WebLogic JDBC JSP Servlet JavaBean HTML JavaScript Session/Cookie MVC 设计模式 Tomcat Jbuilder Eclipse + MyEclipse Oracle 数据库安装配置 / 基本管理及开发, 使用 OEM/SQL Plus, 标准 SQL,DML,DDL, 函数, 事务, 约束, 序列, 索引, 视图, 数据库设计.SQL Server 基础

2 本章学习目标 1 Java 语言概述 2 Java 应用程序运行机制 3 Java 虚拟机及运行时环境 4 开发第一个 Java 应用程序 5 Java 运行环境安装和配置 3 What s Java Sun:Stanford University Network 1982 年 2 月成立, 目前全球雇员 2 万 6 千余人 Java 不仅仅是一种编程语言, 更是一种功能强大 / 完备的开发和运行环境

3 Java 发展历程 1991 年出现, Oak, 用于嵌入家电 Sun 发布了 Java 1.0 (Java Development Kit JDK1.0) 从 发布 JDK1.2, 始称 Java 2 现在 SUN 已推出 Java Platform Micro Edition (Java ME) Java Platform Standard Edition (Java SE) Java Platform Enterprise Edition (Java EE) 5 Java 的设计目标 创建一种面向对象的程序设计语言 ; 提供程序运行的解释环境, 使程序代码独立于平台 ; 吸收 C 和 C++ 的优点, 使程序员容易掌握 ; 去掉 C 和 C++ 中影响程序健壮性的部分, 如指针 内存申请和释放 无条件转移语句等 ; 提供多线程机制 ; 提供动态下载程序代码的机制 ; 提供代码检验机制以保证安全性 ; 6 3

4 Java 三种核心机制 Java 虚拟机 Java Virtual Machine 垃圾收集机制 Garbage collection 代码安全性检测 Code Security 7 Java 程序运行原理 计算机的高级编程语言类型 : 编译型 解释型 Java 语言是两种类型的结合 常用术语 : Java 源程序 字节码文件 机器码指令 8 4

5 Java 虚拟机 JVM Java Virtual Machine 在一台计算机上由软件或硬件模拟的计算机 Java 虚拟机 (JVM) 读取并处理经编译过的平台无关的字节码 class 文件 Java 编译器针对 Java 虚拟机产生 class 文件, 因此是独立于平台的 Java 解释器负责将 Java 虚拟机的代码在特定的平台上运行 9 Java 虚拟机 Java 虚拟机规范定义了 : 指令集 寄存器集 类文件结构 堆栈 垃圾收集堆 内存区域

6 Java 虚拟机 编译 执行 JVM for Dos Dos Platform Java 源文件 字节码文件 JVM For Windows Windows Platform JVM for Unix Unix Platform JVM for other Other Platform 11 Java 运行时环境 JRE--The Java Runtime Environment Java 运行环境组成 : JRE = JVM + Runtime Interpreter + 其它 Java 运行环境的三项主要功能 : 加载代码 : 由 class loader 完成 ; 校验代码 : 由 bytecode verifier 完成 ; 执行代码 : 由 runtime interpreter 完成

7 Java 自动垃圾收集 GC--garbage collection 不再使用的内存空间应回收 ---- 垃圾收集 在 C/C++ 等语言中, 由程序员负责回收无用内存 Java 语言解除了程序员回收无用内存空间的责任 它提供一种系统级线程跟踪存储空间的分配情况 并在 JVM 的空闲时, 检查并释放那些可被释放的存储器空间 垃圾收集在 Java 程序运行过程中自动进行, 程序员无法精确控制和干预 13 Java 应用程序分类 Java 应用程序 (Java Application) 以 main() 方法作为程序入口, 由 Java 解释器加载执行 Java 小应用程序 (Java Applet) 没有 main() 方法作为程序入口, 由浏览器或 appletviewer 加载执行

8 第一个 Java 应用程序 源文件 :HelloWorld.java public class HelloWorld { public static void main (String args[]) { System.out.println("hi, 你好!"); 15 HelloWord 程序分析 类定义 Java 程序的基本组成部分是类 (class), 如本例中的 HelloWorld 类 再由类中所包含的方法实现程序要完成的功能, 方法体由 0 到多条语句组成 main() 方法 Java Application 程序的入口是 main() 方法 它有固定的书写格式 : public static void main(string args[ ]){

9 编译和运行 Java 程序 编译源程序 : 指令 :Javac HelloWorld.java 说明 : 源文件名为 HelloWorld.java, 由 javac 编译器编译源程序, 产生字节码文件 (.class 文件 ) 解释执行字节码文件 : 指令 :Java HelloWorld 说明 : 由 java 运行环境 (JRE) 解释执行 17 Java 程序结构 源文件命名如果 java 源文件包含了 public 修饰的类, 那此源文件必须与 public 类同名, 后缀为.java 类个数一个源文件中最多只能有一个 public 类 ; 其它类的个数不限 Java 语言中单词拼写严格区分大小写 ;

10 Java 程序结构 第一部分 package 语句 第二部分 import 语句 之后 其它成分之前 第三部分 public class Definition Class Definition Interface Definition //0 或 1 个, 必须放在文件开始 //0 或多个, 位于 package 语句 //0 或 1 个 //0 或多个 //0 或多个 19 JRE 安装配置 Java 开发工具集 JDK Java Development Kits API 其它工具和资源 运行环境 环境变量 Path: 外部命令搜索路径 编译器 CLASSPATH: 类资源位置搜索路径 JDK 组成

11 练 习 编辑 编译并运行 HelloWorld.java 应用程序, 练习文本编辑器用法 体会 Java 应用程序的运行机制 ; 练习环境变量的设置, 分析出现的问题并改正, 体会环境变量的作用 ; 21 第二章面向对象程序设计 11

12 本章学习目标 1 面向对象的分析和设计简介 2 类和对象 3 属性 方法和构造方法 4 对象的创建和使用 5 信息的封装和隐藏 6 Java API 23 软件开发流程 软件工程开发模型 瀑布模型

13 分析 / 设计 / 编码阶段 分析阶段 : 分析并确定用户需求, 用采用适当的模型规范地表述这一需求, 形成分析模型, 为要处理的现实世界中的事物建立抽象建模 设计阶段 : 确定系统如何实现所需的功能 ---- 采用适当的数据结构 + 控制逻辑, 将分析模型细化 编码实现 : 选定一种适当的编程语言, 编码实现上述的设计, 并在开发过程中引入测试, 完善整个解决方案 25 面向对象思想概述 面向对象的编程思想力图使对计算机语言中对事物的的描述与现实世界中该事物的本来面目尽可能的一致 类 (class) 和对象 (object) 是面向对象方法的核心概念 类是对一类事物描述, 是抽象的 概念上的定义 ; 对象是实际存在的该类事物的每个个体, 因而也称实例 (instance)

14 类和对象举例 定义一个类 class Person { int age; int getage() { return age; void setage(int i){ age = i; 声明并创建一个 Person 类的对象, 并将之命名为 aperson a = new Person(); 调用对象 a 的方法 a.setage(36); 27 语法格式 : 声明类 [< modifiers>] class < class_name> { [<attribute_declarations>] [<constructor_declarations>] [<method_declarations>] 举例 : public class Person{ private int age ; public void showage(int i) { age = i;

15 声明属性 语法格式 : [< modifiers>] type < attr_name> [=defaultvalue] ; 举例 : public class Person{ private int age; public String name = Lila ; 29 声明方法 语法格式 : [< modifiers>] <return_type> <name>([< argu_list>]) { [< statements>] 举例 : public class Person{ private int age; public int getage() { return age; public void setage(int i) { age = i;

16 构造方法 功能 : 创建其所属类型的一个新的对象 语法格式 : [< modifiers>] <class_name>([< argu_list>]) { [< statements>] 举例 : public class Person { public Person(String n){ name = n; public Person(String n, int a){ name = n; age = a; 31 缺省构造方法 1 Java 语言中, 每个类都至少有一个构造方法 ; 如果类的定义者没有显式定义任何构造方法, 系统将自动提供一个缺省的构造方法 : 缺省构造方法没有参数 缺省构造方法方法体为空 Java 类中, 一旦类的定义者显式定义了一个或多个构造方法, 系统将不再提供缺省的构造方法 ;

17 缺省构造方法 2 类的定义 : public class Person { private int age; public void setage(int w) { age = w; 等价于 : public class Person { private int age; public Person() { public void setage(int w) { age = w; 应用举例 : public class Test{ public static void main(string args[]){ Person d = new Person(); d.setage(120); 33 对象的创建和使用 语法规则 : 使用 new + 构造方法创建一个新的对象 ; 使用 对象名. 对象成员 的方式访问对象成员 ( 包括属性和方法 ); 举例 : public class Test { public static void main(string[] args){ Person d = new Person(); d.setage(42); System.out.println(" 本人年龄 : " + d.getage());

18 练习 2-1 分析并编译 运行下面的源文件, 体会类的定义 对象的创建 对象成员方法的调用 类的定义和应用程序在源文件结构上的不同 ; // 源文件 A.java public class A { public void m1() { System.out.println("hi"); // 源文件 Test.java public class Test { public static void main(string[] args) { A hello=new A(); hello.m1(); 35 面向对象应用举例 1 // 源文件 Person.java public class Person{ public String name = " 无名氏 "; public int age; public void setname(string n){ name = n; public String getname(){ return name; public void setage(int a){ age = a; public int getage(){ return age; public void sleep(){ System.out.println(name + " 在睡觉, 呼噜噜!");

19 面向对象应用举例 2 // 源文件 TestObject.java public class TestObject{ public static void main(string[] args){ Person p1 = new Person(); Person p2 = new Person(); p1.name = " 张三 "; p1.age = 18; p2.setname(" 李四 "); p2.setage(33); p1.sleep(); p2.sleep(); System.out.println(p1.getAge()); System.out.println(p2.age); 输出结果 : 张三在睡觉, 呼噜噜! 李四在睡觉, 呼噜噜! 信息的封装和隐藏 1 使用者对类内部定义的数据 ( 对象的成员变量 ) 的直接操作会导致数据的错误 混乱或安全性问题 举例 : class Person{ public int age; public class DirectAccess{ public static void main(string[] args){ Person b = new Person(); b.age = 40; b.age = -3; System.out.println(b.age);

20 信息的封装和隐藏 2 Java 中通过将数据封装 声明为私有的 (private), 再提供一个或多个公开的 (public) 方法实现对该属性的操作, 以实现下述目的 : 隐藏一个类的实现细节 ; 使用者只能通过事先定制好的方法来访问数据, 可以方便地加入控制逻辑, 限制对属性的不合理操作 ; 便于修改, 增强代码的可维护性 ; 39 信息的封装和隐藏 3 class Person{ private String name; private int age; public Person(String n){ name = n; public String getname(){ return name; public void setage(int i){ if(i>=0 && i<=120){ age = i; public int getage(){ return age; public class Encapsulation{ public static void main(string[] args){ Person b = new Person("Tom"); b.setage(34); b.setage(-3); System.out.println(b.getName() + "--" + b.getage());

21 Java API 文档 API 文档是 JDK 系统类库的使用说明, 由 Sun 公司提供, 下载地址 第三章 Java 基础语法 21

22 本章学习目标 1 注释 分隔符 标识符和关键字 2 数据类型 3 方法 变量 4 值传递和关键字 this 5 标准输入输出 6 编码惯例 43 注释 注释 (Comment) 是对源程序起解释说明作用的文本信息, 适当使用注释能够增强代码的可读性 Java 语言中定义了三种注释形式 : // 单行注释 ---- 注释到行尾 /* 单行或多行注释 */ /** 可用于文档化处理的单行或多行注释 */ JDK 中提供了一个文档自动生成工具 javadoc, 在自定义类中 public 的成员前以 /** */ 形式加入的注释内容均可被自动提取到生成的说明文档中 用法 : somepath\javadoc source.java

23 分隔符 Java 分隔符组成 : 分号 -";" 逗号 -"," 空格 -" " 圆点 -"." 花括号 -"{" 及 "" Java 分隔符作用 : Java 语句必须以分号作为结束标记,for 循环语句中使用分号来分隔不同的成份 逗号可以在方法声明或调用时的参数列表中用于分隔多个参数, 也可在一条声明语句中同时声明多个属性或局部变量时起分隔作用 Java 程序源代码中各组成部分之间可以插入任意数量的空格, 包括换行 圆点用于访问对象成员 ( 属性或方法 ) 时标明调用或隶属关系, 其格式为 " 对象名. 对象成员 " 花括号用于构造语句块 45 语句块 Java 允许用花括号 "{" 将一组语句括起来, 形成一个语句块 (block) 用法 : 定义类时类体必须采用语句块形式 定义方法时方法体必须采用语句块的形式 定义循环语句时, 循环体可以采用语句块的形式, 采用将 0~ 多条语句集合到一起, 作为一个整体进行处理 语句块可以嵌套, 嵌套层数无限制

24 标识符 Java 语言中, 为各种变量 方法和类等起的名字称为标识符 (identifier) Java 标识符的命名规则 : 应以字母 下划线 (_) 美元符 ($) 开头 后跟字母 下划线 美元符或数字 Java 标识符大小写敏感, 长度无限制 举例 : 合法的标识符 HelloWorld DataClass _983 $bs5_c7 不合法的标识符 class DataClass# 98.3 Hell World 47 关键字 Java 语言中一些被赋以特定的含义 并用做专门用途的单词称为关键字 (keyword) 所有 Java 关键字都是小写的,TURE FALSE NULL 等都不是 Java 关键字 goto 和 const 虽然从未使用, 但也作被为 Java 关键字保留 true,false 虽被用做专门用途, 但不是 Java 关键字

25 Java 关键字表 abstract case continue extends goto assert catch default final if boolean char do finally implements break class double float import byte const else for instanceof int interface long native new null package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while 49 Ex 练习在一个已有.java 源代码文件中使用三种不同类型的注释, 并用 javadoc 命令创建自己的类文档, 体会其用法 2. 练习在已有应用程序的一个语句中插入多处空格 中间换行 将多个语句组成一个语句块儿 ( 置于 { 中 ), 并编译运行程序, 体会其自由程度 3. 测试并体会 Java 标识符 关键字的使用规则 : 在程序中试将不合法的标识符 ( 如 :3ar, *bily, d9#8 等 ) 或关键字作为变量名 方法名或类名, 编译然后改正错误

26 数据类型 数据类型就是一组性质相同的值的集合以及定义于这个值集合上的一组操作的总称 常用数据类型 : 整型 浮点型 字符型 字符串型 布尔型 按照对数据类型的使用约束程度来划分, 高级编程语言可分为 : 强类型语言 (Strong Typed Languages) 弱类型语言 (Weakly Typed Languages) 51 Java 数据类型 基本类型 整型 (byte,short,int,long) 数值型浮点型 (float,double) 字符型 (char) 布尔型 (boolean) Java 数据类型 类 (class) 接口类型 (interface) 引用类型 数组类型 枚举类型 (Enum) 注解类型 (Annotation) Java 数据类型层次结构

27 基本数据类型 基本类型 (Primitive Type) 的数据只能保存单一的值, 因此也被称为原始类型 或简单类型 Java 中定义了四类 / 八种基本数据类型 逻辑型 -- boolean 文本型 -- char 整数型 -- byte, short, int, long 浮点型 -- float, double 53 整型 整型数据用于保存整数信息,Java 提供了四种不同的整数类型, 各有固定的表数范围和字段长度, 而不受具体操作系统的影响, 以保证 Java 程序的可移植性 类型 byte short int long 占用存储空间 1 字节 2 字节 4 字节 8 字节 表数范围 -128 ~ ~ ~ ~

28 整型常量表示 Java 语言整型常量的三种表示形式 : 十进制整数, 如 12,-314, 0 八进制整数, 要求以 0 开头, 如 012 十六进制数, 要求 0x 或 0X 开头, 如 0x12 Java 语言的整型常量默认为 int 型, 声明 long 型常量可以后加 "l" 或 "L" 举例 : int a = 39; int b = 0x4b; int c = 021; int d = a + 0x ; // 等价于 d= ; long m = 3L; long n = m + 40; 55 浮点型 Java 浮点型包括 float 和 double 两种, 分别用于保存单精度和双精度的浮点数 浮点型有固定的表数范围和字段长度 : 类 型 占用存储空间 表数范围 float double 4 字节 8 字节 E38~3.403E E308~1.798E

29 浮点型常量表示 Java 浮点类型常量有两种表示形式 十进制 必须含有小数点, 也可采用科学计数法表示, 例如 e2 1.24e2 4.5E-3 十六进制 从 JDK5.0 开始引入, 十六进制浮点数只能采用科学记数法表示, 其格式为 : <0x 0X>< 十六进制尾数 ><p P>< 以 2 为底的指数 > 例如 0x1.2p3, 转换为十进制的计算方法为 : 0x1.2p3 = (1* *16-1 ) * 2 3 = 9.0 Java 浮点型常量默认为 double 型, 如要声明 float 型常量为, 则需在数字后面加 f 或 F, 如 : double d = 3.14; float f = 3.14f; 57 字符型 基本概念 : 字节 字符 字符集 字符编码 char 型数据用来表示通常意义上 字符,Java 语言采用 16 位 Unicode 编码保存 字符常量的三种表示方法 : 使用单引号括起来的单个字符, 例如 : char c = 'A'; 十六进制编码形式表示, 例如 : char c1 = '\u0061'; 使用转义字符 '\' 来将其后的字符转变为其它的含义, 例如 : char c2 = '\n'; // 代表换行符

30 布尔型 boolean 类型数据用来表示只有两种状态的逻辑值, 分别代表现实生活中的特定条件成立与否, 通常用于逻辑运算和程序流程控制 boolean 类型数据只允许取值 true 或 false, 不可以 0 或非 0 的整数替代 true 和 false 用法举例 : boolean b = true; if(b == false){ System.out.println("haha"); else{ System.out.println("hehe"); 59 Ex 编写 Java 应用程序, 测试并体会各种原始类型数据的定义, 赋值和输出 输出可采用下述形式的语句 : System.out.println("x=" + x); // 其中 x 是变量名, 如 a,b,c 等 2. 使用 char 型的三种常量声明方式为 char 型变量赋值并输出

31 引用数据类型 Java 语言中除 8 种基本数据类型以外, 其它的数据类型统称为引用类型 ( Reference Type), 具体包括 : 类 接口 数组 枚举和注解类型 引用类型数据以对象的形式存在 引用类型变量的值是某个对象的句柄, 而不是对象本身 声明引用类型变量时, 系统只为该变量分配引用空间, 并未创建一个具体的对象 61 引用类型应用举例 (1) public class MyDate{ private int day = 17; private int month = 2; private int year = 2007; public MyDate(){ public MyDate(int d,int m,int y){ day = d; month = m; year = y; public void setday(int d) { day = d; public int getday() { return day; public void setmonth(int m) { month = m; public int getmonth() { return month; public void setyear(int y) { year = y; public int getyear() { return year; public void display(){ System.out.println(year + "-" + month + "-" + day);

32 引用类型应用举例 (2) public class TestReferenceType{ public static void main(string args[]){ MyDate d1; d1 = new MyDate(8,8,2008); d1.display(); 63 对象构造和初始化 (1) 一. 为引用类型变量分配引用空间 语句 : 内存状态 : MyDate d1; 二. 创建新对象 为新对象分配内存空间, 并进行属性 ( 实例变量 ) 的默认初始化 语句 : 内存状态 : d1 d1 = new MyDate(8,8,2008); d1 MyDate 对象 0 year 0 month 0 day

33 对象构造和初始化 (2) Java 对象默认初始化规则 属性类型 byte short int long char float double boolean 所有引用类型 默认初值 L '\u0000' 0.0F 0.0D false null 65 对象构造和初始化 (3) 三. 进行属性的显式初始化, 显式初始化取值来自于类的定义中属性声明部分 语句 : private int day = 17; private int month = 2; private int year = 2007; 内存状态 : d1 MyDate 对象 2007 year 2 month 17 day 说明 : 如果属性在声明时未指定缺省值, 则在这个环节就不对其进行赋值操作

34 对象构造和初始化 (4) 四. 执行构造方法体中的语句 语句 : public MyDate(int d,int m,int y){ day = d; month = m; year = y; 内存状态 : d1 MyDate 对象 2008 year 8 month 8 day 说明 : 此时新建对象和先前声明的变量 d1 间还是没有建立任何关联 67 对象构造和初始化 (5) 五. 为引用类型变量赋值 语句 : d1 = new MyDate(8,8,2008); 内存状态 : d1 0x3a478b MyDate 对象 2008 year 8 month 8 day 说明 : 此时变量 d1 保存的并不是新建对象封装的具体信息 如属性值等, 而是该对象的句柄 (Handle)

35 Ex3-3 运行 P26 页程序, 体会 Java 引用数据类型的实现机制, 思考并讨论下述问题 : 基本数据类型和引用数据类型的区别? 引用类型变量和对象的区别? 类和对象的关系? 69 方法 方法 (Method) 是类的动态性能, 描述了该类事物所共有的功能或行为 Java 语言的方法相当于其它编程语言中的函数 (Function) 或子程序 (Subroutine), 是用来完成相对独立功能的一段代码的集合 语法规则 : Java 语言的方法必须定义在类中, 而不允许直接出现在源文件内 只有其所在类的对象才有资格调用方法 方法的定义不允许出现嵌套

36 形参 实参及返回值 形式参数在方法被调用时用于接收外界输入的数据 ; 实参调用方法时实际传给方法的数据 返回值方法在执行完毕后返还给调用它的环境的数据 返回值类型事先约定的返回值的数据类型 如无返回值, 在 Java 中也必须给出返回值数据类型为 void 定义构造方法时则不允许给出返回值类型 71 方法举例 public class TestMethod{ public int m1(int a,int b,int c){ int result = a + b + c; return result; public void m2(int c){ System.out.println(c); public static void main(string args[]){ TestMethod tm = new TestMethod(); int j = tm.m1(3,4,5); System.out.println(j); System.out.println(tm.m1(100,10,9)); tm.m1(1,2,3); // 合法, 丢弃了返回结果 tm.m2(6); //int k = tm.m2(8); // 非法, 方法 m2() 无返回值

37 相关语法 方法形参列表格式 : ( 数据类型 1 参数名 1, 数据类型 2 参数名 2, ) Java 语言中使用下述形式调用方法 : 对象名. 方法名 ( 实参列表 ) 实参列表格式如下 : ( 参数 1, 参数 2, ) 实参可以是变量 常量或表达式, 但其数目 类型和出现的顺序必须和相应的形参保持一致, 此称为参数匹配 return 语句用于终止方法的运行并指定要返回的数据 如果方法的最后一行没有 return 语句, 则编译时系统会添加 "return;" 73 变量 变量 (Variable) 用于记录数值可以改变的数据 计算机技术中变量包括变量名和变量值两部分 : 变量名 用于标记一段特定的存储空间 变量值 以二进制形式保存在该空间中, 且可以被访问和修改 变量分类 按所属数据类型划分 : 基本类型变量引用类型变量 按声明的位置划分 : 局部变量 方法或语句块内部定义的变量成员变量 方法外部 类的内部定义的变量

38 变量声明和初始化 Java 语言中变量必须先声明和初始化 ( 赋初值 ), 然后才可以使用 成员变量在类的定义中声明, 在创建对象的同时创建有关的成员变量, 然后由系统自动对其进行默认初始化和显式初始化 局部变量声明语法格式 : < 类型 > < 变量名 1>[=< 缺省值 1>][,< 变量名 2>[=< 缺省值 2>] ] ; 举例 : public void m1(int a,int b){ int i; int j = i + 4; // 编译出错, 变量 i 尚未初始化 int k = a + b; 说明 : 形参属局部变量, 方法调用时会被隐含的初始化 75 变量作用域与生存期 变量的作用域也称变量的作用范围, 即一个变量在多大的范围内可以使用 : 成员变量的作用域与其所属对象的作用域相同 局部变量的作用域就是它所在的方法或语句块 变量的生存期即变量的生存时间 : 局部变量的生存期就是其所在方法或语句块单次执行的期间 在程序每一次调用方法或运行进入到一个语句块中时, 其中的局部变量才被创建并可用, 随方法 / 语句块的退出, 局部变量将被销毁 成员变量的生存期与其所属的对象相同, 随着对象的创建而创建 随对象的销毁而销毁

39 数据存储细节 计算机的物理内存在操作系统和 JVM 中使用时分为堆内存和栈内存两种方式 : 堆内存 (Heap Memory) 由所有的应用程序公用, 存储空间分配不连续, 存储容量大 在堆内存中分配存储空间和进行存取操作速度较慢 栈内存 (Stack Memory) 由特定应用程序专用, 存储空间是连续的, 以栈的方式 ( 后进先出 ) 进行管理, 存储容量小, 但访问速度快 Java 程序运行时, 局部变量保存在栈内存中, 而对象及其成员变量保存在堆内存中 77 变量作用域举例 class C{ private int a = 1; private int b = 5; public void m1() { int i=4, j=5; a = i + j; public void m2(int i) { int j = 8; a = i + j; System.out.println(a); public class TestVariable{ public static void main(string[] args) { C c = new C(); c.m1(); int k = 4; c.m2(k);

40 值传递 Java 语言中进行赋值操作或函数调用中传递参数时, 遵循值传递 (Pass By Value) 的原则, 即传递的永远是参数的值 Java 值传递分为两种不同情形 : 基本类型数据传递的是该数据的值本身 引用类型数据传递的是对对象的引用 ( 句柄 ), 而非对象本身 79 值传递举例 (1) public class BirthDate { private int day; private int month; private int year; public BirthDate (){ public BirthDate (int d,int m,int y){ day = d; month = m; year = y; public void setday(int d) { day = d; public int getday() { return day; public void setmonth(int m) { month = m; public int getmonth() { return month; public void setyear(int y) { year = y; public int getyear() { return year; public void display(){ System.out.println(year + "-" + month + "-" + day);

41 值传递举例 (2) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 81 值传递演示 (1) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 程序开始时内存状态 栈内存 堆内存

42 值传递演示 (2) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 main d2 d1 date ex 堆内存 值传递演示 (3) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 change1 main i d2 d1 date ex 堆内存

43 值传递演示 (4) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 change1 main i d2 d1 date ex 堆内存 值传递演示 (5) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 main d2 d1 date ex 堆内存

44 值传递演示 (6) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 change2 main b d2 d1 date ex 堆内存 值传递演示 (7) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 1 堆内存 1 change2 b d d main date 9 7 ex

45 值传递演示 (8) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 main d2 d1 date ex 堆内存 值传递演示 (9) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 change3 main b d2 d1 date ex 堆内存

46 值传递演示 (10) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 change3 main b d2 d1 date ex 堆内存 值传递演示 (11) public class Example{ public static void main(string args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); public void change1(int i){ i = 1234; public void change2(birthdate b){ b = new BirthDate(22,2,2004); public void change3(birthdate b){ b.setday(22); 处内存状态 栈内存 main d2 d1 date ex 堆内存

47 Ex 练习值传递演示中的例程, Example.java, 体会和巩固 Java 中值传递的思想 2. 编写 Java 类 MyTool, 实现下述功能并测试 : 复制 BirthDate 类 ( 见 P39 页 ) 对象 ; public BirthDate copy(birthdate d){ 给定一个 BirthDate 对象, 返回对应其一周后日期的 BirthDate 对象 ( 假定每月均为 30 天 ) public BirthDate nextweek(birthdate d){ 93 关键字 this (1) Java 中为解决变量的命名冲突和不确定性问题, 引入关键字 this 代表其所在方法的当前对象, 具体可分为两种情况 : 在普通方法中, 关键字 this 代表方法的调用者 即本次调用了该方法的对象 ; 在构造方法中, 关键字 this 代表了该方法本次运行所创建的那个新对象 在 Java 方法中既可以直接使用本方法的局部变量, 还可以使用方法当前对象的成员变量

48 关键字 this (2) public class MyDate{ private int year, month, day; public MyDate(){ public MyDate(int day,int month,int year) { this.year = year; this.month = month; this.day = day; public void setyear(int year) { this.year = year; public void setmonth(int m) { month = m; public void setday(int d) { day = d; public void setting(){ this.setyear(2008); this.setmonth(8); setday(11); // 同 this.setday(11); public void display(){ System.out.println(day + "-" + month + "-" + year); 95 标准输入 / 输出 (1) 读取控制台输入 // 源文件 TestInput.java import java.util.scanner; public class TestInput{ public static void main(string args[]){ Scanner s = new Scanner(System.in); System.out.println(" 请输入你的姓名 :"); String name = s.nextline(); System.out.println(" 请输入年龄 :"); int age = s.nextint(); System.out.println(" 请输入你的工资数额 :"); double salary = s.nextdouble(); System.out.println(" 您的个人信息 :\n 姓名 :" + name + "\t 年龄 :" + age + " 岁 \t 工资 :" + salary + " 元 ");

49 标准输入 / 输出 (2) 控制台输出的三种方式 System.out.pirntln() 输出单个数据到控制台上并换行 System.out.print() 输出单个数据但不换行 System.out.printf() 提供增强的格式化输出数据的功能 printf() 方法语法格式 System.out.printf(< 输出格式字符串 >,< 输出数据列表 >); printf() 应用举例 double salary = / 3 ; System.out.printf("%10.2f",salary); 输出结果 : Java 编码惯例 命名惯例 项目 类 变量 方法 接口 常量 包 同 类 的命名规则 ; 分隔和缩进 使用注释 命名规则 名词或名词性词组, 每个单词首字母大写 ; 名词或名词性词组, 首字母小写, 第二个及以后的单词首字母大写 ; 单词间可以使用下画线分隔 ; 变量名不宜过长但也应有意义 ; 动词或动词性词组, 首字母小写, 第二个及以后的单词首字母大写 ; 名词或名词性词组, 每个单词的首字母大写 ; 单词间使用下画线分隔 ; 名词或名词性词组, 全部小写 ; 一般使用本公司 / 组织网站域名的逆序 后跟具体的软件内部模块名 说明 / 举例 class Person; class SprintRain; double salary; int student_age; String studentname; run(); displayinfo(); interface Runner; int MAX_LEVEL; double Comm_Tax; package com.sun.java; package com.icbc.db;

50 第四章 运算符 表达式和流程控制 本章学习目标 1 运算符 2 表达式 3 分支语句 4 循环语句 5 递归

51 运算符 算术运算符 : +,,*,/,%,++, 关系运算符 : >,<,>=,<=,==,!= 布尔逻辑运算符 :!,&,, ^, &&, 位运算符 : &,,^,~, >>,<<,>>> 赋值运算符 : = 扩展赋值运算符 : +=, =,*=,/= 字符串连接运算符 : + 条件运算符 :?: 逻辑运算符 逻辑运算符功能!-- 逻辑非 & -- 逻辑与 -- 逻辑或 ^ -- 逻辑异或 &&-- 短路与 -- 短路或 逻辑运算符功能说明 : a b!a a&b a b a^b a&&b a b true true false true true false true true true false false false true true false true false true true false true true false true false false true false false false false false

52 使用逻辑运算符 public class Test1{ public static void main(string args[]){ boolean a,b,c; a = true; b = false; c = a & b; System.out.println(c); c = a b; System.out.println(c); c = a ^ b; System.out.println(c); c =!a; System.out.println(c); c = a && b; System.out.println(c); c = a b; System.out.println(c); 短路逻辑运算符 使用短路逻辑运算符 && 和 可实现 短路 的 与 和 或 运算的功能 当根据第一个操作数的值已经能够确定整个表达式的结果时, 将跳过对第二个操作数值的评估, 直接得出最终结果 public void m1(int n){ if(n<0 n>31){ System.out.println(" 非法赋值 ");

53 使用短路逻辑运算符 class MyDate{ public int day,month,year; public MyDate(int d, int m, int y){ day = d; month = m; year=y; public class Test { public static void main(string args[]){ MyDate m = null; m = new MyDate(38,6,2002); if((m!=null) && (m.day>0) && (m.day<31)) { System.out.println(" 日期合法 "); 位运算符 位运算符功能 ~ -- 取反 & -- 按位与 -- 按位或 ^ -- 按 位异或 位运算符功能说明 : ~ & ^

54 Java 整数二进制表示 Java 语言二进制数采用补码形式表示, 数正负区分标志 : 符号位 正数进制转换 十进制 ---- 二进制 : 除 2 取余 除尽为止 二进制 ---- 十进制 : 累加求和 负数进制转换 十进制到二进制 : 1. 取绝对值 2. 转换为二进制 3. 逐位取反 4. 加 1 二进制到十进制 : 1. 减 1 2. 逐位取反 3. 转换为十进制正数 4. 乘 使用位运算符 public class TestBitwiseOperator{ public static void main(string args[]){ int a = 9 & 12; int b = 9 12; int c = 9 ^ 12; int d = ~ 12; System.out.println(a); System.out.println(b); System.out.println(c); System.out.println(d); 输出结果 :

55 移位运算符 移位运算符用于对整型数据的二进制位进行移位处理 左移 "a<<b;" 将二进制形式的 a 逐位左移 b 位, 最低位 ( 右侧 ) 空出的 b 位补 0, 原来最左侧的 b 位被丢弃 带符号右移 "a>>b;" 将二进制形式的 a 逐位右移 b 位, 最高位 ( 左侧 ) 空出的 b 位补原来的符号位 ; 无符号右移 "a>>>b;" 将二进制形式的 a 逐位右移 b 位, 最高位 空出的 b 位补 移位运算展示 2227 = 2227<<3 = 2227>>3 = 2227>>>3 = = -2227<<3 = -2227>>3 = -2227>>>3 =

56 移位运算符性质 适用数据类型 :byte short char int long, 对低于 int 型的操作数将先自动转换为 int 型, 再进行移位 对于 int 型整数移位 a>>b, 系统先将 b 对 32 取模, 得到的结果才是真正移位的位数 对于 long 型整数移位时 a>>b, 则是先将移位位数 b 对 64 取模 使用移位运算符 public class Test{ public static void main(string args[]){ int a=10; int j = a>>>3; int k = a<<3; int m = a>>32; System.out.println("j=" + j ); System.out.println("k=" +k ); System.out.println("m=" +m ); 输出结果 : j=1 k=80 m=

57 赋值运算符 = 将等号右侧表达式的计算结果赋给等号左侧的变量 赋值操作时遵循值传递原则 "=" 左侧必须是一个已经声明过的变量, 而不允许 是常量或复合表达式, 例如 : int i = 5, j = 6; // 合法 j = i + 10 ; // 合法 10 = i + j; // 非法 i + j = 10; // 非法 赋值运算符左右两侧的数据类型应保持一致, 可以自动进行类型转换的情况除外 扩展赋值运算符 将赋值运算符和其他的运算符结合起来可以组成扩展赋值运算符, 以实现简化的运算标记效果 运算符 += -= *= /= %= &= = ^= <<= >>= >>>= 使用格式 a += b a -= b a *= b a /= b a %= b a &= b a = b a ^= b a <<= b a >>= b a >>>= b 功能说明 a = a + b a = a - b a = a * b a = a / b a = a % b a = a & b a = a b a = a ^ b a = a << b a = a >> b a = a >>> b

58 条件运算符?: 语法格式 : < 表达式 1>? < 表达式 2> : < 表达式 3> 说明 : 其中 < 表达式 1> 必须为 boolean 类型, 系统将首先计算 < 表达式 1> 的值, 当其值为 true 时, 则将 < 表达式 2> 的值作为整个表达式的最终结果, 否则将 < 表达式 3> 的值作为整个表达式的最终结果 举例 : int score = 50; int result = x <60? 60: x; String type = score <60? " 不及格 " : " 及格 "; 自增 / 自减运算符 ++/-- 也称增量 / 减量运算符, 用于对单个变量进行增 1 和减 1 操作 可以单独使用, 也可用于复合表达式中 ; 运算符可以位于变量之前, 也可用于变量之后 : 位于变量前面时, 先进行变量的增量 / 减量运算, 然后再取用变量的值计算整个表达式的结果 ; 位于变量后面时, 先取用变量的值计算整个表达式的结果, 然后才进行增量 / 减量运算 int i = 5; int j; i ++; // 等价于 i = i + 1; 或 ++i; j = ++i; // 等价于 i = i + 1; j = i; j = i++; // 等价于 j = i; i= i + 1; j = 4 * i--; // 等价于 j = 4 * i; i = i - 1;

59 字符串连接运算符 + "+" 除用于算术加法运算外, 还可用于对字符串进行连接操作 int i = ; String s = "hello, " + "world!"; "+" 运算符两侧的操作数中只要有一个是字符串 (String) 类型, 系统会自动将另一个操作数转换为字符串然后再进行连接 int i = ; String s = "hello, " + i + " 号 "; System.out.println(s); 输出结果 : hello, 305 号 表达式 表达式是符合一定语法规则的运算符和操作数的序列 a a (a-b) * c - 4 表达式的类型和值 对表达式中操作数进行运算得到的结果称为表达式的值 表达式的值的数据类型即为表达式的类型 表达式的运算顺序 首先应按照运算符的优先级从高到低的顺序进行 String s1 = "hello"; System.out.println(s1); 优先级相同的运算符按照事先约定的结合方向进行 8hello String s2 = "hello" ; System.out.println(s2); 输出结果 : hello

60 运算符优先级 / 结合方向 结合方向从左向右从右向左从左向右从左向右从左向右从左向右从左向右从左向右从左向右从左向右从左向右从左向右从右向左从右向左 Java 运算符 [] (). ( 方法调用 ) ( 单目运算 ) -( 单目运算 ) ~! ( 强制类型转换 ) new * / % +( 加 ) -( 减 ) << >> >>> < <= > >= instanceof ==!= & ^ &&?: = += -+ *= /= %= &= = ^= <<= >>= >>>= 数值类型转换 表达式运算中会出现将数值从一种类型转换为另外一种类型的情况 自动类型转换 int n = 35; long a = n; float f = n; double d = 'c'; double e = 3.14f; 强制类型转换 int i = (int)3.14; byte b = (byte)i; 数值类型间转换途径 char byte short int float long double

61 程序运行流程 按照运行流程来划分, 程序可分为三种基本结构 顺序性结构 分支结构和循环结构 顺序性结构 : 按照语句出现的顺序依次执行的程序结构 语句 A 语句 B 顺序性结构 分支结构 分支结构也称选择性结构, 有条件地执行或跳过特定的语句或语句块, 实现有选择的流程控制 条件 true 语句块 false true 条件 false 语句块 1 语句块 2 条件 1 false 条件 2 false 条件 n false true true true 语句块 1 语句块 2 语句块 n 单路分支结构 双路分支结构 语句块 n+1 多路分支结构

62 循环结构 在一定的条件下重复执行特定代码 条件 true 语句块 false 语句块 true 条件 false 当型循环结构 直到型循环结构 if-else 语句 if-else 语句用于实现分支结构, 其中的 else 子句不是必须的,if 语句又可细分为三种形式 : 1. 使用 if 语句实现单路分支结构 语法格式 : if(<boolean 类型表达式 >) < 语句或语句块 > 使用举例 int score = 57; : if(score < 60) score = 60; // 受 if 条件影响, 条件成立时执行 System.out.println("score:" + score); // 无条件执行

63 if-else 语句 ( 续 ) 2. 使用 if-else 语句实现双路分支结构 语法格式 : if(< 表达式 >) < 语句或语句块 1> else < 语句或语句块 2> 使用举例 : public void m1(int a, int b){ int max; if(a > b) max = a; else max = b; System.out.println("max=" + max); if-else 语句 ( 续 ) 3. 使用 if-else 语句实现多路分支结构 语法格式 : if(< 表达式 1>) < 语句 1> else if(< 表达式 2>) < 语句 2> else if(< 表达式 n>) < 语句 n> [else < 语句 n+1>] 使用举例 : public char convert(int score){ char grade; if (score >= 90) { grade = 'A'; else if (score >= 75) { grade = 'B'; else if (score >= 60) { grade = 'C'; else { grade = 'F'; return grade;

64 switch 语句 用于实现简单的多路分支结构, 语法格式 : switch (< 表达式 >){ case < 常量 1>: [< 语句 1>] case < 常量 2>: [< 语句 2>]... case < 常量 n>: [< 语句 n-1>] [default: < 语句 n> ] 相关规则 : 表达式 expr 的返回值必须是下述几种类型之一 :int, byte, char, short, 枚举类型和封装类类型 ; case 子句中的值 constant 必须是常量且所有 case 子句中的值应是不同的 ; default 子句是任选的 ; break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块 ; switch 语句举例 public class Test{ public static void main(string args[]){ int i = 1; switch (i) { case 0: System.out.println("zero"); break; case 1: System.out.println("one"); break; case 2: System.out.println("two"); break; default: System.out.println("default"); break;

65 switch 语句举例 ( 续 ) public void convert(char grade){ switch (grade){ case 'A': case 'B': case 'C': System.out.println(">=60"); break; case 'D': System.out.println("<60"); break; default: System.out.println("error"); break; Ex 4-1 写一方法, 在调用时通过参数输入年号, 判断是否为闰年 算法 : 当年号能被 4 整除但不能被 100 整除时, 为闰年 当年号能被 400 整除时, 为闰年

66 循环语句 循环语句功能 : 在循环条件满足的情况下, 反复执行特定代码 循环语句的四个组成部分 初始化部分 (init_statement) 循环条件部分 (test_exp) 循环体部分 (body_statement) 迭代部分 (alter_statement) 循环语句分类 for 循环 while 循环 do-while 循环 for-each 循环 for 循环 语法格式 : for (< 初始化表达式 >; < 循环条件表达式 >; < 迭代表达式 >) < 循环体语句或语句块 > 应用举例 : public class TestForLoop { public static void main(string args[]){ int result = 0; for(int i = 1; i<=100; i++){ result += i; System.out.println(result);

67 for 循环执行过程 开始 for (< 初始化表达式 >; < 循环条件表达式 >; < 迭代表达式 >) false 6 true 结束 < 语句 > 执行初始化表达式 ; 2. 计算循环条件表达式的值, 如果其值为 true, 则继续执行第 3 步, 否则结束循环 ; 3. 执行循环体语句 ; 4. 执行迭代表达式, 然后返回到第 2 步继续执行 while 循环 语法格式 : while(< 循环条件表达式 >) < 循环体语句或语句块 > 应用举例 : public class TestWhileLoop{ public static void main(string args[]){ int i = 1; int result = 0; while(i <= 100){ result += i; i ++; System.out.println(result);

68 do-while 循环 语法格式 : do < 循环体语句或语句块 > while(< 循环条件表达式 >) 应用举例 : public class TestDoWhileLoop{ public static void main(string args[]){ int i = 1; int result = 0; do{ result += i; i ++; while(i <= 100); System.out.println(result); for-each 循环 功能 : 逐个处理 ( 遍历 ) 数组或集合中的所有元素 语法格式 : for(< 迭代变量声明 > : < 数组或集合 >) < 循环体语句或语句块 > 应用举例 : public class TestForEachLoop{ public static void main(string args[]){ int[] a = {3,5,78,12; for(int k : a){ System.out.println(k); 输出结果 :

69 循环用法总结 对于同一问题, 三种循环可相互替代 for 循环功能强于 while do-while 但若不是明显地给出循环变量初终值 ( 或修改条件 ), 则应用 while 或 do-while 循环以增强程序的结构化和可读性 除 for-eache 以外, 其它的循环结构要防止出现无限循环 死循环 循环过程中, 也可以提前跳出本次循环或终止整个循环, 这需要用到下述的特殊流程控制语句 continue 和 break break 语句 break 语句的作用是终止所在的 switch 语句或循环语句的运行 语法格式 : break; break < 标签 >; 用法举例 : // 终止其所在的单层 ( 内层 ) 循环的运行 // 在多层嵌套循环中, 终止标签标记的外层循环的运行 public class TestBreak{ public static void main(string args[]){ for(int i = 0; i<10; i++){ if(i==3) break; System.out.println(" i =" + i); System.out.println("Game Over!");

70 continue 语句 continue 语句用于结束所在的循环语句的本次运行, 即跳过其后的循环体语句, 开始下一次循环 语法格式 continue; : // 跳过其所在单层 ( 内层 ) 循环的本次运行 continue < 标签 >; 用法举例 : // 在嵌套循环中, 跳过标签标记的外层循环的本次运行 public class TestContinue{ public static void main(string args[]){ for (int i = 0; i < 100; i++) { if (i%10==0) continue; System.out.println(i); 使用标签的流程控制 public class TestContinueOuter{ public static void main(string args[]){ int n = 0; outer: for(int i=101;i<200;i+=2){ // 外层循环 for(int j=2; j<i;j++){ // 内层循环 if(i%j==0) continue outer; // 不能使用 "break", 为什么? System.out.print(i + "\t"); n++; if(n<6 ) continue; System.out.println(); n = 0; 输出结果 // 输出六个数据后换行 :

71 Ex 4-2 练习目的体会和巩固循环语句 分支语句 特殊流控制语句 表达式的计算次序 逻辑运算符的用法 ; 练习题目 1. 编写程序, 采用适当的循环和流控制语句实现下述功能 : 打印输出 0~200 之间能被 7 整除但不能被 4 整除的所有整数 ; 要求每行显示 6 个数据 ; 2. 编写程序 ( 方法 ), 采用适当的循环和流控制语句实现下述功能 : 输出参数指定数据 ( 整数 ) 的所有素数因子 递 归 问题 : 求给定整数的阶乘, 如何实现? 解决方案 : 1. 采用循环结构 public int f(int n){ if(n == 1){ return 1; else{ int k = f(n-1); return n*k; 2. 采用递归结构 public int f(int n){ if(n == 1){ return 1; else{ int k = f(n-1); return n*k;

72 使用递归 public class Factorial{ public int f(int n){ if(n == 1){ return 1; else{ int k = f(n-1); return n*k; public static void main(string args[]){ Factorial fact = new Factorial(); int result = fact.f(4); System.out.println(result); 输出结果 : 递归基本思想和要素 递归方法解决问题的基本思想是 依此类推 实现原理 : 1. 先求得范围或规模缩小的同种性质问题的结果, 然后再利用上一步已得到的结果经过简单操作处理求得问题的最后解答 ; 2. 重复前述的步骤, 当相同性质的问题被简化到足够简单时, 将可直接获得问题的答案, 而不会无限重复下去 递归要素 : 递推公式 递归终止条件

73 Ex 4-3 问题 : 求 Fibonacci 数列 : 1, 1, 2, 3, 5, 8, 第 40 个数的值 数列规律 : F 1 = 1, F 2 = 1 F n = F n 1 + F n 2 程序要点 : 1. 使用递归 2. 不使用递归 (n>2) 第五章数组 73

74 本课学习目标 1 一维数组的声明和初始化 2 数组元素的引用 3 多维数组 4 数组拷贝 5 数组排序 数组概述 数组是多个相同类型数据的组合, 实现对这些数据的统一管理 数组属引用类型, 数组型数据是对象 (object), 数组中的每个元素相当于该对象的成员变量 数组中的元素可以是任何数据类型, 包括基本类型和引用类型

75 声明数组类型变量 一维数组声明的语法格式 < 类型 > var[]; 或 < 类型 > [] var; 举例 : int[] a; double d[]; String[] args; Person p[]; Java 语言中声明数组类型的变量时不允许指定数组的长度 ( 数组中元素的个数 ) int[3] a; // 非法 创建并使用数组 (1) 创建数组对象语法格式 : new < 元素类型 >[< 数组长度 >] 基本类型元素组成的一维数组 (1) public class Test{ public static void main(string args[]){ int[] s; s = new int[10]; for ( int i=0; i<10; i++ ) { s[i] =2*i+1; System.out.println(s[i]); main s 栈内存 堆内存 处内存状态

76 创建并使用数组 (2) 基本类型元素组成的一维数组 (2) public class Test{ 栈内存 public static void main(string args[]){ int[] s; s = new int[10]; for ( int i=0; i<10; i++ ) { s[i] =2*i+1; System.out.println(s[i]); main s int[] 对象 处内存状态 堆内存 创建并使用数组 (3) 基本类型元素组成的一维数组 (3) public class Test{ 栈内存 public static void main(string args[]){ int[] s; s = new int[10]; for ( int i=0; i<10; i++ ) { s[i] =2*i+1; System.out.println(s[i]); main s int[] 对象 处内存状态 堆内存

77 创建并使用数组 (4) 引用类型元素组成的一维数组 (1) public class MyDate{ private int day; private int month; private int year; public MyDate(int d, int m, int y){ day = d; month = m; year = y; public void display(){ System.out.println(day + "-" + month + "-" + year); 创建并使用数组 (5) 引用类型元素组成的一维数组 (2) public class Test{ 栈内存 public static void main(string args[]){ MyDate[] m; m = new MyDate[10]; for ( int i=0; i<10; i++ ) { m[i] =new MyDate(i+1, i+1, 1990+i); m[i].display(); main m 处内存状态 堆内存

78 创建并使用数组 (6) 引用类型元素组成的一维数组 (3) public class Test{ 栈内存 public static void main(string args[]){ MyDate[] m; m = new MyDate[10]; for ( int i=0; i<10; i++ ) { m[i] =new MyDate(i+1, i+1, 1990+i); m[i].display(); main m MyDate[] 对象 null null null null null null null null null null 处内存状态 堆内存 创建并使用数组 (7) 引用类型元素组成的一维数组 (3) public class Test{ 栈内存 public static void main(string args[]){ MyDate[] m; m = new MyDate[10]; for ( int i=0; i<10; i++ ) { m[i] =new MyDate(i+1, i+1, 1990+i); m[i].display(); main m MyDate[] null null null null null null null null null null 堆内存 MyDate For 循环执行三次后内存状态

79 数组元素缺省初始化 数组是引用类型, 它的元素相当于类的成员变量, 因此数组对象一经创建, 其中的每个元素也被按照成员变量同样的方式被隐式初始化 例如 : public class Test { public static void main(string argv[]){ int a[]= new int[5]; System.out.println(a[3]); 数组初始化 (1) 动态初始化数组定义 创建对象以及为数组元素赋值等操作分开进行 int a[]; a = new int[3]; a[0] = 3; a[1] = 9; a[2] = 8; MyDate dates[]; dates = new MyDate[3]; dates[0] = new MyDate(22, 7, 1964); dates[1] = new MyDate(1, 1, 2000); dates[2] = new MyDate(22, 12, 1964);

80 数组初始化 (2) 静态初始化在定义数组的同时就为数组元素分配空间并赋值 int[] a = { 3, 9, 8; MyDate dates[] = { new MyDate(22, 7, 1964), new MyDate(1, 1, 2000), new MyDate(22, 12, 1964) ; 数组元素的引用 创建数组对象后才可以引用数组中的元素, 格式 < 数组名 : >[< 元素下标 >] 其中, 元素下标应为整型表达式 如 a[3], b[i], c[6*i] 数组元素下标从 0 开始 ; 长度为 n 的数组合法下标取值范围 :0 ~ n-1; Java 数组对象一经创建, 其长度不可改变, 如果越界访问数组元素 ( 即元素下标超过零至数组长度 -1 的范围 ) 时将出现运行错误 此外, 数组对象拥有一个由系统自动提供的特殊属性 int[] a = new length, int[3]; 用于以只读的方式给出数组的输出结果 : System.out.println(a.length); 3 长度

81 Ex 5-1 编写一应用程序实现下述功能 : 创建一基本数据类型元素组成的数组并输出各数组元素的值 编写一应用程序练习数组对象的两种初始化方式, 并输出各元素的值 编写程序, 练习使用数组类型对象的 length 属性, 测试并体会数组元素的默认初始化机制 ; 多维数组 多维数组可以理解为由若干个低维数组所组成的数组 二维数组举例 : int a[][] = {{1,2,{3,4,0,9,{5,6,7; i j i = 0 j = 0 1 j = 1 2 j = 2 j = 3 i = i =

82 多维数组特性 Java 中多维数组的声明和初始化应按从高维到低维的顺序进行 Java 中多维数组不必须是规则矩阵形式 举例 : int[][] a = new int[3][4]; int[][] t = new int[3][]; t[0] = new int[4]; t[1] = new int[2]; int[][] b = new int[][4]; // 非法 多维数组初始化 静态初始化 int a[][] = {{1,2,{2,3,{3,4,5; int b[3][2] = {{1,2,{2,3,{4,5; // 非法 动态初始化 int a = new int[3][]; a[0] = new int[2]; a[1] = new int[4]; a[2] = new int[3]; a[0][0] = 45; a[0][1] = 87; a[2][2] = 99;

83 Ex 5-2 编写一应用程序实现下述功能 : 创建一基本数据类型元素组成的二维数组, 依次并输出各数组元素的值 例如 : int a[][] = {{1,2,{2,3,4,5,{5,6,7; for(int i=0; i<a.length; i++) { for(int j=0; j<a[i].length; j++) { System.out.println(a[i][j]); 数组拷贝 java.lang.system 类的 arraycopy() 方法提供了数组元素复制功能 将一个数组的连续多个元素的值批量复制到另一个数组中 // 源数组 int source[] = { 1, 2, 3, 4, 5, 6 ; // 目的数组 int dest[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ; // 复制源数组中从下标 0 开始的 3 个元素到的数组, // 从下标 0 的位置开始存储 System.arraycopy(source, 0, dest, 0, 3); 拷贝后目标数组中各元素值?

84 数组排序 JDK 的 java.util 包中定义的 Arrays 类提供了多种数组排序的功能 // 创建样本数组 int[] a = {6,23,45,12,-83,94,41; // 数组排序 Arrays.sort(a); // 排序后数组元素输出 for(int i=0;i<a.length;i++){ System.out.print(arr[i] + "\t"); 输出结果 : 第六章 面向对象编程进阶 84

85 学习目标 1 包 2 继承 3 访问控制 4 方法重写 重载 5 多态性 6 关键字 super static final 包 为便于管理大型软件系统中数目众多的类, 解决类的命名冲突问题,Java 引入包 (package) 机制, 提供类的多重类命名空间 java lang io System Object String

86 package 语句 package 语句作为 Java 源文件的第一条语句, 指明该文件中定义的类所在的包 ( 若缺省该语句, 则指定为无名包 ) 语法格式 : package pkg1[.pkg2[.pkg3 ]]; 用法举例 : package p1; public class Test{ public void m1(){ System.out.println("In class Test, method m1 is running!"); 编译和生成包 Java 编译器把包对应于文件系统的目录管理,package 语句中, 用. 来指明包 ( 目录 ) 的层次 ; 如果在程序 Test.java 中已定义了包 p1, 编译 时采用如下方式 javac Test.java : 则编译器会在当前目录下生成 Test.class 文件, 再在适合位置 (destpath 目录 ) 手动创建一个名为 p1 javac 的子目录 -d destpath Test.java, 将 Test.class 复制到该 p1 目录下 则编译器会自动在 destpath 目录下建立一个子目录 p1, 并将生成的 文件都放到 172 下 86

87 import 语句 为使用定义在不同包中的 Java 类, 需用 import 语句来引入所需要的类 语法格式 : import pkg1[.pkg2 ].(classname *); 用法举例 : import p1.test; // 或 import p1.*; public class TestPackage{ public static void main(string args[]){ Test t = new Test(); t.m1(); Java 包特性 一个类如果未声明为 public 的, 则只能在其所在包中被使用, 其他包中的类即使在源文件中使用 import 语句也无法引入它 可以不在源文件开头使用 import 语句导入要使用的有名包中的类, 而是在程序代码中每次用到该类时都给出其完整的包层次, 例如 : public class TestPackage{ public static void main(string args[]){ p1.test t = new p1.test(); // 每次用到时给出包层次 t.m1();

88 JDK 中主要的包介绍 包名功能说明包名含义 java.lang 包含了 Java 语言程序设计的基础类 lang 是 language 的简写 java.awt java.util java.io java.net 包含用于创建图形用户界面和绘制图形图像的相关类 包含集合 日期 国际化和各种实用工具类包含可提供数据输入 / 输出相关功能的类提供用于实现 Java 网络编程的相关功能类 awt 是抽象窗口工具集 (abstract window toolkit) 的简写 util 是 utility 的简写 io 是 input/output 的简写 net 意为网络 java.sql 提供数据库操作相关功能类 sql 是结构化查询语言 (structed query language) 的简写 Ex 6-1 练习使用 Java 包

89 继承 (1) 继承 (Inheritance) 是面向对象编程的核心机制之一, 其本质是在已有类型基础之上进行扩充或改造, 得到新的数据类型, 以满足新的需要 根据需要定义 Java 类描述 " 人 " 和 " 学生 " 信息 : public class Person { public String name; public int age; public Date birthdate; public String getinfo() {... public class Student { public String name; public int age; public Date birthdate; public String school; public String getinfo() {... 通过继承, 简化 Student 类的定义 : public class Student extends Person{ public String school; 继承 (2) Java 类声明语法格式 : [< 修饰符 >] class < 类名 > [extends < 父类名 >] { [< 属性声明 >] [< 构造方法声明 >] [< 方法声明 >] Object 类是所有 Java 类的最高层父类, 如果在类的声明中未使用 extends 关键字指明其父类, 则默认父类为 Object 类 public class Person {... 等价于 : public class Person extends Object {

90 继承 (3) Java 只支持单继承, 不允许多重继承 一个子类只能有一个父类 一个父类可以派生出多个子类 Soldier Person +name : String +age : int +birthdate : + Date getinfo() : String Student +school : String +setschool : void +getschool : String Officer Graduate +major : String + register() : void Ex 按照上一页的类结构及继承关系, 定义实现 Java 类 Person Student Graduate 所有的类 属性及方法均定义为 public 的 2. 编写 Java 程序 创建 Graduate 类型对象并测试 访问其所有继承来的方法和属性 3. 将父类 Person Student 中的部分属性 / 方法改为 private 的, 然后重复 2 中的测试

91 访问控制 访问控制是指对 Java 类或类中成员的操作进行限制, 即规定其在多大的范围内可以被直接访问 类的访问控制 public 的类可在任意场合被引入和使用, 而非 public 的类只能在其所在包中被使用 类中成员的访问控制修饰符个个 : private 缺省 protect ed public 同一 类中 Yes Yes Yes Yes 同一 包中 Yes Yes Yes 子类中 Yes Yes 任意范围 Yes 类范围 包范围 任意范围 子类中 访问控制举例 public class Parent{ private int n_private = 1; int n_default = 2; protected int n_protected = 3; public int n_public = 4; public void testprint(){ System.out.println("n_private " + n_private ); System.out.println("n_default " + n_default); System.out.println("n_protected " + n_protected ); System.out.println("n_public " + n_public ); public class Child extends Parent{ public void child_testprint(){ System.out.println("n_private " + n_private ); // 非法 System.out.println("n_default " + n_default); System.out.println("n_protected " + n_protected ); System.out.println("n_public " + n_public );

92 方法重写 什么是方法重写? 在子类中可以根据需要对从父类中继承来的方法进行重新定义, 此称方法重写 (Override) 或覆盖 语法规则 : 重写方法必须和被重写方法具有相同的方法名称 参数列表和返回值类型 ; 重写方法不能使用比被重写方法更严格的访问权限 ; 重写方法不允许声明抛出比被重写方法范围更大的异常类型 方法重写举例 (1) public class Person { String name; int age; public String getinfo() { return "Name:"+ name + "\t" +"age:"+ age; public class Student extends Person { private String school; public void setschool(string scholl){ this.school = school; public String getschool(){ return school; public String getinfo() { return "Name:"+ name + "\tage:"+ age + "\tschool:" + school;

93 方法重写举例 (2) public class Parent { public void method1() { public class Child extends Parent { private void method1() { // 非法 public class UseBoth { public void dootherthing() { Parent p1 = new Parent(); Child p2 = new Child(); p1.method1(); p2.method1(); 同名属性 public class Person{ int age = 5; public int getage(){ return age; public int getinfo(){ return age; public class Student extends Person{ int age = 6; public int getage(){ return age; public class Test{ public static void main(string args[]){ Person p = new Person(); System.out.println(p.getAge()); Student s = new Student(); System.out.println(s.age); System.out.println(s.getAge()); System.out.println(s.getInfo()); 输出结果 :

94 关键字 super 在存在命名冲突 ( 子类中存在方法重写或添加同名属性 ) 的情况下, 子类中的代码将自动使用子类中的同名属性或重写后的方法 也可以在子类中使用关键字 super 引用父类中的成分 : 访问父类中定义的属性 super.< 属性名 > 调用父类中定义的成员方法 super.< 方法名 >(< 实参列表 >) 子类构造方法中调用父类的构造方法 ( 见后文 ) super 的追溯不仅于直接父类 super 用法举例 (1) class Animal{ protected int i = 1; class Person extends Animal{ protected int i = 2; private String name = "Tom"; private int age = 9; // 用于测试同名属性, 无现实含义 // 用于测试同名属性, 无现实含义 public String getinfo(){ return "Name:" + name + "\tage:" + age; public void testi(){ System.out.println(super.i); System.out.println(i);

95 super 用法举例 (2) class Student extends Person{ private int i = 3; private String school = "THU"; public String getinfo(){ // 重写方法 return super.getinfo() + "\tschool:" + school; public void testi(){ // 重写方法 System.out.println(super.i); System.out.println(i); public class Test{ public static void main(string args[]){ Person p = new Person(); 输出结果 : System.out.println(p.getInfo()); Name:Tom p.testi(); 1 Student s = new Student(); System.out.println(s.getInfo()); 2 s.testi(); Name:Tom 2 3 Age:9 Age:9 School:THU Ex 6-3 编写应用程序, 实现 Java 方法重写并测试 编写应用程序, 测试 super 关键字用法

96 多态性 (1) 多态 在 Java 中, 子类的对象可以替代父类的对象使用 Java 引用变量与所引用对象间的类型匹配关系 : 1. 一个对象只能属于一种确定的数据类型, 该类型自对象创建直至销毁不能改变 2. 一个引用类型变量可能引用 ( 指向 ) 多种不同类型的对象 既可以引用其声明类型的对象, 也可以引用其声明类型的子类的对象 Person p = new Student(); //Student 是 Person 的子类 Person 类型变量 p 0x3a478b Student 类型对象 null 0 null name age schoo l 多态性举例 (1) public class Person{ private String name; private int age; public void setname(string name){ this.name = name; public String getname(){ return name; public void setage(int age){ this.age = age; public int getage(){ return age; public String getinfo(){ return "Name: " + name + "\tage: " + age;

97 多态性举例 (2) public class Student extends Person{ private String school; public void setschool(string school){ this.school = school; public String getschool(){ return school; public String getinfo(){ // 重写方法 return super.getinfo() + "\tschool: " + school; public class Test{ public static void main(string[] args){ Person p = new Student(); System.out.println(p.getInfo()); 多态性 (2) 引用类型数组元素相当于引用类型变量, 多态性也同样适用 : Person [] p= new Person[3]; // 假定 Student 类继承了 Person 类 p[0] = new Student(); //Graduate 类继承了 Student 类 p[1] = new Person(); p[2] = new Graduate(); 一个引用类型变量如果声明为父类的类型, 但实际引用的是子类对象, 那么该变量就不能再访问子类中添加的属性和方法 Student m = new Student(); m.setschoo("pku"); Person e = new Student(); e.setschoo("pku"); // 合法 // 非法

98 虚方法调用 正常的方法调用 Person p = new Person(); p.getinfo(); Student s = new Student(); s.getinfo(); 虚方法调用 (Virtual Method Invocation) Person e = new Student(); e.getinfo(); 编译时类型和运行时类型 多态性举例 (3) 方法声明的参数类型为父类类型, 可以使用子类的对象作为实参调用该方法 : public class Test{ public void show(person p){ //--- System.out.println(p.getInfo()); public static void main(string[] args){ Test t = new Test(); Person p = new Person(); t.show(p); Student s = new Student(); t.show(s);

99 Ex 6-4 编写应用程序, 测试 Java 语言多态性 对象造型 (Casting ) 引用类型数据值之间的强制类型转换称为造型, 具体规则如下 : 从子类到父类的类型转换可以自动进行 ; Person p = new Student(); 在多态的情况下, 从父类到子类的类型转换必须通过造型 ( 强制类型转换 ) 实现 ; Person p1 = new Student(); Student s1 = (Student)p1; Person p2 = new Person(); Student s2 = (Student)p2; 无继承关系的引用类型间的转换是非法的 String s = "Hello,World!"; Person p = (Person)s; // 合法 // 非法 // 非法

100 对象造型举例 public class Test{ public void cast(person p){ //System.out.println(p.getSchool()); // 非法, 编译出错! Student stu = (Student)p; //p1 System.out.println(stu.getSchool()); public static void main(string[] args){ Test t = new Test(); Student s = new Student(); t.cast(s); Person 类型变量 p Student 类型变量 stu 0x3a478b 0x3a478b Student 类型对象 null name 0 age null school 程序运行到 p1 处内存状态 instanceof 运算符 运算符 instanceof 用于检测一个对象的真正 类型 class Person{ //--- class Student extends Person{ //--- class Graduate extends Student{ //--- public class Tool{ public void distribute(person p){ if(p instanceof Graduate){ Graduate g = (Graduate)p; //--- // 处理 Graduate 类型及其子类类型对象! else if(p instanceof Student){ //--- // 处理 Student 类型及其子类类型对象! else{ //--- // 处理 Person 类型及其子类类型对象!

101 协变返回类型 协变返回类型 重写方法时修改其返回值的类型, 但必须是重写前方法返回值类型的子类或实现类类型 class A{ public Person getassistor(){ Person p = new Person(); //--- return p; class B extends A{ public Student getassistor(){ // 重写方法时改变了返回值类型 Student s = new Student(); s.setname("nancy"); s.setage(18); s.setschool("thu"); return s; 方法重载 在一个类中存在多个同名方法的情况称为方法重载 (Overload), 重载方法参数列表必 须不同 class Tool{ public void display(int i){ System.out.println(" 输出整数 :" + i); public void display(double d){ System.out.println(" 输出符点数 :" + d); public void display(string s){ System.out.println(" 输出文本 :" + s); public class TestOverLoad{ public static void main(string args[]){ Tool t = new Tool(); t.display(3); t.display(3.14); t.display("hello, 你好!");

102 构造方法重载 public class Person{ private String name; private int age; public Person(){ public Person(String name){ this.name = name; public Person(int age){ this.age = age; public Person(String name,int age){ this.name = name; this.age = age; // 其他成分 this 调用重载构造方法 可以在构造方法的第一行使用关键字 this 调用其它 ( 重载的 ) 构造方法 public class Person{ private String name; private int age; public Person(String name,int age){ this.name = name; this.age = age; public Person(String name){ this(name,18); public Person(int age){ this("anonymous",age); //

103 深究对象构造 / 初始化 在 Java 类的构造方法中一定直接或间接地调用了其父类的构造方法 (Object 类除外 ) 在子类的构造方法中可使用 super 语句调用父类的构造方法, 其格式为 : super(< 实参列表 >); 如果子类的构造方法中既没有显式地调用父类构造方法, 也没有使用 this 关键字调用同一个类的其他重载构造方法, 则系统会默认调用父类无参数的构造方法, 其格式为 : super(); 如果子类构造方法中既未显式调用父类构造方法, 而父类中又没有无参的构造方法, 则编译 出错 super 调用构造方法 (1) public class Person{ private String name; private int age; public Person(String name,int age){ this.name = name; this.age = age; public Person(String name){ this(name,18); public Person(int age){ this("anonymous",age); public void showinfo(){ System.out.println("Name:" + name + "\tage:" + age);

104 super 调用构造方法 (2) public class Student extends Person{ private String school; public Student(String name,int age,string school){ super(name,age); this.school = school; public Student(String name,string school){ super(name); this.school = school; public Student(String name,int age){ this(name,age,null); public Student(String school){ // 编译出错 //super(); this.school = school; 对象构造 / 初始化细节 第一阶段 : 为新建对象的实例变量分配存储空间并进行默认初始化 第二阶段 : 按下述步骤继续初始化实例变量 1) 绑定构造方法参数 ; 2) 如有 this() 调用, 则调用相应的重载构造方法, 然后跳转到步骤 5; 3) 显式或隐式追溯调用父类的构造方法 (Object 类除外 ); 4) 进行实例变量的显式初始化操作 ; 5) 执行当前构造方法的方法体中其余的语句

105 Ex 6-5 编写应用程序, 测试练习如下内容 : Java 对象造型 协变返回类型 方法重载 this 调用重载构造方法 super 调用父类构造方法 关键字 static 在 Java 类中声明属性 方法和内部类时, 可使用关键字 static 作为修饰符 static 标记的属性或方法由整个类 ( 所有实例 ) 共享, 如访问控制权限允许, 可不必创建该类对象而直接用类名加. 调用 static 成员也称 类成员 或 静态成员, 如 类属性 类变量 类方法 静态方法 等

106 static 属性 static 属性由其所在类 ( 包括该类所有的实例 ) 共享, 而非 static 属性则必须依赖具体 / 特定的对象 ( 实例 ) 而存在 public class Person { private int id; public static int total = 0; public Person() { total++; id = total; <<instanceof>> p1 : Person id=1 Person +total : int = 0 -id : int <<instanceof>> p2 : Person id= static 属性应用举例 public class Person{ private int id; public static int total = 0; public Person(){ total ++; id = total; public class Test { public static void main(string args[]) { Person.total = 100; System.out.println(Person.total); Person p1 = new Person(); Person p2 = new Person(); System.out.println(Person.total); 输出结果 :?

107 static 方法 public class Person { private int id; private static int total = 0; public Person() { total++; id = total; public int getid(){ return id; public static int gettotalperson() { return total; public class Test{ public static void main(string[] args) { System.out.println(Person.getTotalPerson()); Person p1 = new Person(); System.out.println(p1.getTotalPerson()); System.out.println(Person.getTotalPerson()); 输出结果 :? static 初始化块 在类的定义体中 方法的外部可包含 static 语句块,static 块仅在其所属的类被载入时执行一次, 通常用于初始化化 static ( 类 ) 属 性 class Person { public static int total; static { total = 100; System.out.println("in static block!"); public class Test { public static void main(string[] args) { System.out.println("total = "+ Person.total); System.out.println("total = "+ Person.total); 输出结果 :?

108 非 static 初始化块 非 static 的初始化块在创建对象时被自动调 用 class A{ private int i = 5; { System.out.println(" 创建新对象 ---"); public A(){ public A(int a){ System.out.println(" 开始执行构造方法体中语句 "); i = a; System.out.println(" 构造方法体中语句执行完毕 "); public class Test { public static void main(string[] args) { new A(); new A(3); 输出结果 : 创建新对象 --- 创建新对象 --- 开始执行构造方法体中语句构造方法体中语句执行完毕 静态导入 静态导入用于在一个类中导入其他类或接口中的 static 成员, 语法格式 : import static < 包路径 >.< 类名 >.* 或 : import static < 包路径 >.< 类名 >.< 静态成员名 > 应用举例 : import static java.lang.math.*; public class Test{ public static void main(string[] args){ double d = sin(pi*0.45); //double d = Math.sin(Math.PI*0.45); System.out.println(d);

109 Singleton 设计模式 public class Single{ private String name; private static Single onlyone = new Single(); private Single(){ public void setname(string name){ this.name = name; public String getname(){ return name; public static Single getsingle() { return onlyone; public class TestSingle{ public static void m1(){ Single s2 = Single.getSingle(); System.out.println(s2.getName()); public static void main(string args[]) { Single s1 = Single.getSingle(); s1.setname("tom"); m1(); 输出结果 :? 关键字 final 在声明 Java 类 变量和方法时可以使用关键字 final 来修饰, 以使其具有 终态 的特性 : final 标记的类不能被继承 final 标记的方法不能被子类重写 final 标记的变量 ( 成员变量或局部变量 ) 即成为常量, 只能赋值一次 final 标记的成员变量必须在声明的同时或在每个构造方法中显式赋值, 然后才能使用 final 不允许用于修饰构造方法 抽象类以及抽象方法

110 关键字 final 应用举例 public final class Test{ public static int totalnumber= 5 ; public final int id; public Test(){ id = ++totalnumber; public static void main(string[] args) { Test t = new Test(); System.out.println(t.id); final int i = 10; final int j; j = 20; j = 30; // 非法 Ex 6-6 练习上述有关例程, 体会并掌握 static/final 关键字的用法 ;

111 第七章 高级类特性 本章学习目标 1 抽象类 2 接口 3 内部类 4 枚举类型

112 抽象类 (1) 在定义 Java 方法时可以只给出方法头, 而不必给出方法体 即方法实现的细节, 这样的方法被称为抽象方法 抽象方法必须使用关键字 abstract 修饰, 包含抽象方法的类必须声明为抽象类 public abstract class Animal{ private int age; public void setage(int age){ this.age = age; public int getage(){ return age; public abstract void eat(); 抽象类 (2) public class Person extends Animal{ private String name; public void setname(string name){ this.name = name; public String getname(){ return name; public void eat(){// 重写方法 System.out.println(" 洗手 烹饪 摆餐具 吃喝 收摊儿 ---"); public class Bird extends Animal{ public void fly(){// 重写方法 System.out.println(" 我心飞翔!"); public void eat(){ System.out.println(" 直接吞食!");

113 抽象类 (3) Java 语言规定, 子类必须实现其父类中的所有抽象方法, 否则该子类也只能声明为抽象类 抽象类不能被实例化 public class Test{ public static void main(string[] args){ Animal a = new Person(); a.setage(2); a.eat(); 抽象类 (4) 抽象类主要是通过继承 再由其子类发挥作用的, 其作用包括两方面 : 代码重用 规划 其他特性 : 抽象类中可以不包含抽象方法 ; 子类中可以不全部实现抽象父类中的抽象方法, 但此时子类也只能声明为抽象类 ; 父类不是抽象类, 但在子类中可以添加抽象方法, 但子类需声明为抽象类 ; 抽象类中可以声明 static 属性和方法 ;

114 Ex 7-1 参照前述例程, 编写自己的抽象类和应用程序, 测试并体会抽象类相关特性 接口 (1) 接口 (interface) 是抽象方法和常量值的定义的集合 从本质上讲, 接口是一种特殊的抽象类, 这种抽象类中只包含常量和方法的定义, 而没有变量和方法的实现 接口举例 : public interface Runner{ public static final int id = 1; public abstract void start(); public abstract void run(); public abstract void stop();

115 接口 (2) 接口中定义的属性必须是 public static final 的, 而接口中定义的方法则必须是 public abstract 的, 因此这些修饰符可以部分或全部省略 public interface : Runner{ public static final int id = 1; public abstract void start(); public abstract void run(); public abstract void stop(); 等价于 和继承关系类似,Java 类可以 实现 接口, 且接口和实现类之间也存在多态性 [< modifier>] class < name> [extends < superclass>] [implements < interface> [,< interface>]* ] { declarations>* public interface Runner{ int id = 1; void start(); void run(); void stop(); 接口应用举例 (1) public class Person implements Runner{ public void start(){ System.out.println(" 弯腰 蹬腿 咬牙 瞪眼 开跑 "); public void run(){ System.out.println(" 摆动手臂 维持直线方向 "); public void stop(){ System.out.println(" 减速直至停止 喝水 "); public class Test{ public static void main(string[] args){ Runner r = new Person(); r.start(); r.run(); r.stop();

116 接口应用举例 (2) <<interface> > Runner +start() +run() +stop() Person +start() +run() +stop() +dance() Car +start() +run() +stop() +fillfuel() +crack() +start() +run() +stop() +fly() Bird 接口的多重实现 (1) interface Runner { public void run(); interface Swimmer { public void swim(); abstract class Animal { public abstract void eat(); class Person extends Animal implements Runner,Swimmer { public void run() { System.out.println("I am running, to the sea!"); public void swim() { System.out.println("I am swimming, to the island!"); public void eat() { System.out.println("I am eating!");

117 接口的多重实现 (2) public class Test{ public static void main(string args[]){ Test t = new Test(); Person p = new Person(); t.m1(p); t.m2(p); t.m3(p); public void m1(runner f) { f.run(); public void m2(swimmer s) { s.swim(); public void m3(animal a) { a.eat(); 输出结果 : I am running, to the sea! I am swimming, to the island! I am eating! 接口间的继承 interface A{ public void ma(); interface B{ public int mb(int i); interface C extends A,B{ public String mc(); class D implements C{ public void ma(){ System.out.println("Implements method ma()!"); public int mb(int i){ return i; public String mc(){ return "Hello!";

118 接口特性总结 通过接口可以实现不相关类的相同行为, 而不需要考虑这些类之间的层次关系 ; 接口可以被多重实现 ; 接口可以继承其它的接口, 并添加新的属性和抽象方法 接口间支持多重继承 Ex 7-2 定义自己的接口 实现类和测试程序, 体会接口的功能和用法

119 嵌套类 Java 语言支持类的嵌套定义, 即允许将一个类定义在其他类的内部, 其中内层的类被称为嵌套类 (Nested Class) 嵌套类可以分为两种 : 静态嵌套类 (Static Nested Class): 使用 static 修饰的嵌套类 ; 内部类 (Inner Class): 非 static 的嵌套类 public class A{ private class B{ public static class C{ // 内部类 // 静态嵌套类 内部类 内部类又可分为三种情况 : 1. 普通的内部类 : 在 Java 类中 方法或语句块的外部定义的非 static 类 2. 局部内部类 : 也称局部类 (Local Class), 定义在方法或语句块中的类 3. 匿名内部类 : 也称匿名类 ( Anonymous Class), 定义在方法或语句块中, 该类没有名字 只能在其所在之处使用一次 普通内部类 内部类 局部内部类 Java 嵌套类 匿名内部类 静态嵌套类

120 内部类 内部类与其所在的外层类之间存在着逻辑上的依赖关系 内部类的对象不能单独存在, 它必须依赖一个其外层类的对象 ; 在内部类中可以直接访问其外层类中的成员 包括属性和方法, 即使这些属性和方法是 private 的 内部类可以声明为抽象类, 因此可以被其它的内部类继承 也可以声明为 final 的 和外层类不同, 内部类可以声明为 private 或 protected 使用内部类 (1) public class A { private int s; public class B{ public void mb() { s = 100; //p3 System.out.println(" 在内部类 B 中 s=" + s); public void ma() { B i = new B(); //p2 i.mb(); public class TestInner { public static void main(string args[]){ A o = new A(); //p1 o.ma();

121 使用内部类 (2) public class A { private int s; public class B{ public void mb() { s = 100; //p3 处内存状态 System.out.println( " 在内部类 B 中 s=" + s); public void ma() { B i = new B(); //p2 处内存状态 i.mb(); mb() ma() main() ma() main() this i this 栈内存 0xa7b6c2 0xa7b6c2 0x2b374f o 0x2b374f args 0x5ca749 栈内存 0x2b374f i 0xa7b6c2 this 0x2b374f o 0x2b374f args 0x5ca749 B 类对象 0x2b374f 100 s A 类对象堆内存 String[] 对象 B 类对象 0x2b374f A.this A.this 0 s A 类对象堆内存 String[] 对象 public class TestInner { public static void main(string args[]){ A o = new A(); //p1 处内存状态 o.ma(); main() 栈内存 o 0x2b374f args 0x5ca749 A 类对象 0 String[] 对象 s 堆内存 使用内部类 (3) 在外部使用其他类中的内部类时, 应指明其完整层次, 并显式建立对象间的依赖关系 public class A { private int s; public class B { public void mb() { System.out.println(s); public class TestInner2 { public static void main(string[] args) { A a = new A(); // 创建一个依赖于 a 而存在的 b A.B b = a.new B(); b.mb();

122 使用内部类 (4) 内部类中出现变量命名冲突时, 可以使用内部类对象的特殊属性 "< 外层类名 >.this" 来访问其所依赖外层类对象的成员 class A{ private int s = 111; public class B { private int s = 222; public void mb(int s) { System.out.println(s); System.out.println(this.s); System.out.println(A.this.s); // 局部变量 s // 内部类对象的属性 s // 外层类对象属性 s public class TestInner3{ public static void main(string args[]){ A a = new A(); A.B b = a.new B(); b.mb(333); 枚举类型 Java SE5.0 开始,Java 语言引入了一种新的引用数据结构 枚举 (Enum) Java 语言中枚举类型均自动继承了 java.lang.enum 类 ( 该类继承了 Object 类 ) 枚举类型使用一组常量值来表示特定的数据集合, 该集合中数据的数目确定 ( 通常较少 ), 且这些数据只能取预先定义的值 public enum Week{ MON,TUE,WED,THU,FRI,SAT,SUN

123 使用枚举类型 public enum Week{ MON,TUE,WED,THU,FRI,SAT,SUN public class TestEnum{ public static void main(string[] args){ TestEnum te = new TestEnum(); te.work(week.sun); public void work(week day){ if(day.equals(week.sat)){ System.out.println(" 购物!"); else if(day.equals(week.sun)){ System.out.println(" 祈祷!"); else{ System.out.println(" 工作!"); 组合使用枚举类型与 switch 语句 public class TestEnumInSwitch{ public static void main(string[] args){ TestEnumInSwitch teis = new TestEnumInSwitch(); teis.work(week.fri); public void work(week day){ switch(day){ case MON: case TUE: case WED: case THU: case FRI: System.out.println(" 工作日, 去上班!"); break; case SAT: System.out.println(" 星期六, 去购物!"); break; case SUN: System.out.println(" 礼拜天, 去教堂!"); break; default: System.out.println(" 你有没有搞错!"); 输出结果 : 工作日, 去上班!

124 第八章 异常处理 本章学习目标 1 Java 异常的概念和分类 2 Java 异常处理机制 2.1 捕获和处理异常 2.2 声明抛弃异常 2.3 人工抛出异常 3 用户自定义异常 4 断言

125 什么是异常 异常 (Exception) 是程序运行过程中发生的事件, 该事件可以中断程序指令的正常执行流程 Java 异常分为两大类 : 错误 (Error) 是指 JVM 系统内部错误 资源耗尽等严重情况 ; 违例 (Exception) 则是指其他因编程错误或偶然的外在因素导致的一般性问题, 例如对负数开平方根 空指针访问 试图读取不存在的文件以及网络连接中断等 Java 异常举例 (1) public class TestException{ public static void main(string[] args) { String friends[]={"lisa","bily","kessy"; for(int i=0;i<5;i++) { System.out.println(friends[i]); System.out.println("\nthis is the end"); 程序运行时出错, 输出结果 : Lisa Bily Kessy Exception in thread "main" java.lang.arrayindexoutofboundsexception: 3 at TestException.main(TestException.java:5)

126 Java 异常举例 (2) class Person{ public int age; public class TestNullPointerException{ public static void main(string[] args) { Person p = null; System.out.println(p.age); 程序运行时出错, 输出结果 : Exception in thread "main" java.lang.nullpointerexception at TestNullPointerException.main(TestNullPointerException.java:8) Java 异常类层次 VirtualMachineError Error LinkageError IndexOutOfBoundsException Object Throwable RuntimeException NullPointerException ArithmeticException Exception IOException FileNotFoundException EOFException

127 常见异常 RuntimeException 错误的类型转换 数组下标越界 空指针访问 IOExeption 从一个不存在的文件中读取数据 越过文件结尾继续读取 连接一个不存在的 URL 异常处理机制 (1) Java 异常处理宗旨 : 1. 返回到一个安全和已知的状态 ; 2. 能够使用户执行其他的命令 ; 3. 如果可能, 则保存所有的工作 ; 4. 如果有必要, 可以退出以避免造成进一步的危害 处理机制 : 1. Java 程序执行过程中如出现异常, 系统会监测到并自动生成一个相应的异常类对象, 然后再将它交给运行时系统 ; 2. 运行时系统再寻找相应的代码来处理这一异常 如果 Java 运行时系统找不到可以处理异常的代码, 则运行时系统将终止, 相应的 Java 程序也将退出 3. 程序员通常对错误 (Error) 无能为力, 因而一般只处 理违例 (Exception)

128 异常处理机制 (2) try{... // 可能产生异常的代码 catch( ExceptionName1 e ){... // 当产生 ExceptionName1 型异常时的处置措施 catch( ExceptionName2 e ){... // 当产生 ExceptionName2 型异常时的处置措施 [ finally{... // 无条件执行的语句 ] public class Test{ public static void main(string[] args) { String friends[]={"lisa","billy","kessy"; try { for(int i=0;i<5;i++) { System.out.println(friends[i]); catch(arrayindexoutofboundsexception e) { System.out.println("index err"); System.out.println("\nthis is the end"); 输出结果 : Lisa Billy Kessy index err this is the end 使用 finally 块 public class Test{ public static void main(string[] args) { String friends[]={"lisa","billy","kessy"; try { for(int i=0;i<5;i++) { System.out.println(friends[i]); catch(arrayindexoutofboundsexception e) { System.out.println("index err"); return; finally{ System.out.println("in finally block!"); System.out.println("this is the end"); 输出结果 : Lisa Billy Kessy index err in finally block!

129 追踪运行栈信息 public class A{ public void work(int[] a){ String s = this.contain(a,3); System.out.println("Result: " + s); public String contain(int[] source, int dest){ String result = "no!"; try{ for(int i=0;i<source.length;i++){ if(source[i] == dest) result = "yes!"; catch(exception e){ System.out.println(" 异常信息 : " + e.getmessage()); System.out.println(" 运行栈信息 :"); e.printstacktrace(); result = "error!"; return result; public class MyTest{ public static void main(string[] args) { A tst = new A(); tst.work(null); 输出结果 : 异常信息 : null 运行栈信息 : java.lang.nullpointerexception at A.contain(A.java:9) at A.work(A.java:3) at MyTest.main(MyTest.java:4) Result: error! 输入 / 输出异常 (1) import java.io.*; public class TestIOException{ public static void main(string[] args) { FileInputStream in=new FileInputStream("myfile.txt"); int b; b = in.read(); while(b!= -1) { System.out.print((char)b); b = in.read(); in.close();

130 输入 / 输出异常 (2) 程序 TestIOException.java 编译时出错, 输出错误信息如下 : D:\ex\TestIOException.java:4: 未报告的异常 java.io.filenotfoundexception; 必须对其进行捕捉或声明以便抛出 FileInputStream in=new FileInputStream("myfile.txt"); ^ D:\ex\TestIOException.java:6: 未报告的异常 java.io.ioexception; 必须对其进行捕捉或声明以便抛出 b = in.read(); ^ D:\ex\TestIOException.java:9: 未报告的异常 java.io.ioexception; 必须对其进行捕捉或声明以便抛出 b = in.read(); ^ D:\ex\TestIOException.java:11: 未报告的异常 java.io.ioexception; 必须对其进行捕捉或声明以便抛出 in.close(); ^ 4 错误 输入 / 输出异常 (3) import java.io.*; public class TestIOException{ public static void main(string[] args) { try{ FileInputStream in=new FileInputStream("myfile.txt"); int b; b = in.read(); while(b!= -1) { System.out.print((char)b); b = in.read(); in.close(); catch(filenotfoundexception e){ System.out.println("File is missing!"); catch(ioexception e){ e.printstacktrace(); System.out.println("It's ok!");

131 Ex 8-1 编译 运行前述应用程序, 体会 java 语言异常的捕捉和处理机制 声明抛弃异常 声明抛弃异常是 Java 中处理违例的第二种方式 如果一个方法中的代码在运行时可能生成某种异常, 但在本方法中不必 或者不能确定如何处理此类异常时, 则可以声明抛弃该异常 ; 此时方法中将不对此类异常进行处理, 而是由该方法的调用者负责处理 [< 修饰符 >] < 返回值类型 > < 方法名 >(< 参数列表 >) [throws < 异常类型 > [,< 异常类型 >]*]{ [<Java 语句 >]*

132 声明抛弃异常举例 import java.io.*; public class TestThrowsException{ public static void main(string[] args){ TestThrowsException t = new TestThrowsException(); try{ t.readfile(); catch(ioexception e){ System.out.println(e); public void readfile() throws IOException { FileInputStream in=new FileInputStream("myfile.txt"); int b; b = in.read(); while(b!= -1) { System.out.print((char)b); b = in.read(); in.close(); 重写方法声明抛弃异常 重写方法不允许抛出比被重写方法范围更大的异常类型 : public class A { public void ma() throws IOException { public class B1 extends A { public void ma() throws FileNotFoundException, EOFException{ public class B2 extends A { public void ma() throws Exception { // 非法

133 人工抛出异常 Java 异常类对象除了在程序运行出错时由系统自动生成并抛出之外, 也可根据需要人工创建并抛出 : IOException e =new IOException(); throw e; 被抛出的必须是 Throwable 或其子类类型的对象, 下述语句在编译时会产生语法错误 : throw new String("want to throw"); 用户自定义异常 (1) Java 语言针对常见异常状况已事先定义了相应的异常类型, 并在程序运行出错时由系统自动创建相应异常对象并进行抛出 捕获和处理, 因此一般不需要用户人工抛出异常对象或定义新的异常类型 针对特殊的需要也可以这样做 : public class MyException extends Exception { private int idnumber; public MyException(String message, int id) { super(message); this.idnumber = id; public int getid() { return idnumber;

134 用户自定义异常 (2) public class TestCustomizingException{ public void regist(int num) throws MyException { if (num < 0) { throw new MyException(" 人数为负值, 不合理 ",3); System.out.println(" 登记人数 :" + num ); public void manager() { try { regist(-100); catch (MyException e) { System.out.println(" 登记失败, 出错种类 "+e.getid()); System.out.print(" 本次登记操作结束 "); public static void main(string args[]){ new TestCustomizingException().manager(); 输出结果 : 登记失败, 出错种类 3 本次登记操作结束 断言 (Assert) 从 JDK1.4 版本开始,Java 语言中引入了断言 (Assert) 机制 允许 Java 开发者在代码中加入一些检查语句, 主要用于程序调试目的 : 断言机制在用户定义的 boolean 表达式 ( 判定条件 ) 结果为 false 时抛出一个 Error 对象, 其类型为 AssertionError; 当我们需要在约定的条件不成立时中断当前操作的话, 可以使用断言 ; 作为 Error 的一种, 断言失败也不需捕获处理或者声明抛出, 一旦出现了则终止程序 不必进行补救和恢复

135 启用和禁用断言 开启断言功能 : Java 运行时环境默认设置为关闭断言功能, 因此在使用断言以前, 需要在运行 Java 程序时先开启断言功能 java -ea MyAppClass // 或者 : java -enableassertions MyAppClass 关闭断言功能 : java -da MyAppClass // 或者 : java -disableassertions MyAppClass 断言用法 (1) assert <boolean 表达式 >; public class TestAssertion{ public static void main(string[] args){ new TestAssertion().process(-12); public void process(int age){ assert age>=0; System.out.println(" 您的年龄 :" + age); //--- 启用断言时输出结果 :( 使用命令 "java -ea TestAssertion" 运行程序 ) Exception in thread "main" java.lang.assertionerror at TestAssertion.process(TestAssertion.java:7) at TestAssertion.main(TestAssertion.java:3) 关闭断言时输出结果 :( 使用命令 "java TestAssertion" 运行程序 ) 您的年龄 :

136 断言用法 (2) assert <boolean 表达式 >:< 表达式 2>; public class TestAssertion2{ public static void main(string[] args){ new TestAssertion2().process(-12); public void process(int age){ assert age>=0:" 年龄超出合理范围!"; System.out.println(" 您的年龄 :" + age); //--- 启用断言时输出结果 : Exception in thread "main" java.lang.assertionerror: 年龄超出合理范围! at TestAssertion2.process(TestAssertion2.java:7) at TestAssertion2.main(TestAssertion2.java:3) 关闭断言时输出结果 : 您的年龄 : 第九章 精通常用的 Java 类 136

137 本章学习目标 1 java.lang.object 类 2 字符串相关类型 3 封装类 4 日期 / 时间相关类型 5 数学相关类型 Object 类 java.lang.object 类是所有 Java 类的最高层次父类, 该类提供了面向对象编程技术的基本机制 重要方法列表 : hashcode() 方法 tostring() 方法 equals() 方法 finalize() 方法 clone() 方法 wait() 方法 notify()/notifyall() 方法

138 hashcode() 方法 public class Person{ private int age; public Person(int age){ this.age = age; // public class TestHashCode{ public static void main(string[] args){ Person p1 = new Person(18); Person p2 = new Person(18); int handle1 = p1.hashcode(); System.out.println(handle1); System.out.println(Integer.toHexString(handle1)); System.out.println(p1); System.out.println(" "); System.out.println(p2.hashCode()); 输出结果 : a90653 Person@a tostring() 方法 方法格式 : public String tostring() { 方法功能 : 以字符串形式返回当前对象的有关信息, 在 Object 类的原始定义中, 所返回的是对象所属的类型名称及其哈希码 当使用 System.out.println() 方法直接打印输出引用类型变量时,println() 方法中会先自动调用其 tostring() 方法, 再将所返回的字符串信息输出 在进行 String 与其它类型数据的连接操作时, 自动调用 tostring() 方法, 基本类型数据转换为 String 类型时, 调用了对应封装类的 tostring() 方法 可以根据需要在用户定义类型中重写 tostring() 方法

139 重写 tostring() 方法 public class Person{ private int age; public Person(int age){ this.age = age; public void setage(int age){ this.age = age; public int getage(){ return age; public String tostring(){ return "This is an instance of Person,age = " + age; public class TestOverride{ public static void main(string[] args){ Person p1 = new Person(18); System.out.println(p1.hashCode()); System.out.println(p1); // 等价于 System.out.println(p1.toString()); 输出结果 : This is an instance of Person,age = 18 This is an instance of Person,age = equals() 方法 方法格式 : public boolean equals(object obj) { 功能 : 比较引用类型数据的等价性 等价标准 : 引用类型比较引用, 基本类型比较值 equals() 方法与 == 操作符的区别 : equals() 方法只能比较引用类型数据, 而 "==" 可以比较引用类型及基本类型数据 ; equals() 方法存在特例 : 对 File( 第 节 ) String Date( 第 节 ) 及封装类 ( 第 9.3 节 ) 等类型来说, 是比较类型及对象的内容而不考虑引用的是否为同一实例 可以根据需要, 在用户定义类中重写其 equals() 方法以改变其等价性评价标准 139

140 使用 equals() 方法 对比使用 "==" 和 equals() 方法 例 9-3: Person.java TestEquals.java 例 9-4: TestEquals2.java 重写 equals() 方法, 实现用户定制等价性标准 例 9-5 Person.java TestEquals3.java finalize() 方法 方法格式 : 方法功能 :Java 运行时环境中的垃圾收集器在销毁一个对象之前, 会自动调用该对象的 finalize() 方法, 然后才释放对象的内存空间 方法用途 : 是在子类中重写, 以加入所需的逻辑代码来配置系统资源或执行其他清除操作 使用举例 : 例 9-6 finalize() 方法效果演示 Person.java protected void finalize() throws Throwable { TestFinalize.java

141 clone() 方法 方法格式 : protected native Object clone() throws CloneNotSupportedException; 方法功能 : 对象拷贝 要进行 克隆 的对象所属的类必须实现 java.lang. Cloneable 接口 使用举例 : 例 9-7 实现简单的克隆操作 Person.java TestClone.java 浅度拷贝和深度拷贝 字符串相关类型 1. String 类 2. StringBuffer 类 3. StringBuilder 类 4. StringTokenizer 类

142 String 类 java.lang.string 类对象表示不可修改的 Unicode 编码字符串 方法说明 : 构造方法 字符串连接 转换和截断 concat() replace() substring() tolowercase() touppercase() trim() 检索和查找功能 charat() startswith() indexof() lastindexof() length() 内容比较 equals() equalsignorecase() compareto() StringBuffer 类 StringBuffer 类对象保存可修改的 Unicode 字符序列 构造方法 : StringBuffer() StringBuffer(int capacity) StringBuffer(String initialstring) 主要功能方法 : append() insert() reverse() setcharat() 用法举例 例 9-11 TestStringBuffer.java

143 StringBuilder 类 JDK5.0 以后引入, 该类能够提供与 StringBuffer 相同的功能, 二者区别 : StringBuffer 类是线程安全的, 而 StringBuilder 则不是, 即不保证其对象的同步性, 在多线程环境中是不安全的 StringBuilder 在性能上要比 StirngBuffer 好一些 练习 将例 9-11 代码中的 StringBuffer 类直接换成 StringBuilder, 自行测试其用法 StringTokenizer 类 java.util.stringtokenizer 类的功能是将当前 字符串按照默认或指定的分隔符分解为多 个片段 构造方法 : public StringTokenizer(String str) public StringTokenizer(String str, String delim) public StringTokenizer(String str, String delim, boolean returndelims) 主要功能方法 : public boolean hasmoretokens() public String nexttoken() 用法举例 : 例 9-12 TestStringTokenizer.java

144 分解字符串的新方法 从 JDK1.4 开始,Sun 公司推荐开发者使用一种新的字符串分解方式 String 类的 split() public class 方法 TestStringSplit{ : public static void main(string args[]){ String s = " 阳光 : 沙滩 : 海浪 : 仙人掌 "; String[] results = s.split(":"); for(string each: results) { System.out.println(each); 输出结果 : 阳光沙滩海浪仙人掌 封装类 针对八种基本定义相应的引用类型 封装类 基本数据类型 封装类 boolean Boolean byte Byte short Short int Integer long Long char Character float Float double Double

145 使用封装类 public class TestWrapper{ public static void main(string args[]){ Integer t1 = new Integer(314); Integer t2 = new Integer("314"); int i = t1.intvalue(); System.out.println(i); System.out.println(t1 == t2); System.out.println(t1.equals(t2)); System.out.println(t1.toString()); System.out.println(Integer.toBinaryString(27)); System.out.println(Integer.toOctalString(27)); System.out.println(Integer.toHexString(27)); i = Integer.parseInt("500"); System.out.println(i); 输出结果 : 314 false true b 自动封装 / 拆封 public class TestAutoBoxing{ public static void main(string args[]){ Integer t1 = new Integer(3); int i = t1; int j = 4; Integer t2 = j; System.out.println(i); System.out.println(t2.toString()); m1(20); public static void m1(integer it){ int k = it + 5; // 等价于 k = it.intvalue() + 5; System.out.println(k); 输出结果 :

146 日期相关类型 1. Date 类 2. Calendar 类 3. Locale 类 4. TimeZone 类 5. GregorianCalendar 类 6. DateFormat 类 7. SimpleDateFormat 类 Date 类 java.util.date 类用于表示特定的时间点, 精确到毫秒, 但不支持日期的国际化和分时区显示 构造方法 : public Date() public Date(long date) 主要功能方法 : public int compareto(date anotherdate) public boolean equals(object obj) public long gettime() public String tostring() 用法举例 : 例 9 16 TestDate java

147 Calendar 类 抽象类 java.util.calendar 类提供了常规的日期修改功能和国际化支持 主要方法 : public static Calendar getinstance() public int get(int field) public void set(int field, int value) public final void set(int year, int month, int date) public final void set(int year,int month,int date,int hourofday,int minute, int second) public abstract void add(int field, int amount) 用法举例 例 9-17 TestCalendar.java Locale 类 java.util.locale 类描述特定的地理 政治 / 文化上的地区, Locale 对象主要封装了 地区 和 语言种类 两方面的信息 通常用于在国际化 / 本地化程序中以地区 / 语言相关的方式显示日期 数字或文本信息等 主要方法 : public Locale(String language) public Locale(String language, String country) public static Locale getdefault() public String getcountry() public String getlanguage() public final String getdisplayname() public static Locale[] getavailablelocales() 用法举例 :

148 TimeZone 类 java.util.timezone 类描述时区信息 TimeZone 被定义为抽象类, 可以调用其静态方法 getdefault() 以获得该类的实例 public static TimeZone getdefault() public static TimeZone gettimezone(string ID) 其它方法 : public static String[] getavailableids() 用法举例 : 例 9-19 TestTimeZone.java GregorianCalendar 类 java.util.gregoriancalendar 是 Calendar 的子类, 该类提供了世界上大多数国家 / 地区使用的标准日历系统, 并添加判断闰年的功能 主要方法 : public GregorianCalendar() public GregorianCalendar(TimeZone zone) public GregorianCalendar(Locale alocale) public GregorianCalendar(TimeZone zone, Locale alocale) public GregorianCalendar(int year, int month, int dayofmonth) public GregorianCalendar(int year, int month, int dayofmonth, int hourofday, int minute, int second) public boolean isleapyear(int year) 用法举例 : 例 9-20 TestGregorianCalendar.java

149 DateFormat 类 java.text.dateformat 类提供了将日期 / 时间信息进行格式化处理的功能, 其格式化风格如下 : 风格 短格式 中等格式 长格式 完全格式 描述 较短 较长 更长 最详尽 日期样例 ( 英文环境 ) 4/17/07 Apr 17, 2007 April 17, 2007 Tuesday, April 17, 2007 主要方法 : public static final DateFormat getdateinstance() public static final DateFormat gettimeinstance() public static final DateFormat getdatetimeinstance() public final String format(date date) 用法举例 : 例 9-21 TestDateFormat.java 时间样例 ( 英文环境 ) 8:50 AM 8:50:33 AM 8 : 5 0 : 3 3 AM GMT+08:00 8 : 5 0 : 3 3 AM GMT+08: SimpleDateFormat 类 java.text.simpledateformat 类是 DateFormat 类的子类, 它允许用户自己定义日期 / 时间信息的表现格式, 并提供更灵活的 Date<=>String 信息转换和解析的功能 在创建 SimpleDateFormat 实例时应指定所转换的字符串格式 ( 模式串 ), 否则系统会缺省采用与所在语言环境相关的默认格式 用法举例 : 例 9-22 TestSimpleDateFormat.java

150 日期格式化模式字符表 模式字符 a D d E F G H h K k M m S s W w y Z z 说明上午 / 下午 (AM/PM) 标志一年中的第几天一月中的第几天星期中的第几天一月中的第几个星期几年代标志小时 (0~23) 小时 (0~11), 使用 AM/PM 区分上下午小时 (1~24) 小时 (1~12), 使用 AM/PM 区分上下午月份分钟毫秒秒一个月中的第几星期一年中的第几星期年太平洋标准时间 (PST) 时区 RFC822 时区 数学相关类型 1. Math 类 2. Random 类 3. BigInteger/BigDecimal 类 4. NumberFormat/DecimalFormat 类

151 Math 类 java.lang.math 类提供常用数学功能和数学常量 : 数据截断操作 : ceil(), floor(), round() 取最大 最小及绝对值操作 : max(), min(), abs() 三角函数 : sin(), cos(), tan(), asin(), acos(), atan(), todegrees(), toradians() 幂运算和对数运算 : pow(), exp(), sqrt(), log(), log10() 其他操作 : random() Random 类 java.util.random 类是基于 线性同余 算法的一种伪随机数序列生成器 其主要功能方法包括 : public Random() public Random(long seed) public int nextint() public int nextint(int n) public import java.util.random; double nextdouble() public public boolean class TestRandom{ nextboolean() public static void main(string args[]){ Random rand = new Random(); System.out.println(rand.nextInt()); System.out.println(rand.nextInt(10)); System.out.println(rand.nextBoolean()); System.out.println(rand.nextDouble()); System.out.println(rand.nextFloat()); 输出效果 : false

152 BigInteger/BigDecimal java.math 包中定义的 BigInteger 和 BigDecimal 类型可以分别提供任意长度 / 精度的整数和浮点数运算功能 BigInteger 类主要方法 : public BigInteger(String val) public static BigInteger valueof(long val) public BigInteger add(biginteger val) public BigInteger subtract(biginteger val) public BigInteger multiply(biginteger val) public BigInteger divide(biginteger val) public int compareto(biginteger val) public BigInteger remainder(biginteger val) public BigInteger pow(int exponent) public String tostring() 用法举例 NumberFormat/DecimalFormat java.text.numberformat/decimalformat 提供了将数字格式化为语言环境相关字符串以及逆向解析字符串为数字的功能 主要方法 : public static final NumberFormat getinstance() public static NumberFormat getinstance(locale inlocale) public final String format(double number) public static final NumberFormat getcurrencyinstance() public static NumberFormat getcurrencyinstance(locale inlocale) public static final NumberFormat getpercentinstance() public static NumberFormat getpercentinstance(locale inlocale) 用法举例 : 例 9-27 TestNumberFormat.java

153 第十章 控制台应用程序设计 本章学习目标 1 命令行参数 2 系统属性 3 标准 I/O 文件 I/O 4 可变参数 5 过时 API 6 注解 (Annotation) 7 Java 归档工具

154 命令行参数 在启动时 Java 控制台应用程序, 可以一次性地向程序中传递零至多个字符串参数, 这些参数被称为命令行参数 语法格式 : java < 应用程序类名 > [< 命令行参数 >]* 命令行参数将被系统接收并静态初始化为一个一维的 String 数组对象, 然后将之作为实参传给应用程序入口方法 main() 命令行参数须使用空格符及双引号分隔 使用命令行参数 // 例 10-1 使用命令行参数 public class TestCommandLineArgs{ public static void main(string[] args){ for(int i=0;i<args.length;i++){ System.out.println(args[i]); 使用下述命令运行程序 : java TestCommandLineArgs Lisa "Billy" "Mr Brown" "a""b" 输出结果 : Lisa Billy Mr Brown a"b

155 系统属性 Java 系统属性以 键 - 值 对的形式存在 由属性名称 属性值两部分组成, 均为字符串形式, 记录了当前操作系统和 JVM 等相关的环境信息 可使用 System.getProperties() 方法获得 Properties 类的对象, 其中包含了所有可用的系统属性信息 可使用 System 或 Properties 类的 getproperty(string) 方法获得特定系统属性的属性值 可使用 System 或 Properties 类的 setproperty(string, String) 方法添加新的系 遍历系统属性 // 例 10-2 遍历系统属性 import java.util.properties; import java.util.enumeration; public class TestSystemProperties { public static void main(string[] args) { Properties ps = System.getProperties(); ps.setproperty("myname","myvalue"); Enumeration pn = ps.propertynames(); while ( pn.hasmoreelements() ) { String pname = (String) pn.nextelement(); String pvalue = ps.getproperty(pname); System.out.println(pName + "----" + pvalue); 也可使用下述命令在运行程序时添加新的系统属性 : D:\ex>java -Dmmmm=vvvv TestSystemProperties

156 标准输入 / 输出 控制台输入 / 输出是应用程序的基本功能 : System.out 提供向 标准输出 写出数据的功能 (java.io.printstream 类型 ) System.in 提供从 标准输入 读入数据的功能 (java.io.inputstream 类型 ) System.err 提供向 标准错误输出 写出数据的功能 (java.io.printstream 类型 ) PrintStream 类的主要方法 : print()/println() 方法被进行了多次重载 (boolean, char, int, long, float, double 以及 char[], Object 和 String) 例 10-3 读取控制台输入的传统方法 import java.io.inputstreamreader; import java.io.bufferedreader; import java.io.ioexception; public class TestStandardInput{ public static void main (String args[]) { String s; InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); try { s = br.readline(); while (!s.equals("")) { System.out.println("Read: " + s); s = br.readline(); br.close(); catch (IOException e) { e.printstacktrace();

157 文件输入输出 java.io 包中定义与数据输入 输出功能有关的类, 包括提供文件操作功能的 File 类 创建 File 类对象 File f; f = new File("Test.java"); f = new File("E:\\ex\\","Test.java"); 在 Java 中, 将目录也当作文件处理 File 类中提供了实现目录管理功能的方法 File path = new File("E:\\ex\\"); File f = new File(path, "Test.java"); File 类主要方法 关于文件 / 目录名操作 String getname() String getpath() String getabsolutepath() String getparent() 测试操作 boolean exists() boolean canwrite() boolean canread() boolean isfile() boolean isdirectory() boolean isabsolute(); 获取常规文件信息操作 long lastmodified() long length() 设置和修改操作 boolean delete() void deleteonexit() boolean createnewfile() setreadonly() boolean renameto(file dest) 目录操作 boolean mkdir() String[] list() File[] listfiles() File 常规方法用法举例 例 10-4 TestFile.java

158 文件 I/O 有关类型 java.io.filereader 类提供 read() 方法以字符为单位从文件中读入数据 java.io.filewrite 类提供 write() 方法以字符为单位向文件写出数据 java.io.bufferedreader 类提供 readline() 方法以行为单位读入一行字符 java.io.printwriter 类 提供 print() 和 println() 方法以行为单位写出 例 10-5 import java.io.*; 读取文件信息 public class ReadFile{ public static void main (String[] args) { String fname = "test.txt"; File f = new File(fname); try { FileReader fr = new FileReader(f); BufferedReader br = new BufferedReader(fr); String s = br.readline(); while ( s!= null ) { System.out.println(" 读入 : " + s); s = br.readline(); br.close(); catch (FileNotFoundException e1) { System.err.println("File not found: " + fname); catch (IOException e2) { e2.printstacktrace();

159 例 10-7 import java.io.*; 输出信息到文件 public class TestWriteFile{ public static void main (String[] args) { File file = new File("tt.txt"); try { InputStreamReader is = new InputStreamReader(System.in); BufferedReader in=new BufferedReader(is); FileWriter fw = new FileWriter(file); PrintWriter out = new PrintWriter(fw); String s = in.readline(); while (!s.equals("")) { // 从键盘逐行读入数据输出到文件 out.println(s); s = in.readline(); in.close(); // 关闭 BufferedReader 输入流. out.close(); // 关闭连接文件的 PrintWriter 输出流. catch (IOException e) { e.printstacktrace(); 可变参数方法 例 10-9 Java 语言允许在定义方法时指定使用任意数量的参数, 其格式是在参数类型后加 "..." 可变长度参数必须放在参数列表的最后, 而且 一个方法最多只能包含一个可变长度参数 import java.util.date; public class TestVarargs{ public static void main(string[] args){ TestVarargs tv = new TestVarargs(); tv.myprint("china",5000,new Integer(54),new Date(),5,7.89); public void myprint(string s,int i,object... objs){ System.out.println(s.toUpperCase()); System.out.println(100 * i); for(object o: objs){ System.out.println(o);

160 过时 API 过时 API 是指那些过去定义的, 现已不提倡使用的 API, 包括类 属性和方法等 过时 API 均存在相应的替代物, 这些替代者可能采用了更标准化的命名惯例 或功能更适用 在移植 Java 代码时, 可使用 - Xlint:deprecation 选项进行编译以获得相关详细信息 使用过时 API (1) 例 import java.util.*; public class TestDeprecation{ public static void main(string[] args){ Date now = new Date(); int hour = now.gethours(); System.out.println(hour); 编译程序时输出提示信息 : 注意 :D:\ex\TestDeprecation.java 使用或覆盖了已过时的 API 注意 : 要了解详细信息, 请使用 -Xlint:deprecation 重新编译 使用下述命令重新编译程序 : javac -Xlint:deprecation TestDeprecation.java 输出更详细说明信息 : TestDeprecation.java:5: 警告 :[deprecation] java.util.date 中的 gethours() 已过时 int hour = now.gethours(); ^ 1 警告

161 使用过时 API (2) 查阅相关的 API 文档找到相应的替换成分 : import java.util.*; public class TestDeprecation{ public static void main(string[] args){ Calendar c = Calendar.getInstance(); int hour = c.get(calendar.hour_of_day); System.out.println(hour); 用户自定义过时 API 例 在过时的成分前添加第三种形式的注释, 并在其中使用 "@deprecated" 标记标明此成分已过时, 同时还可以给出简要的说明信息 public class A{ 本方法不推荐使用, 这里只是用于测试用途 */ public void ma(){ System.out.println("In class A,just for test!"); public class TestMyDeprecation{ public static void main(string[] args){ A a = new A(); a.ma();

162 注解 注解不直接影响程序的语义, 然而开发和部署工具可以对其读取并以某种形式处理 本质上, 注解就是可以添加到代码中的一种类似于修饰符的成分, 可以用于声明包 类 构造方法 方法 属性 参数和变量等场合 Java 语言采用了一类新的数据类型来描述注解 注解类型相当于类或接口, 每一条注解相当于该类的一个实例 注解类型采用 标记来声明 JDK 中提供的几种有用注解类型 : Deprecated Override SuppressWarnings Override 注解 java.lang.override 类型注解用于指明被注解的方法重写了父类中的方法, 如果不是合法的方法重 例 10-12写则编译报错 //import java.lang.override; public class Person{ private String name; public Person(String name){ this.name = name; public void setname(string name){ this.name = name; public String getname(){ return public String tostring(){ return "Name: " + name;

163 Deprecated 注解 例 Deprecated 注解的作用也是标记过时的 API ( 与前述使用第三种注释形式来标记的效果相同 public ) class public void ma(){ System.out.println("In class A,just for test!"); public class TestMyDeprecation{ public static void main(string[] args){ A a = new A(); a.ma(); SuppressWarnings 注解 例 使用 SuppressWarnings 注解可以关闭编译器对指定的一种或多种问题的提示 / 警告功能 import java.util.*; //import public class TestSuppressWarnings{ public static void main(string[] args){ Date now = new Date(); int hour = now.gethours(); System.out.println(hour);

164 归档工具 Java 归档工具是 JDK 中提供的一种多用途的存档及压缩工具, 可以将多个文件或目录合并 / 压缩为单个的 Java 归档文件 (jar, java archive) jar 文件的主要作用 : 发布和使用类库 作为程序组件或者插件程序的基本部署单位 用于打包与组件相关联的资源文件 使用 jar 工具基本语法格式 : jar {ctxui[vfm0me] [jar-file] [manifest-file] [entry-point] [-C dir] files... 演示 : 制作并使用自己的 jar 文件 例 Ajava TestJar java 第十一章 集合与映射 164

165 本章学习目标 1 列表 (List) 2 集 (Set) 3 映射 (Map) 4 其它相关 API 集合框架概述 集合就是将若干用途 性质相同或相近的 数据 组合而成一个整体 从体系上讲, 集合类型可以归纳为三种 : 集 (Set) Set 集合中不区分元素的顺序, 不允许出现重复元素 列表 (List) List 集合区分元素的顺序, 且允许包含重复元素 映射 (Map) 映射中保存成对的 键 - 值 (Key-Value) 信息, 映射中不能包含重复的键, 每个键最多只能映射一个值 Java 集合中只能保存引用类型的数据, 实际上 存放的是对象的引用而非对象本身集合中 165

166 Collection 接口 java.util.collection 接口是描述 Set 和 List 集合类型的根接口, 其中定义了有关集合操作的普遍性方法 : boolean add(object o) boolean remove(object o) int size() boolean isempty() boolean contains(object o) void clear() Iterator iterator() Object[] toarray() Set 和 List 接口 java.util.set 和 java.util.list 分别描述前述的集和列表结构, 二者均为 Collection 的子接口 List 接口规定使用者可以对列表元素的插入位置进行精确控制, 并添加了根据元素索引来访问元素等功能, 接口中新添加了相应方法 : void add(int index,object element) Object get(int index) Object set(int index, Object element) int indexof(object o) Object remove(int index)

167 Map 接口 java.util.map 接口描述了映射结构,Map 结构允许以键集 值集合或键 - 值映射关系集的形式查看某个映射的内容 主要方法 : Object put(object key, Object value) Object get(object key) boolean isempty() void clear() int size() boolean containskey(object key) boolean containsvalue(object value) Set keyset() Collection values() 集合相关 API 关系结构 HashSet Collection Set List TreeSet ArrayList Vector Stack HashMap Map Hashtable Properties Enumeration TreeMap StringTokenizer java.util.arrays java.util.collections

168 ArrayList java.util.arraylist 类实现了 List 接口, 用于表述长度可变的数组列表 ArrayList 列表允许元素取值为 null 除实现了 List 接口定义的所有功能外, 还提供了一些方法来操作列表容量的大小, 相关方法包括 : public ArrayList() public ArrayList(int initialcapacity) public void ensurecapacity(int mincapacity) public void trimtosize() 用法举例 : 例 11-1 TestArrayList.java Vector java.util.vector 也实现了 List 接口, 其描述的也是可变长度的对象数组 与 ArrayList 的差别 :Vector 是同步 ( 线程安全 ) 的, 运行效率要低一些, 主要用在在多线程环境中, 而 ArrayList 是不同步的, 适合在单线程环境中使用 常用方法 ( 除实现 List 接口中定义的方法外 ): public Vector() public Object elementat(int index) public void addelement(object obj) public void removeelementat(int index) public void insertelementat(e obj, int index) public boolean removeelement(object obj) public void removeallelements() public Object[] toarray() 用法举例 168

169 Stack java.util.stack 类继承了 Vector 类, 对应数据结构中以 后进先出 (Last in First out, LIFO) 方式存储和操作数据的对象栈 Stack 类提供了常规的栈操作方法 : public Stack() public Object push(e item) public Object pop() public Object peek() public boolean empty() public void clear() public int search(object o) 用法举例 例 11-3 TestStack.java Iterator 接口 java.util.iterator 接口描述的是以统一方式对各种集合元素进行遍历 / 迭代的工具, 也称 迭代器 允许在 遍历 过程中移除集合中的 ( 当前遍历到的那个 ) 元素 主要方法 : boolean hasnext() Object next() void remove() 用法举例 : 例 11-4 TestIterator.java 例 11-5 Person java TestIterator2 java

170 HashSet java.util.hashset 类实现了 java.util.set 接口, 描述典型的 Set 集合结构 HashSet 中不允许出现重复元素, 不保证集合中元素的顺序 HashSet 中允许包含值为 null 的元素, 但最多只能有一个 null 元素 用法举例 : 例 11-6 TestHashSet.java TreeSet java.util.treeset 类也实现了 java.util.set, 它描述的是 Set 的一种变体 可以实现排序功能的集合 在将对象元素添加到 TreeSet 集中时会自动按照某种比较规则将其插入到有序的对象序列中, 以保证 TreeSet 集合元素组成的对象序列时刻按照 升序 排列 用法举例 : 例 11-7 TestTreeSet.java

171 Comparable 接口 java.lang.comparable 接口中定义的 compareto() 方法用于提供对其实现类的对象进行整体排序所需的比较逻辑 实现类基于 compareto() 方法的排序被称为自然排序 而 compareto() 方法被称为它的自然比较方法, 具体的排序原则可由实现类根据需要而定 用户在重写 compareto() 方法以定制比较逻辑时, 需要确保其与等价性判断方法 equals() 保持一致 用法举例 : 例 Person java HashMap java.util.hashmap 类实现了 java.util.map 接口, 该类基于哈希表实现了前述的映射集合结构 HashMap 结构不保证其中元素 ( 映射信息 ) 的先后顺序, 并且允许使用 null 值 和 null 键 当集合中不存在当前检索的 键 所对应的映射值时,HashMap 的 get() 方法会返回空值 null, 而不会运行出错 影响 HashMap 性能的两个参数 : 初始容量 (Initial Capacity) 加载因子 (Load Factor) 用法举例 :

172 Hashtable java.util.hashtable 与 HashMap 作用基本相同, 也实现了 Map 接口, 采用哈希表的方式将 键 映射到相应的 值 Hashtable 与 HashMap 的差别 : Hashtable 中元素的 键 和 值 均不允许为 null, 而 HashMap 则允许 Hashtable 是同步的, 即线程安全的, 效率相对要低一些, 适合在多线程环境下使用 ; 而 HashMap 是不同步的, 效率相对高一些, 提倡在单线程环境中使用 Hashtable 与 HashMap 的用法格式完全相同 TreeMap java.util.treemap 类实现了将 Map 映射中的元素按照 键 进行升序排列的功能, 其排序规则可以是默认的按照 键 的自然顺序排列, 也可以使用指定的其他排序规则 向 TreeMap 映射中添加的元素 键 所属的类必须实现 Comparable 接口 用法举例 : 例 MyKey.java Person.java TestTreeMap.java

173 Enumeration 接口 java.util.enumeration 接口作用与 Iterator 接口类似, 但只提供了遍历 Vector 和 Hashtable ( 及子类 Properties) 类型集合元素的功能, 且不支持集合元素的移除操作 import java.util.*; public class TestEnumeration{ public static void main(string[] args) { Vector v = new Vector(); v.addelement("lisa"); v.addelement("billy"); v.addelement("mr Brown"); Enumeration e = v.elements(); while(e.hasmoreelements()){ String value = (String)e.nextElement(); System.out.println(value); 输出结果 : Lisa Billy Mr Brown Collections 类 java.util.collections 类中定义了多种集合操作方法, 实现了对集合元素的排序 取极值 批量拷贝 集合结构转换 循环移位以及匹配性检查等功能 主要方法 : public static void sort(list list) public static void reverse(list list) public static void shuffle(list list) public static void copy(list dest, List src) public static ArrayList list(enumeration e) public static int frequency(collection c, Object o) public static T max(collection coll) public static T min(collection coll) public static void rotate(list list, int distance) 用法举例 : 例

174 Arrays 类 java.util.arrays 类定义了多种数组操作方法, 实现了对数组元素的排序 填充 转换为列表或字符串形式 增强的检索和深度比较等功能 主要方法 : public static List aslist(object... a) public static void sort(< 类型 >[ ] a) public static int binarysearch(int[] a, int key) public static String tostring(int[] a) 用法举例 : 例 TestArrays.java 第十二章 GUI 程序设计 174

175 本章学习目标 1 图形用户界面 (GUI) 设计 2 GUI 事件处理 3 GUI 常用组件和视觉控制 4 AWT 绘图 5 Applet 基本概念 / 术语 图形用户界面 GUI -- Graphical User Interface 抽象窗口工具集 AWT -- Abstract Window Toolkit 相关软件包 : java.awt 包 提供基本 GUI 组件 视觉控制和绘图工具 API java.awt.event 包提供 Java GUI 事件处理 API

176 组件 组件 (Component) 是图形用户界面的基本组成元素, 凡是能够以图形化方式显示在屏幕上并能够与用户进行交互的对象均为组件, 如菜单 按钮 标签 文本框 滚动条等 组件不能独立地显示出来, 必须将组件放在一定的容器中才可以显示出来 JDK 的 java.awt 包中定义了多种 GUI 组件类, 如 Menu Button Label TextField 等 抽象类 java.awt.component 是除菜单相关组件之外所有 Java AWT 组件类的根父类, 该类规定了 GUI 组件的基本特性, 如尺寸 位置和颜 色效果等, 并实现了作为一个 GUI 部件所应具 备的基本功能 容器 容器 (Container) 实际上是 Component 的子类, 因此容器类对象本身也是一个组件, 具有组件的所有性质, 另外还具有容纳其它组件和容器的功能 容器类对象可使用方法 add() 添加组件 两种主要的容器类型 : java.awt.window 可自由停泊的顶级窗口 java.awt.panel 可作为容器容纳其他组件, 但不能独立存在, 必须被添加到其他容器 ( 如 Frame) 中

177 常见组件和容器 组件类型 父类 说 明 Button Component 可接收点击操作的矩形 GUI 组件 Canvas Component 用于绘图的面板 Checkbox Component 复选框组件 CheckboxMenuItem MenuItem 复选框菜单项组件 Choice Component 下拉式列表框, 内容不可改变 Component Object 抽象的组件类 Container Component 抽象的容器类 Dialog Window 对话框组件, 顶级窗口 带标题栏 FileDialog Dialog 用于选择文件的平台相关对话框 Frame Window 基本的 Java GUI 窗口组件 Label Component 标签类 List Component 包含内容可变的条目的列表框组件 MenuBar MenuComponent 菜单条组件 Menu MenuItem 菜单组件 MenuItem MenuComponent 菜单项组件 Panel Container 基本容器类, 不能单独停泊 PopupMenu Menu 弹出式菜单组件 Scrollbar Component 滚动条组件 ScrollPane Container 带水平及垂直滚动条的容器组件 TextComponent Component TextField 和 TextArea 的基本功能 TextField TextComponent 单行文本框 TextArea TextComponent 多行文本域 Window Container 抽象的 GUI 窗口类, 无布局管理器 Frame 继承层次 : java.lang.object +----java.awt.component +----java.awt.container +----java.awt.window +----java.awt.frame Frame 对象的显示效果是一个可自由停泊的顶级 窗口, 带有标题和尺寸重置角标 Frame 默认初始化为不可见的, 可以调用 Frame 对象的 setvisible(true) 方法使之变为可见 作为容器 Frame 还可使用 add() 方法包含其他组 件 177

178 第一个 GUI 应用程序 // 例 12-1 TestFrame.java import java.awt.frame; public class TestFrame { public static void main( String args[]) { Frame f = new Frame("Hello GUI"); f.setsize( 200,100); f.setvisible( true); 组件定位 Java 组件在容器中的定位由布局管理器决定 如要人工控制组件在容器中的定位, 可取消布局管理器, 然后使用 Component 类的 下述成员方法 : setlocation() setsize() setbounds() GUI 坐标系 : 屏幕坐标系 (0,0) y (0,0)Frame 内部坐标系 50 y x 1 x

179 Panel 提供容纳组件的空间 Panel 不能独立存在, 必须被添加到其他容器中 可以采用和所在容器不同的布局管理器 Panel 类的继承层次 java.lang.object +----java.awt.component +----java.awt.container +----java.awt.panel FrameWithPanel 应用举例 // 例 12-2 TestFrameWithPanel.java import java.awt.frame; import java.awt.panel; import java.awt.color; public class TestFrameWithPanel{ public static void main(string args[]) { Frame f = new Frame("MyTest"); Panel pan = new Panel(); f.setsize(200,170); f.setbackground(color.cyan); f.setlayout(null); // 取消默认布局管理器 pan.setsize(80,80); pan.setbackground(color.green); f.add(pan); pan.setlocation(40,40); f.setlocation(300,300); f.setvisible(true);

180 Ex 12-1 练习 Frame 与 Panel 组件的使用, 对使用 AWT 组件创建图形用户界面机制建立初步认识 ; 布局管理器 (1) 容器对其中所包含组件的排列方式, 包括组件的位置和大小设定, 被称为容器的布局 (Layout) 为了使图形用户界面具有良好的平台无关性,Java 语言提供了布局管理器来管理容器的布局, 而不建议直接设置组件在容器 中的位置和尺寸 FlowLayout LayoutManager 布局管理器类层次 : GridLayout LayoutManager2 BorderLayout CardLayout GridBagLayout

181 布局管理器 (2) 每个容器都有一个布局管理器, 当容器需要对某个组件进行定位或判断其大小尺寸时, 就会调用其对应的布局管理器 Component Container Window Panel Frame Dialog Applet BorderLayout FlowLayout GUI 容器默认布局管理器 FlowLayout 布局 FlowLayout 是 Panel 容器的默认布局管理器类型 布局效果 : 组件在容器中按照加入次序逐行定位, 行内从左到右, 一行排满后换行 不改变组件尺寸, 即按照组件原始大小进行显示 组件间的对齐方式默认为居中对齐, 也可在构造方法中设置不同的组件间距 行距及对齐方式 构造方法 : public FlowLayout()

182 FlowLayout 举例 // 例 12-3 TestFlowLayout.java import java.awt.frame; import java.awt.button; import java.awt.flowlayout; public class TestFlowLayout { public static void main(string args[]) { Frame f = new Frame("Flow Layout"); Button button1 = new Button("Ok"); Button button2 = new Button("Open"); Button button3 = new Button("Close"); f.setlayout(new FlowLayout()); f.add(button1); f.add(button2); f.add(button3); f.setsize(100,100); f.setvisible(true); BorderLayout 布局 (1) BorderLayout 是 Frame 容器的默认布局管理器 布局效果 : BorderLayout 将整个容器的布局划分成东 西 南 北 中五个区域, 组件只能被添加到指定的区域 如不指定组件的加入部位, 则默认加入到 Center 区域 每个区域只能加入一个组件, 如加入多个, 则先前加入的组件会被遗弃 组件尺寸被强行控制, 即与其所在区域的尺寸相同

183 BorderLayout 布局 (2) BorderLayout 型布局容器尺寸缩放原则 : 北 南两个区域只能在水平方向缩放 ( 宽度可调整 ) 东 西两个区域只能在垂直方向缩放 ( 高度可调整 ) North 中部可在两个方向上缩放 West Center South Eest BorderLayout 举例 // 例 12-4 TestBorderLayout.java import java.awt.frame; import java.awt.button; public class TestBorderLayout { public static void main(string args[]) { Frame f = new Frame("Border Layout"); Button bn = new Button("BN"); Button bs = new Button("BS"); Button bw = new Button("BW"); Button be = new Button("BE"); Button bc = new Button("BC"); f.add(bn, "North"); f.add(bs, "South"); f.add(bw, "West"); f.add(be, "East"); f.add(bc, "Center"); f.setsize(200,200); f.setvisible(true);

184 GridLayout 布局 布局效果 : 将容器区域划分成规则的矩形网格, 每个单元格区域大小相等, 组件被添加到每个单元格中, 按组件加入顺序先从左到右填满一行后换行, 行间从上到下 GridLayout 型布局的组件大小也被布局管理器强行控制, 与单元格同等大小, 当容器尺寸发生改变时, 组件的相对位置保持不变, 但大小自动调整 构造方法 : public GridLayout(int rows, int cols) public GridLayout(int rows,int cols,int hgap,int vgap) 用法举例 CardLayout 布局 布局效果 : 将多个组件在同一容器区域内交替显示, 相当于多张卡片摞在一起, 只有最上面的卡片是可见的 CardLayout 可以按名称显示某一张卡片, 或按先后顺序依次显示, 也可以直接定位到第一张或最后一张卡片 主要方法 : public void first(container parent) public void last(container parent) public void previous(container parent) public void next(container parent) public void show(container parent, String name)

185 GridBagLayout 布局 GridBagLayout 是建立在 GridLayout 基础上的一种极为复杂而灵活的布局方式 容器的嵌套使用 利用容器嵌套可以在某个原本只能包含一个组件的区域中显示多个组件 效果示意 : 用法举例 : 例 12-7 NestedContainer.java

186 Ex 12-2 练习使用 FlowLayout 布局管理器, 要求在布局管理器的构造方法中尝试设置不同的对齐方式并显式指定组件的水平和竖直间距 ; 练习使用 BorderLayout 布局管理器, 试验不指明加入位置 f.add(bs); 以及向同一位置加入多个组件的实际效果 ; 练习使用 GridLayout 布局管理器, 尝试在声明为 2*3 个 GridLayout 网格的 Frame 中加入多于或少于 6 个组件时程序的运行表现 ; 使用 Java AWT 实现简易计算器图形用户界 面 GUI 事件处理 1 用户鼠标点击 ActionEvent 2 actionperformed(actionevent e){ 如果关注某个组件产生的事件, 则可以在该组件上注册适当的事件处理方法, 实际上注册的事件处理者方法所属类型的一个对象 -- 事件监听器

187 事件处理相关概念 事件 (Event) 一个事件类型的对象, 用于描述了发生什么事情, 当用户在组件上进行操作时会触发相应的事件 事件源 (Event Source) 能够产生事件的 GUI 组件对象, 如按钮 文本框等 事件处理方法 (Event Handler) 能够接收 解析和处理事件类对象, 实现与用户交互功能的方法 事件监听器 (Event Listener) 调用事件处理方法的对象 GUI 事件处理举例 // 例 12-8 TestActionEvent.java import java.awt.*; import java.awt.event.*; public class TestActionEvent { public static void main(string args[]) { Frame f = new Frame("Test"); Button b = new Button("Press Me!"); MyMonitor mm = new MyMonitor(); b.addactionlistener(mm); f.add(b,borderlayout.center); f.pack(); f.setvisible(true); class MyMonitor implements ActionListener { public void actionperformed(actionevent e) { System.out.println("A button has been pressed!");

188 事件处理模型综述 Java GUI 设计中, 通过注册监听器的方式对所关注的事件源进行监控 注册监听器时应指明该监听器监控 ( 感兴趣 ) 的事件种类 当事件源发生了某种类型的事件时, 只触发事先已就该种事件类型注册过的监听器 GUI 事件类型层次 java.awt.event java.lang.object java.util.eventobject java.awt.awtevent ActionEvent AdjustmentEvent ComponentEvent ItemEvent FocusEvent InputEvent ContainerEvent KeyEvent MouseEvent TextEvent WindowEvent Java GUI 主要事件类层次

189 事件及相应监听器接口 事件类型 Action Item Mouse MouseMotion Key Focus Adjustment Component Window Container Text 相应监听器接口监听器接口中的方法 ActionListener actionperformed(actionevent) ItemListener itemstatechanged(itemevent) mousepressed(mouseevent) mousereleased(mouseevent) MouseListener mouseentered(mouseevent) mouseexited(mouseevent) mouseclicked(mouseevent) MouseMotionListe mousedragged(mouseevent) ner mousemoved(mouseevent) keypressed(keyevent) KeyListener keyreleased(keyevent) keytyped(keyevent) FocusListener focusgained(focusevent) focuslost(focusevent) AdjustmentListener adjustmentvaluechanged(adjustmentev ent) componentmoved(componentevent) ComponentListene componenthidden (ComponentEvent) r componentresized(componentevent) componentshown(componentevent) windowclosing(windowevent) windowopened(windowevent) windowiconified(windowevent) WindowListener windowdeiconified(windowevent) windowclosed(windowevent) windowactivated(windowevent) windowdeactivated(windowevent) ContainerListener componentadded(containerevent) componentremoved(containerevent) TextListener textvaluechanged(textevent) actioncommand 属性 actioncommand 属性用于记录按钮 / 菜单类组件所激发的 ActionEvent 事件相关指令信息 用法举例 : 例 12-9 Monitor2.java TestActionEvent2.java

190 Ex 练习前述 Java GUI 事件处理例程, 并对实现了 ActionListener 接口的 Monitor 类进行个性化修改, 理解 Java 语言中的事件处理机制 ; 2. 完善先前计算器的图形用户界面, 并显示 3. 在 2 的基础上实现下述功能 : 按下计算器的某个键 ( 按钮 ) 时, 在系统标准输出上显示该按钮的标签 4. ( 选做 ) 按下计算器的某个键 ( 按钮 ) 时, 在计算器的显示器上显示该按钮的标 签 多重监听器 一般情况下, 事件源可以产生多种不同类型的事件, 因而可以注册 ( 触发 ) 多种不同类型的监听器 一个事件源组件上可以注册多个监听器, 针对同一个事件源的同一种事件也可以注册多个监听器, 一个监听器可以被注册到多个不同的事件源上 用法举例 : 例 TestMultiListener.java

191 Ex 12-4 扩充前述 TestMultiListener.java, 对 MouseListener 接口和 MouseMotionListener 接口中其余几个未真正实现的声明的方法进行细化, 使其实现一定的功能, 体会在同一个组件上注册多个事件监听器的机制 事件适配器类 事件适配器类 (Adapter) 是针对大多数事件监听器接口定义的相应的实现类, 适配器类实现了相应监听器接口中所有的方法, 但不做任何事 情 package java.awt.event; public abstract class MouseMotionAdapter implements MouseMotionListener { public void mousedragged(mouseevent e) { public void mousemoved(mouseevent e) { 主要适配器类 : 监听器接口 对应适配器类 说明 MouseListener MouseAdapter 鼠标事件适配器 MouseMotionListener MouseMotionAdapter 鼠标运动事件适配器 WindowListener WindowAdapter 窗口事件适配器 FocusListener FocusAdapter 焦点事件适配器 KeyListener KeyAdapter 键盘事件适配器 ComponentListener ComponentAdapter 组件事件适配器 ContainerListener ContainerAdapter 容器事件适配器

192 事件适配器类用法举例 例 MyAdapter.java TestAdapter.java 分析 : public class MyAdapter extends WindowAdapter{ public void windowclosing(windowevent e){ System.exit(1); public class MyAdapter implements WindowListener{ public void windowopened(windowevent e){ public void windowclosing(windowevent e){ System.exit(1); public void windowclosed(windowevent e){ public void windowiconified(windowevent e){ public void windowdeiconified(windowevent e){ public void windowactivated(windowevent e){ public void windowdeactivated(windowevent e){ 使用内部类和匿名类 监听器类中封装的业务逻辑具有非常强的针对性, 一般没有重用价值, 因此经常采用内部类或匿名类的形式来实现 用法举例 : 例 在 GUI 事件处理中使用内部类 TestInner.java 例 在 GUI 事件处理中使用匿名类 TestAnonymousMonitor.java

193 Ex 在理解的基础上, 将例 中的 InnerMoniter 内部类改造为普通的外部类, 实现同样的功能 ; 2. 将例 中的监听器匿名内部类从继承事件适配器类 MouseMotionAdapter 改为实现监听器接口 MouseMotionListener, 实现同样的功能 使用 AWT 常用组件 文本组件 : 文本框 / 文本域 例 例 使用 TextField 组件基于 TextArea 实现留言板功能 菜单组件 : 菜单条 / 菜单 / 菜单项 / 复选菜单项 / 弹出菜单 例 例 使用菜单组件使用多级菜单和弹出式菜单 选择组件 : 下拉式选择框 / 列表框 / 复选框 例 使用选择组件 对话框组件 : 对话框 / 文件对话框 例 例 使用对话框组件使用文件对话框实现文本文件编辑器 滚动组件 : 滚动条 / 滚动面板

194 AWT 视觉控制类 java.awt.color 类 Color 类用于表示标准 RGB 颜色空间中的颜色, 主要用于在 GUI 开发中设置组件的背景色和前景色 java.awt.font 类用于表示字体,Font 对象主要包括如下三方面的字体信息 : 字体名称 字体样式 字体大小 使用 AWT 视觉控制类 import java.awt.*; public class TestVisualControl{ public static void main(string args[]){ Frame f = new Frame("Test"); f.setbackground(new Color(68,175,83)); Button b = new Button(" 启动 "); b.setbackground(color.green); b.setforeground(color.red); Font font = new Font(" 宋体 ",Font.BOLD,20); b.setfont(font); f.setlayout(new FlowLayout()); f.add(b); f.setsize(200,150); f.setvisible(true);

195 AWT 绘图 绘图原理 : 定义子类继承现有组件类, 通过重写 Component 类中定义的 paint() 方法, 加入所需的绘图逻辑, 以实现在 AWT 组件上绘图的目的 public void paint(graphics g) java.awt.graphics 是处理各种图形对象的基本工具类,Graphics 支持两种绘图方式 : 基本绘图 -- 画线 多边形 圆 填充图形和文字等 绘制图像 -- 主要用于图像显示 AWT 绘图举例 : 例 在 AWT 组件上绘图 例 在 AWT 组件上显示图像 Java 小程序 (Applet) Java 小程序 (Applet) 在支持 Java 的浏览器环境中运行, 通常用于在网页中实现嵌入图片 播放声音等多媒体功能, 或添加其他的客户端处理逻辑 ( 如网络计算器 ) Java 小程序都必须继承 java.applet.applet 类 Applet 与 Application 的区别 : 运行方式 性能 安全性要求

196 第一个 Java 小程序 // 源文件 HelloWorld.java import java.awt.*; import java.applet.applet; public class HelloWorld extends Applet { String text ; public void init () { text = "Hello World"; this.setbackground(new Color(120,180,140)); public void paint(graphics g) { g.drawstring (text, 25, 25) ; //html 源文件 test.html <html> <applet code="helloworld.class" width=200 height=150></applet> </html> Applet 两种运行方式 IE 浏览器中运行 使用 appletviewer 查看 Applet 运行机制 Applet 对象具备 GUI 容器的性质, 其默认布局管理器为 FlowLayout 类型 Applet 类提供了小应用程序及其运行环境间的标准接口, 相关方法包括 : public void init(); public void start(); public void stop(); public void destroy(); Applet 生命周期 Applet 安全策略 首次启动 构造 ->init() 运行态 start() 初始态 从活动转入非活动状态 stop() 从非活动转入活动状态 start() 消亡态 停止态 关闭浏览器destroy()

197 Applet 插件标记 在 HTML 页面中嵌入 Java Applet 时, 可以采用插件标记的形式给出 Applet 属性或参数信息 语法格式 : <applet 用法举例 : [archive = archivelist] code = appletfile.class width = pixels height = pixels [codebase = codebaseurl] [alt = alternatetext] [name = appletinstancename] [align = alignment] [vspace = pixels] [hspace = pixels] > [param name = var1 value = value1] [param name = var2 value = value2] </applet> 例 Test.java test.html 第十三章 Swing 基础 197

198 本章学习目标 1 Swing 概述 2 Swing 典型组件 2.1 JFrame 2.2 Swing 按钮 菜单和工具条 2.3 Swing 标准对话框 2.4 表格和树 2.5 定时器 Swing 概述 Swing 与 AWT 的关系 相关基本概念 Java 基础类库 (Java Foundation Classes, JFC) 重量组件 (Heavy-Weight Components) 轻量组件 (Light-Weight Components) 可视化组件 (Visual Component) java.lang.object Swing 组件根父类 JComponent +----java.awt.component +----java.awt.container +----javax.swing.jcomponent

199 JFrame JFrame 继承并扩充了 java.awt.frame 类 JFrame 实现了 javax.swing.windowconstants 接口, 该接口中定义了用于控制窗口关闭操作的整型常量, 包括 : DO_NOTHING_ON_CLOSE HIDE_ON_CLOSE DISPOSE_ON_CLOSE EXIT_ON_CLOSE 用法举例 : 例 13-1 TestJFrame.java Swing 按钮 / 菜单 / 工具条 与 AWT 相应组件对比 用法举例 : 例 13-2 TestSwing.java