再回首： Java关键字 数据类型：byte boolean char double float int long short

Presentation on theme: "再回首： Java关键字 数据类型：byte boolean char double float int long short"— Presentation transcript:

1 再回首： Java关键字 数据类型：byte boolean char double float int long short
特殊的值： false true void null length 程序流程控制： if else 、 switch case、 break default、do – while、for 、continue、return 类的定义：class extends implements import interface package super this 非访问控制符：abstract final static native 特殊运算符： instanceof new 访问控制符：public private protected 异常处理：try catch finally throw throws 线程：thread transient synchronized

2 第3章 Java面向对象编程基础 3.1 面向对象程序设计的基本概念 3.2 类的定义与对象的创建 3.3 继承与多态
3.2 类的定义与对象的创建 3.3 继承与多态 3.4 包与访问控制符 3.5 接口 3.6 异常处理 3.7 Java基础类与工具类

3 学习提要 掌握面向对象的相关概念 了解面向对象的设计方法 掌握Java的类的组成与定义 掌握域与方法的定义与实现 掌握方法的重载与覆盖的含义
理解类的继承的概念与实现 掌握Java的非访问控制符：static、abstract、final 掌握Java的访问控制符：public、protected、private、private protected 掌握包、接口、异常处理的定义与使用方法 掌握Java语言的Object类、Math 类、数据类型类、System类

4 3.1 面向对象程序设计的基本概念 （1）面向对象的几个基本概念
类（Class）是现实世界或思维世界中的实体在计算机中的反映，是对具有相似性质的一批对象的归纳和抽象，代表的是一类事物。 对象（Object，类的一个实例） 域（Field，对象的“状态”，属于静态属性） 方法（Method，对象的“行为”，属于动态属性） 事件（Event，为方法传递消息） 继承（由父类派生出子类） 多态（包括重载Overload、覆盖Override）

5 Student 张凌=new Student ()
学生 Class Student { } 对象、实体与类

6 类图 类与对象的关系 　“人”类和对象“李四”的关系

7 每个对象“总是”有不同的身份，一个类的多个对象“可能”有不同的状态
如何理解 “对象”？ 对象的行为是什么？——方法 对象的状态是什么？——域 对象的身份是什么？——名称 状态可能影响行为 每个对象“总是”有不同的身份，一个类的多个对象“可能”有不同的状态 三方面特征

8 （2）类之间的关系 包含——当类A是类B的属性时，称类B包含类A； 如：发动机与汽车， CPU与计算机
继承——当类A是类B的特例时，称类A继承了类B 如：北京大学和大学，液晶显示器和显示器 关联——当类A的引用是类B的属性时，称类A和类 B之间是关联关系。 如: 汽车与制造商

9 类之间的关系 示例代码 //包含（聚合）关系通常表现为部分与整体的关系，如： public class B{ /***B中的一个属性**/ A a; } //继承（泛化）关系通常表现为继承关系，如： public class B extends A{ } //关联（依赖/使用）最常见的是参数关系，如： public class B{ /***B中的一个方法**/ public void testMethod(A a){ //此时B和A是依赖关系 } }

10 （3）程序设计方法的发展 设计方法 特点 代表性语言 面向机器
用机器指令为特定硬件系统编制程序，其目标代码短，运行速度和效率高，但可读性和移植性差。 86系列汇编语言 面向过程 用高级程序设计语言按计算机能够理解的逻辑来描述要解决的问题及其解决方法，是过程驱动的，程序的可读性和移植性好，核心是数据结构和算法。但大型程序维护起来比较困难。 Fortran（50年代） Basic（60年代） C（70年代） 面向对象 用面向对象的编程语言把现实世界的实体描述成计算机能理解、可操作的、具有一定属性和行为的对象，将数据及数据的操作封装在一起，通过调用各对象的不同方法来完成相关事件，是事件驱动的，其核心是类和对象，程序易于维护 、扩充。 C++（80年代） VB （90年代） Object Pascal （90年代） Java（ 90年代） C++语言是一种通用的面向对象的程序设计语言，1980年由美国贝尔实验室研究员对C语言的功能进行扩充而形成的，其最大的功能扩充是能够帮助维护大型程序（大于5万行）。1982年正式命名为C++。 Object Pascal是Delphi所采用的编程语言。 Fortran=Formula Translator，50年代出现的“老字号”高级程序设计语言，主要用于科学计算。

11 （4）面向对象的软件开发过程 面向对象的软件开发过程可以大体划分为三个阶段：
面向对象的分析（object oriented analysis，OOA） 面向对象的设计（object oriented design，OOD） 面向对象的实现（object oriented programming，OOP） Peter Coad and Edward Yourdon,

12 （5）面向对象程序设计的四个特点： （6）面向对象程序设计的三大优点： 抽象性——采用数据抽象的方法来构建程序的类、对象和方法
封装性——将数据和基于数据的操作封装在一起 继承性——一个类可以从其它已有的类中派生 多态性——一个程序中可以有同名的不同方法共存 （6）面向对象程序设计的三大优点： 可重用性 可扩展性 可管理性

13 3. 2 类的定义与对象的创建 类属于一种抽象的数据类型，是Java程序的基本组成要素，其基本成分包括：
3. 2 类的定义与对象的创建 类属于一种抽象的数据类型，是Java程序的基本组成要素，其基本成分包括： 成员变量 成员方法 （如：人，性别，吃饭） 对象是由类模块创建的，其基本组成包括： 对象标识（对象的名字，也叫对象的引用） 状态（对象的静态属性） 行为（对象的动态属性） （如：张三，男，狼吞虎咽的吃饭） 编写Java程序就是一个编写类和创建对象的过程

14 （1）类的封装（可用类图示意） 类由属性（域）和方法构成，是Java编程的基础 类既要提供与外部联系的接口，同时又要尽可能隐藏类的实现细节。
属性（数据） 方法（操作数据）

15 （2）类的定义 { //域的定义 [修饰符] 数据类型 变量名[=值]； public abstract final …… //方法的定义
[修饰符] class 类名 [extends 父类] [implements 接口名] {      //域的定义 [修饰符] 数据类型 变量名[=值]； …… //方法的定义 [修饰符] 返回值类型 方法名（[参数列表]） { //方法体 } public abstract final

16 域的定义 [修饰符] 数据类型 变量名[=值]； int x = 3, y; //定义了整型变量x和y
[修饰符] 数据类型 变量名[=值]； int x = 3, y; //定义了整型变量x和y Date today ; //定义了Date型类变量today char [] m ; //定义了字符型数组m

17 方法的定义 方法由方法头和方法体构成： { //方法体 } [修饰符] 返回值类型 方法名（[参数列表]） 形参 可为各种类型，
或者空类型 void， 表示无返回值

18 方法的参数 形参：可以方便地从外部向方法提供信息。 编写方法时，要说明方法的所有形参名和形参的类型。
void setIncome (double d) { salary = d; }

19 类的完整定义示例 Person类 class Person name sex salary age Person（） getName（）
{ String name; //姓名 int sex; //性别 private double salary; //薪水 int age; //年龄 Person类 name sex salary age Person（） getName（） setIncome( ) public Person(String s1){ name=s1; } String getName() { return name; void setIncome (double d) { salary = d;

20 classDemo.java 成员变量 构造方法 成员方法 public class ClassDemo { int a; int b;
} void show() System.out.println(“a=”+a+”,b=”+b); public static void main(String args[]) new ClassDemo(). show(); 成员变量 构造方法 成员方法

21

22

23 （3）构造方法 构造方法是类的一种特殊方法，主要作用是在创建对象时，进行必要的初始化。 特点： 方法名必须与类名相同
没有返回值类型，也没有void 在用户创建对象时，由系统自动调用执行，用户不能直接调用构造方法。

24 引入构造方法的原因: 1) 满足面向对象程序设计中对象初始化的需要; 2) 提高灵活度，使初始化工作除赋值外有更复杂的操作; 在不定义构造方法时，系统会自动为该类生成一个默认的构造方法。

25 构造方法的定义 Person类的构造方法： public Person(String s1) { name=s1; }

26 缺省构造 类中可以不出现构造方法，如果没有构造方法，系统将为该类缺省定义一个空构造方法，也称为缺省构造方法。用缺省构造方法初始化对象时，系统用缺省值初始化类对象的数据成员。 各数据类型的缺省值如下： 数值型：0 布尔型：false 字符型：’\0’ 类：null

27 （4）对象的定义 对象实例化的语法为： 下面是对象实例化的例子： Person myPerson = new Person(“孙悟空”);
类名 objectName = new 构造方法名([参数列表]); 下面是对象实例化的例子： Person myPerson = new Person(“孙悟空”); 为对象分配内存空间，同时调用类的构造方法对该对象进行初始化

28 firstPerson.name = “Henry”;
（5）对象的使用 可以用点（.）操作符来调用对象实例的成员变量和方法 成员变量的引用 成员变量引用的形式如下： 对象名.成员变量名 例如可以通过赋值语句修改firstPerson.name的值： firstPerson.name = “Henry”;

29 方法的调用 对象的方法调用的一般形式如下： 对象名.方法名( 参数列表) 例如： firstPerson.setIncome(5000);
实参 实参

30 参数传递示例 值传递

31 参数传递 ⑴ 值传递 ⑵引用传递 调用方法时，参数是普通变量，实参将其值传给形参，调用中实参的值不受形参的影响。
调用方法时，参数的类型为复合数据类型，如：数组、类，实参随形参的变化而变化。

32 引用传递 public class SquareC { void square(int x[]) int s=0;
for(int i=0;i<x.length;i++) x[i]=i*10; } public static void main(String args[]) int n[]=new int[5]; SquareC a=new SquareC(); for(int i=0;i<5;i++) n[i]=i; System.out.print(n[i]+" "); System.out.println(); a.square(n); 引用传递

33 对象的使用总结 对象是一个动态概念，具有产生、使用和消亡的生命周期 通过new操作符创建对象 对象属性的使用： 对象方法的使用：
对象名.属性 对象方法的使用： 对象名.方法名（） 当对象不再使用时，将由系统的垃圾回收机制进行回收。

34 （6）变量的作用域 在方法体中定义的变量称为局部变量，它只能被定义它的方法内部访问。而成员变量可以被类中的所有方法访问。
成员变量随对象的创建而创建，局部变量在方法被调用时创建，在方法调用结束后销毁。 与成员变量不同，局部变量使用前，必须进行初始化。 局部变量的名字可以与成员变量相同 。

35 成员变量 不同方法中的同名局部变量互不影响
class AreaVarity { int vary1,vary2; int Multiply() int z; z=vary1*vary2; return z; } int Sum() z=vary1+vary2; 成员变量 不同方法中的同名局部变量互不影响 public static void main(String args[]){ AreaVarity a=new AreaVarity(); a.vary1=1; a.vary2=2; System.out.print(a.vary1+" "); System.out.println(a.vary2); System.out.println(a.Multiply()); System.out.println(a.Sum()); }

36 局部变量的名字可以与成员变量相同 public class EqualVarible{ int i=2; //此处i为成员变量
加this表达 成员变量 public class EqualVarible{ int i=2; //此处i为成员变量 void mv(){ int i=6; //此处i为局部变量 System.out.println("i="+i); } public static void main(String args[]){ EqualVarible k = new EqualVarible(); k.mv(); System.out.println("this.i="+this.i); this:指代当前对象，常用形式this.域变量，表示引用当前对象的某域变量

37 形参名可以与类的成员变量名相同 如果相同，那么形参名将在方法体内隐藏同名的成员变量。 public class Rectangle{
double x; //成员变量 double y; //成员变量 double computeArea(double x, double y){ double s; s = x*y; return s; } } 局部变量 如何调用computeArea方法？ 请编写main方法，以调用computeArea方法

38 课堂练习： 1.编写一个车辆类，其中包括2个成员变量：车辆类别、轮胎数量，2个成员方法：分别用来设置车辆类别和轮胎数量。
2. 编写一个Java Application程序，实现车辆对象的创建，并调用其成员方法将所创建车辆的“车辆类别”设置为“长公交”、轮胎数量设置为6，要求通过字符界面输出所创建与设置的结果。

39

40 3.3 继承与多态 类的继承 类的多态性 非访问控制符

41 3.3.1 类的继承 1. 继承的概念 继承是一种由已有的类创建新类的机制。
类的继承 1. 继承的概念 继承是一种由已有的类创建新类的机制。 在类的继承中，被继承的类称为父类，继承而来的类则称为子类。父类和子类之间反映的是“一般与特殊”的关系。 子类继承父类所有非private的属性和方法，同时也可以在父类的基础上添加新的属性和方法。 Java中，一个父类可以同时拥有多个子类，但一个类只能继承一个父类，称为单重继承。

42 子类的派生： 子类新增了属性和方法 class Employee { String name; char sex; int age;
protected double salary; public double getSalary() return salary; } public void modiSalary(double a) salary=salary+a; class Teacher extends Employee { String speciality; public String getSpeciality() return speciality; } public void setSpeciality(String s) speciality=s;

43 子类的派生： 用类图表达 Employee Teacher getSalary() getSalary() modiSalary()
String name char sex int age double salary getSalary() modiSalary() Teacher String name char sex int age double salary String speciality getSalary() modiSalary() getSpeciality() setSpeciality()

44 图 1 各种图形类及其间的继承关系

45 在面向对象的程序设计中，采用继承的机制来组织、设计系统中的类的优点：
可以提高程序的抽象程度，使之更接近于人类的思维方式； 使得程序结构清晰，降低编码和维护的工作量。

46 在 Java 中，类的层次结构为树型结构，其中Object为树型结构的根类，所有其他类都直接或间接地继承自Object类。
…… 父类 Person Teacher Student Employee …… …… 子类

47 2. 继承的实现 定义子类的形式为： public、abstract、final [修饰符] class 类名 extends 父类名 {
2. 继承的实现 定义子类的形式为： [修饰符] class 类名 extends 父类名 { 类体 } public、abstract、final

48 类的继承原则： 子类继承父类的非私有成员变量，包括实例成员变量和类成员变量。 子类继承父类的非私有成员方法，包括实例成员方法和类成员方法。
子类可以重新定义父类成员。

49 类的继承示例

50 类的继承示例

51 3. 属性的继承与隐藏 （1）属性的继承：子类从父类继承属性而不是把父类属性的定义部分复制一遍，可以减少程序维护的工作量。
3. 属性的继承与隐藏 （1）属性的继承：子类从父类继承属性而不是把父类属性的定义部分复制一遍，可以减少程序维护的工作量。 （2）属性的隐藏：对子类从父类继承来的属性变量重新加以定义。 即：子类定义了与父类同名的属性变量，即出现了子类变量对同名父类变量的隐藏。 区别： 子类执行继承自父类的操作时，处理的是继承自父类的变量。 子类执行它自己定义的方法时，操作的是自己定义的变量，而把继承自父类的变量“隐藏”起来。

52 4. 方法的继承 父类的非私有方法作为类的非私有成员，可以被子类所继承。

53 不写这个方法时，可以直接继承 setArea（）方法。

54 类在继承时会遇到的问题： 如何处理同名变量？ 如何处理同名方法？

55 5. 父类对象与子类对象的使用与转化 super和this是用来指代父类对象和子类对象的关键字。Java系统默认每个类都缺省地具有null、this和super三个量，null代表“空” 。 （1）this this表示的是当前对象本身，代表当前对象的一个引用，如可以利用this写成：

56

57 This的使用场合 在构造函数中使用 指代该构造函数创建的对象，放在另一个构造函数的第一行 在实例方法中使用
指代该对象，在不影响理解的情况下可省略 使用this区分参数和成员变量 避免混淆同名的参数与成员变量 使用this区分成员变量和局部变量 恢复被隐藏的同名成员变量

58 （2）super super代表当前对象的直接父类对象，是当前对象的直接父类对象的引用。 super的两种使用方法：
放在子类构造函数的第一行 使用super操作被隐藏的成员变量和方法 在子类重新定义了与父类同名的成员变量和方法时，可用super调用父类的同名属性和方法。

59

60

61

62

63 super 与 this 使用小结 super 引用父类成员变量 引用父类成员方法 引用父类构造方法 super.成员变量名

64 super 与 this 使用小结 this 引用当前对象的成员变量 引用当前对象的成员方法 引用当前对象的构造方法 this.成员变量名

65 （3）父类对象与子类对象的转换原则 1）子类对象可以被视为是父类的一个对象； 2）父类对象不能被当作其某一个子类的对象； 3）如果一个方法的形式参数定义的是父类对象，则调用这个方法时，可以使用子类对象作为实际参数； 4）如果父类对象引用指向的实际是一个子类对象，则这个父类对象的引用可以用强制类型转换成子类对象的引用。

66 关于对象的上转型对象 设B类是A类的子类或间接子类, 当出现下列情况时，称A类对象a是子类对象b的上转型对象。 A a; //声明A类对象
B b=new B( ); //声明B类（子类）对象 a=b; //将子类对象赋值给父类对象 注意： （1）上转型对象不能操作子类新增的成员变量，不能使用子类新增的方法； （2）不可以将父类创建的对象的引用赋值给子类声明的对象，即不可以是 b=a； （3）可以将对象的上转型对象再强制转换为一个子类对象，即： b=(B)a; 这时该子类对象又具备了子类的所有属性和功能。

67 A a; //声明A类对象 B b=new B( ); //声明B类（子类）对象 a=b; //将子类对象赋值给父类对象 新增的变量 对象的上转型对象 a 新增的方法 继承或隐藏的变量 对象 b 继承或隐藏的方法 上转型对象示意图

68

69 关于Java中对象的引用和实体 当用类创建一个对象时，类中的成员变量被分配空间，这些内存空间称为该对象的实体，而对象中放着引用，以确保实体由该对象操作使用。 例：Point p1=new Point(12,16); Point p2=new Point(6,18); 当执行 p1=p2; 后 0xDD 18 6 P2 x y P1 对象内存模式2 0xAB 16 12 P1 x y 0xDD 18 6 P2 x y 对象内存模式1

70 6. 构造函数的继承 指子类可以继承父类的构造方法。 构造方法继承应遵循的原则： 1）子类无条件地继续父类的不含参数的构造方法；
2）如果子类自己没有构造方法，则将继承父类的无参构造方法作为自己的构造方法；如果子类自己定义了构造方法，则在创建新对象时，先执行从父类继承来的无参构造方法，然后再执行自己的构造方法； 3）对于父类的含参构造方法，子类可以通过在自己构造方法中使用super关键字来调用它，但这个调用语句必须是子类构造方法的第一个可执行语句。

71 3.3.2 类的多态性 多态是指一个程序中同名的不同方法共存的情况。 实现多态的途径：
1）覆盖（ override ）——在子类中对从父类继承的方法进行重新定义，即重写。 2）重载（ overload ）——在同一个类中定义多个同名的定义内容不同但最终功能相同的方法。 比如，程序中定义多个名为 print方法，用来打印不同类型的数据，如字符型、数值型等。 区分同名方法的措施：采用不同的形式参数列表，包括形式参数的个数、类型、顺序的不同。 注意：只是改变方法的返回值类型不改变参数是不行的。

72 1. 构造方法的重载 指同一个类中存在着若干个具有不同参数列表的构造方法。
1. 构造方法的重载 指同一个类中存在着若干个具有不同参数列表的构造方法。 出现重载情况时，创建该类对象的语句会自动根据给出的实际参数的数目、类型和顺序来确定调用哪个构造方法来完成新对象的初始化工作。 一个类的若干构造方法之间可以通过关键字this来互相调用，目的是最大限度地利用已有程序，提高程序的抽象、封装程度，减少程序维护工作量。 注意：this语句必须是整个构造方法的第一个可执行语句。

73

74

75 2. 方法的重载与覆盖 （1）方法的覆盖 子类定义与父类同名的方法，除非使用super关键字或父类名 为前缀，否则调用的都是自己定义的方法。
注意：子类在重新定义父类已有的方法时应保持与父类完全相同 的方法头声明,其访问权限不可窄于父类的访问权限。 （2）方法的重载 即类对自身已有的同名方法重新定义。 方法的重载是同类中同名方法共存的情况，需通过参数列表（ 包括类型、顺序和数目）来区分不同的方法。 注意：不能通过方法的返回值来区分同名的不同方法。

76 方法的重载示例 正确的重载方法头： 错误的重载方法头： public double area(double r)
public double area(int a, double b) public double area(double a, int b) 错误的重载方法头： public int volume(int a, int b) public void volume(int x, int y)

77 方法的重载 示例 例如，计算圆、三角形和长方形的面积，可以定义具有以下方法头的3个重载方法：
public double area(double r) public double area(double a, double b, double c) public double area(double a, double b)

78

79 3.3.3 Java的非访问控制符 Java的非访问控制符 static 静态修饰符 修饰属性和方法
abstract 抽象修饰符 修饰类和方法 final 最终修饰符 修饰类、属性和方法

80 1. 静态属性、静态方法与静态初始化器 （１）静态属性
1. 静态属性、静态方法与静态初始化器 （１）静态属性 被static修饰的属性不属于任何一个类的具体对象，是公共的存储单元。任何对象访问它时，取到的都是相同的数值。静态属性是类属性。 当需要引用或修改一个static限定的类属性时，可以使用类名，也可以使用某一个对象名，效果相同。

81 （２）静态方法 用static修饰符修饰的方法，是属于整个类的方法。 用static修饰的方法的含义：
1）调用这个方法时应该使用类名做前缀， 一般不用某个具体的对象名（尽管可以用）； 2）该方法属于整个类，它在内存中的代码段随着类的定义而分配和装载； 3）该方法不能操纵属于某个对象的成员变量，即static方法只能处理static属性。

82

83

84 （3）静态初始化器 直接用static 当名字、用{ }包起来的一段特殊代码。与构造函数类似，完成初始化工作，但两者的区别是：
静态初始化器对每个类初始化，构造函数对每个新创建的对象初始化。 静态初始化器在所属的类加载入内存时由系统调用运行，构造函数则在产生新对象时由系统自动执行。 静态初始化器不是方法，没有方法名、返回值和参数列表。 总之，静态初始化器对整个类完成初始化操作，包括给static类成员赋初值。

85

86 2. 抽象类和抽象方法 用abstract修饰的类或方法。 1）抽象类 抽象类是没有具体实例对象的类，主要用来实现类之间的继承关系。 使用抽象类的优点就是可以充分利用公共属性来提高开发和维护程序的效率。 2）抽象方法 抽象方法仅有方法头而没有具体的方法体，方法体的实现由当前类的不同子类在各自的类定义中完成。抽象方法只能存在于抽象类中。

87 抽象类与抽象方法的关系 抽象类中可以有0个或多个抽象方法，也可以包含非抽象的方法。
抽象类中可以没有抽象方法，但是，有抽象方法的类必须是抽象类。 抽象类派生的子类中必须实现抽象类中定义的所有抽象方法。

88 抽象类示例

89

90

91

92

93 3. 最终类、最终属性、最终方法 用final最终修饰符来修饰的类、属性和方法。 1）最终类 用final修饰的最终类不能有子类。
3. 最终类、最终属性、最终方法 用final最终修饰符来修饰的类、属性和方法。 1）最终类 用final修饰的最终类不能有子类。 2）最终属性 用final修饰的最终属性在整个执行过程中都不会变，一般用来修饰常量。修饰常量时需要说明常量的数据类型和常量的具体取值。为了节省空间，常量通常还同时被声明为static。 3）最终方法 用final修饰的最终方法其功能和语句都不能再被修改，即不能被当前类的子类重载。目的是为了预防不必要的重复定义。

94 用final修饰的类不能被继承; 用final修饰的成员方法不能被覆盖; 用final修饰的成员变量不能被修改。
注意：所有已被private修饰符限定为私有的方法，以及所有包含在final类中的方法，都被缺省地认为是final的。 用final修饰的类不能被继承; 用final修饰的成员方法不能被覆盖; 用final修饰的成员变量不能被修改。

95 例 继承final类 final class C1 { int i; public void print()
System.out.println("i="+i); } public class C2 extends C1 //出错 double x; public double getX() { return x; }

96

97 4 . 修饰符的混合使用 大多数情况下，修饰符是可以混合使用的。
4 . 修饰符的混合使用 大多数情况下，修饰符是可以混合使用的。 例如：public abstract class transportmeans... 但有以下例外： abstract不能与final并列修饰同一个类； abstract不能与private、static、final、native并列修饰同一个方法； abstract类中不能有private的成员（包括属性和方法）； abstract方法必须在abstract类中； static方法中不能处理非static的属性。

98 3.4 Java的包与访问控制符 3.4.1 包的概念 包（package）是一种松散的类的集合，包以目录形式存在。包是Java有效管理类的一个机制。 定义包的目的： 在Java中,为了使类易于查找和使用，也为了防止命名冲突和限定类的访问权限，可以将一组相关的类与接口存储在一起形成包，使得程序功能清楚、结构分明，有利于实现不同程序间类的复用。 同一个包中的类在缺省情况下可以互相访问，为了便于编程和管理，常把需要在一起工作的类放在一个包里。

99 3.4.2 Java的类库 Java类库——已有的有特定功能的Java程序模块。
Java的类库大部分是由SUN公司提供的，叫基础类库（JFC）； 根据功能不同，Java的类库被划分为若干个不同的包，每个包中都有若干个具有特定功能和相互关系的类和接口。

100 使用系统类库的方式： （1）继承系统类，在用户程序里创建系统类的子类
如： public class SjApplet extends Applet （2）创建系统类的对象 如：TextField input= new TextField（6） （3） 直接使用系统类 如：System.out.println（） 注意：使用系统类之前，用户程序需要用import语句引入所用到的系统类或系统类所在的包。 如：import java.awt.*； import java.awt.event.*； System：系统类 Out：静态属性 println：方法

101 3.4.3 Java中常用的包 （1） java.lang 包
（2） java.io包 是Java语言的标准输入/输出类库，包含了实现Java程序与操作系统、用户界面以及其他Java程序做数据交换所使用的类。 （3） java.util包 包含了Java语言中的一些低级的实用工具，如处理时间的Date类、处理变长数组的Vector类，栈Stack类、散列表HashTable类等。

102 （4）java.awt包 是Java语言用来构建图形用户界面（GUI）的类库。 低级绘图操作——Graphics类等 java.awt 图形控件和布局——Container类、 Checkbox类、LayoutManager接口等 界面用户控制和事件响应——Event类 （5）java.applet包 是用来实现在Internet浏览器中运行Java Applet的工具类，其中包含一个非常有用的类java.applet. Applet。 （6） java.awt.event包 是对Event类的一个扩充，可以用不同方式来处理不同类型的事件，并使每个图形界面元素本身可以拥有处理它上面事件的能力。

103 3.4.4 创建包 缺省情况下，系统创建一个无名包，无名包中的类不能被其他包中的类引用和复用，为此需要创建有名字的包。建议包名全部采用小写字母。 语法：package  包名;//必须是整个java文件的第一个语句 如：package PhoneCard； //在当前文件夹下创建文件夹PhoneCard    package PhoneCard. PhoneCard200 //在当前文件夹下创建文件夹 PhoneCard ，PhoneCard文件夹下创建文件夹PhoneCard200 定义了包的类，编译后生产的字节码需要复制到该包名所指目录下才可以执行该类。可带参数编译实现自动复制： javac –d 路径 文件名.java

104 //创建包示例 X1.java package card; public class X1 { int x,y; public X1(int i,int j) this.x=i; this.y=j; System.out.println("x="+x+" "+"y="+y); } public void show() System.out.println("this class is a X1!");

105 Javac –d 表示编译时将class文件放在哪个目录下
//创建包示例 X2.java package card; public class X2 { int m,n; public X2(int i,int j) this.m=i; this.n=j; System.out.println("m="+m+" "+"n="+n); } public void show() System.out.println("this class is a X2!"); Javac –d 表示编译时将class文件放在哪个目录下

106 3.4.5 包的引用 通常一个类只能引用与它在同一包中的类，若要引用其他包的public类，可使用下列方法： （1） 使用包名、类名前缀
包的引用 通常一个类只能引用与它在同一包中的类，若要引用其他包的public类，可使用下列方法： （1） 使用包名、类名前缀 使用同一个包中的类，只须加上类名作为前缀;若使用其他包中的类，则还须在类名前缀前加上包名前缀。 例： public class Pack1 { public static void main(String args[]) card.X1 aa=new card.X1(4,5); //直接用包名.类名 aa.show(); card.X2 bb=new card.X2(10,20); bb.show(); }

107 加载整个包后，使用这个包中的类不须再使用包前缀
（2） 加载需要使用的类 例： import card.X1;   //程序开始加载其他包的类 public class Pack { public static void main(String args[]) X1 aa=new X1(4,5); //因类已加载，不需要再使用包名做前缀 aa.show(); } （3） 加载整个包 import card.*; import java.awt.*; 加载整个包后，使用这个包中的类不须再使用包前缀

108 //包的引用示例 Pack.java import card.*; public class Pack { public static void main(String args[]) X1 aa=new X1(4,5); aa.show(); X2 bb=new X2(10,20); bb.show(); }

109 CLASSPATH 类路径： CLASSPATH是系统环境变量，指明所有缺省的类字节码文件 .class的路径；当程序找不到所需其他类的.class文件时，系统自动到CLASSPATH所指明的路径中寻找。可以在控制面板—系统—高级中设置，新建变量CLASSPATH 。 例：JDK的java解释器有开关参数-classpath java test -classpath d:\aa 表示test文件不在当前目录，而在d:\aa目录下。

110 3.4.6 Java的访问控制符 Java的访问控制符种类 public 公共的，修饰类、属性和方法 private 私有的，修饰属性和方法
protected 受保护的，修饰属性和方法 private protected 私有受保护的，修饰属性和方法 无符号的缺省定义 友好的， 修饰类、属性和方法 作用： 限定类、属性和方法被程序里的其他部分访问和调用

111 1 公共访问控制符 public public——“公有的、公共的”，它不仅可以修饰类，还可以修饰变量和方法。

112 2 . 保护访问控制符 protected 关键字protected修饰的域和方法能被以下三种类访问和调用： 域和方法所在的类。
同一个包内的其它类。 其它包（package）中该类的子类。

113

114 3. 缺省的修饰符 如果一个类、域和方法前面没有被访问控制符修饰，说明它具有缺省的访问控制特性（包访问特性） ： 域和方法所在的类。
3. 缺省的修饰符 如果一个类、域和方法前面没有被访问控制符修饰，说明它具有缺省的访问控制特性（包访问特性） ： 域和方法所在的类。 同一个包内的其它类。

115 4. 私有访问控制符 private private——私有的，修饰域和方法。

116 编译时 报错

117 同一包内的访问示意图：

118 包间的访问示意图：

119 类、属性和方法的访问控制 小结 类 属性与方法 public 缺省 A B protected B+C private protected
C+D E+D private D A:所有类 B：包中的类 C：所有 子类 E：包中 子类 D：本类

120 访问控制符使用习惯 在声明类时，通常将成员变量声明为private权限，仅允许本类的方法访问成员变量，而将方法声明为public权限，供其他类调用。 构造方法一般声明为public权限。

121 关于构造函数的访问权限 一个类没有定义构造函数时，系统提供的默认无参构造函数的访问权限与该类的访问权限相同；
当类的访问权限与该类的构造函数的访问权限定义的范围不同时，则对该构造函数的访问权限是其与该类的访问权限的交集。比如：类A的构造函数是protected，而类A本身是默认的，则对类A的构造函数的访问权限是默认的。

122 3.5 Java的接口 接口的基本概念 接口又称界面，是由抽象方法和常量组成的特殊类，代表了某一组功能的实现，是用来实现类间多重继承功能的结构。 Java中一个类只能有一个父类，但可以同时实现若干个接口，故可以实现类似于类的多重继承的功能。 接口仅仅定义对外接口和规范，并没有实现这个功能；功能是在继承了这个接口的类中完成的。 接口的访问控制符只有public一个，表明可以被所有的类和接口使用，如果没有此修饰符，则只能被同一个包中的其他类和接口利用。 接口也具有继承性，用extends来声明，一个接口可以有一个以上的父接口，之间用逗号分隔。

123 3.5.2 接口的声明 接口用关键字interface来声明。 语法：
[public] interface 接口名 [extends 父接口名列表] {         //常量域说明；      [public] [static] [final] 域类型 域名=常量值;      //抽象方法声明      [public] [abstract] [native] 返回值 方法名（参数列表） （throw异常列表）; }

124 说明： 接口中的所有属性都必须是public static final，接口中的所有方法都必须是默认的public abstract，这都是系统默认的，无论是否有修饰符显式地限定它们，效果都一样。 例： public interface java.io.DataInput { public abstract boolean readBoolean( ); //读入布尔型数据 public abstract byte readByte( ); //读入字节型数据 public abstract char readChar( ); //读入字符型数据 public abstract double readDouble( ); //读入双精度型数据 public abstract float readFloat( ); //读入浮点型数据 public abstract String readLine( ); //读入一行 }

125

126 定义与使用接口例题

127

128

129

130 3.5.3 接口的实现 实现某个或某几个接口时，需注意： （1）在类的声明部分用implements声明该类将要实现哪些接口；
接口的实现 实现某个或某几个接口时，需注意： （1）在类的声明部分用implements声明该类将要实现哪些接口； (2) 如果实现某接口的类是abstract的抽象类，则它可以不实现该接口所有的方法。但对于这个抽象类任何一个非抽象的子类而言，不允许存在未被实现的接口方法。

131 接口与抽象类的比较 接口中的所有方法都是抽象的，而抽象类中既可以声明抽象方法，也可以声明非抽象方法；
一个类可以实现多个接口，但只能继承一个抽象类； 接口与实现它的类不构成继承关系，即接口不是类体系的一部分，不相关的类可以实现相同的接口；而抽象类属于一个类的继承体系。 使用接口的优势： 一是类通过实现多个接口实现多重继承，二是能够抽象出不相关类之间的相似性，而不必强行形成继承关系。 只有在必须使用方法或成员变量时，才应该考虑使用抽象类，否则用接口代替抽象类。

132 3.6 Java的异常处理 3.6.1 编程中的错误 编程中的错误分为编译错误和运行错误。 编译错误：
程序由于语法的原因无法通过由源代码到目标码的编译而产生的错误。 运行错误： 系统错误：引发操作系统问题的错误，如死循环、死机； 逻辑错误：无法实现设计意图和功能的错误，如算法考虑不周、边界条件不正确。

133 异常是特殊的错误运行对象，又称例外，对应着Java语言特定的运行错误处理机制。
3.6.2 异常与异常类 （1） Java 的异常处理机制 异常是特殊的错误运行对象，又称例外，对应着Java语言特定的运行错误处理机制。 为了能够及时有效地处理程序中的运行错误，Java引入了异常和异常类。异常是异常类的对象。 一旦一个异常对象产生了，系统中就一定有相应的机制来处理它，确保不会产生死机、死循环或其它对操作系统的损害，保证整个程序运行的安全性。

134 InterruptedException IllegalAccessException ClassNotFoundException
（2）异常类结构与组成 每一种类对应一种特定的错误；异常类都是系统Exception类的子类. Throwable类 Error类 Exception类 IOException … … RuntimeException … … AWTException InterruptedException IllegalAccessException ClassNotFoundException

135 Throwable类是类库java.lang包中的一个类，派生两个子类：Exception和Error
public Exception()；           public Exception(String s); 其中s是对该例外所对应的错误的描述。 从父类Throwable继承的常用方法： 1） public String toString(); 该方法返回描述当前Exception类信息的字符串。  2）   public void printStackTrace(); 该方法的功能是完成一个打印操作，在屏幕上输出当前例外对象的堆栈使用轨迹，即程序先后调用了哪些对象或类的方法，使得运行过程中产生了这个例外对象。

136 （3）系统定义的运行异常与所对应的系统运行错误 系统定义的运行异常
异常对应的系统运行错误 ClassNotFoundException 未找到欲装载使用的类 ArrayIndexOutOfBoundsException 数组越界使用 FileNotFoundException 未找到指定的文件或目录 IOException 输入、输出错误 ArithmeticException 算术错误，如除数为0 SecurityException 安全性错误，如Applet欲读写文件 MalformedURLException URL格式错误

137 （4）用户自定义的异常 作用：用来处理程序中特定的逻辑运行错误。 创建用户自定义异常时，一般需要完成如下工作：
（1）声明一个新的异常类，使之以Exception类或其他某个已经存在的系统异常类或用户异常类为父类； （2）为新的异常类定义属性和方法，或重载父类的属性和方法，使这些属性和方法能够体现该类所对应的错误的信息。 定义足够多的异常类是构建一个稳定完善的应用系统的重要基础之一。

138 定义异常类 示例

139 3.6.3 异常的抛出 Java程序在运行时如果由于可识别的错误，系统就产生一个与该错误相对应的异常类的对象，这个过程就是异常的抛出。
（1）系统自动抛出的异常 所有系统定义的运行异常都可以由系统自动抛出。 例：public class TestSystemException  {     public static void main(String[] args)    {         int a=0,b=5;        System.out.println(b/a); //以零为除数，引发系统定义的算术异常     } }

140 （2）语句抛出的异常 用户程序定义的异常不可能靠系统自动抛出，必须借助throw语句定义何种情况才算产生了此种异常对应的错误，并抛出这个异常类的新对象。 语法： 修饰符 返回类型 方法名（参数列表） throws 异常类名列表 {   ...     throw 异常类名;     ... } 对有可能出现异常的方法，用throws语句列出可能出现的异常类名，这样当发生异常时，系统就调用异常处理程序。

141 注意的问题： （1）一般这种抛出异常的语句应该被定义为在满足一定条件时执行，如在if语句的条件分支中。
（2）含有throw语句的方法，应该在方法头定义中增加如下的部分： throws 异常类名列表 （3）由于系统不能识别和创建用户自定义的异常，所以需要编程者在程序中的合适位置创建自定义异常的对象，并利用throw语句将这个新异常对象抛出。

142 定义可能产生异常的方法 示例

143

144 3.6.4 异常的处理 包括捕捉异常、程序流程的跳转和异常处理语句块的定义。 （1）捕捉异常
异常的处理 包括捕捉异常、程序流程的跳转和异常处理语句块的定义。 （1）捕捉异常 异常被抛出时，用专门的语句来接收异常对象，格式如下： catch（异常类名 异常形式参数名） {     异常处理语句； }

145 Java语言规定： 每个catch语句块都应该与一个try语句块相对应，这个try语句块用来启动Java的异常处理机制，可能抛出异常的语句（包括throw语句、调用可能抛出异常方法的方法调用语句）都应该包含在这个try语句块中。

146 （2）多异常处理 通过一个try块后面定义若干个catch块来实现，每个catch块用来接收和处理一种特定的异常对象。 注意如下问题： 1）catch块中的语句应根据异常的不同执行不同的操作； 2）处理多异常时应注意设计各catch块的排列顺序，一般处理较具体和常见的异常应放在前，可以与多种异常相匹配的应放在后；否则可能造成它后面的catch块将永远不被使用。

147 用try/catch块抛出并捕获异常 示例

148 三种情况的运行结果如下：

149 异常处理机制小结（定义、抛出、捕捉） 1）定义异常类y的处理内容： class 异常y extends Exception { …… }
方法x( ) throws 异常y { … throw （new 异常y（参数））； … } 3）将可能产生异常的方法放在try块里启动异常处理机制 try{ …… 方法x( ) ；…… } 4）捕获异常： catch（异常y y1） { …… }

150 应用了面向对象各种知识的 完整例子——银行卡 http://java. hhit. edu. cn/News/Detail_Layout1
应用了面向对象各种知识的 完整例子——银行卡 且看且思考 且敲且理解 且考且答疑 且学且进步

151 3.7 Java语言基础类库 3.7.1 Object类 Object类是Java程序中所有类的直接或间接父类，也是类库中所有类的父类。Object类包含了所有Java类的公共属性，其中的主要方法有： （1）protected Object clone（） 生成当前对象的一个拷贝，并返回这个复制对象。 （2）public boolean equals（Object obj） 比较两个对象是否相同，是则返回true。 （3）public final Class getClass（） 获取当前对象所属的类信息，返回Class对象。

152 3.7.2 数据类型类 （4） protected void finalize（） 定义回收当前对象时所需要完成的清理工作。
（5） public String toString（） 返回当前对象本身的有关信息，按字符串对象返回。 数据类型类 数据类型类 基本数据类型 名称 Boolean boolean 逻辑型 Character char 字符型 Double double 双精度型 Float float 浮点型 Integer int 整型 Long long 长整型

153 Integer类的使用 （1）最大值和最小值的限定： 通过 MAX_VALUE域 和 MIN_VALUE域来设定
public Integer（int value）：通过int数据生成 public Integer（String s）：通过字符串生成 （3）数据类型转换方法： 将当前对象所对应的int量转换成其他基本数据类型的量，并返回转换后的值。 public double doubleValue( ) public int intValue( ) public long longValue( )

154 (4) 字符串与int量相互转化的方法 1）public String toString（）方法 将当前Integer对象对应的int量转换成字符串； 2）public static int parseInt（String s）是类的方法，直接将字符串转化成int量。 例： int i= Integer.parseInt（”345”）； 3） public static Integer valueOf（String s）也是类的方法，可以将一个字符串转化成一个Integer对象。这个对象对应的int数值与字符串表示的数值一致。 int i= Integer. valueOf(”345”).intValue（）; 对其他数据类型： float f= Float.valueOf(”345”).floatValue（）； float f=Float.parseFloat(“345”);

155 Math类 Math类用来完成一些常用的数学运算,提供了一些static方法,使用时用类名做前缀就可以直接使用。如： k=Math.max(9,6); Math类的主要属性和方法： public final static double E; //数学常数e public final static double PI; //圆周率常量π public static double abs(double a); //绝对值 public static double exp(double a); //e的a幂 public static double floor(double a); //不大于a的最大整数 public static double log(double a); //自然对数

156 public static double sqrt(double a); //开平方
public static double random(); //产生0到1之间的随机数 public static double pow(double a, double b ); //乘方 public static double rint(double a); //四舍五入 public static double IEEEremainder(double a, double b); // 求余数 (取模运算) public static float min(float a, float b); //求最小值 public static double max(double a, double b); //求最大值

157 例 TestMath.java //Math类与数据类型类的使用示例 import java.awt.Graphics;
import java.applet.Applet; public class TestMath extends Applet { public void paint(Graphics g) double a=Math.sqrt(4),d=Math.rint(3.5); double p=Math.pow(a,d),r=Math.random(),r1=Math.rint(r*10); double m=Math.min(4.6,7),n=Math.max(5.5,10.3), n1=Math.min(m,n); double mod=Math.IEEEremainder(12,5); // 取余数 int b=Float.valueOf("34.5").intValue(); //字符串转化成整数 float c=Float.valueOf("34.5").floatValue(); //字符串转化成浮点数 String s1=Integer.toString(b); //整数转化成字符串 String s2=Float.toString(c); //浮点数转化成字符串 String s3=Double.toString(a); //双精度数转化成字符串 String s4=Double.toString(p); String s5=Double.toString(r); String s6=Double.toString(r1); String s7=Double.toString(n1); String s8=Double.toString(mod); g.drawString("计算结果:",10,20); g.drawString(s1,10,40); g.drawString(s2,10,60); }

158 3.7.4 System类 (1) 用System类获取标准输入/输出 标准输入 public static InputStream in;
System的属性 标准输出 public static PrintStream out; 标准错误 public static PrintStream err; 例: char c; try { System.out.println("input a character:"); c=(char)System.in.read(); System.out.println("you have inputed: "+c); } catch(IOException e) System.err.println(e.toString());

159 (2) 用System类的方法获取系统信息及完成系统操作
1）public static long currentTimeMillis( ) 获取自1970年1月1日零时至当前系统时刻的微秒数,通常用来比较两事件发生的先后时间差。 2） public static void exit (int status) 在程序的用户线程执行完之前，强制java虚拟机退出运行状态，并把状态信息status返回给虚拟机的操作系统，如：System.exit（0）；//非0为不正常退出 3) Public static void gc( ) 强制调用Java虚拟机的垃圾回收功能，收集内存中丢失的垃圾对象所占用的空间，使其可以被重新加以利用。

160 3.7.5 时间和日期类 1）时间类（Date） 可以使用DateFormat的子类SimpleDateFormat来实现日期的格式化输出,其构造函数是： public SimpleDateFormat(String pattern) 该构造函数可以用参数pattern指定的格式创建一个对象，该对象调用format(Date date)方法来格式化时间对象date。 系统中计算机的起始时间是公元1970年1月1日0时(格林威治时间)，如果是北京时间为8时。

161 Pattern中可以有的元字符 表示的内容 格式 年 y yy yyyy 月 M MM 日 d dd 时 H HH 分 m mm 秒 s
ss 星期 E 用系统当前时间创建日期对象的方法： Date nowTime=new Date( )

162 import java.util.Date; import java.text.SimpleDateFormat; class testDate //系统时间使用示例 { public static void main(String args[]) Date nowTime=new Date(); Date pastTime=new Date(2000); //该数字为毫秒 System.out.println(nowTime); System.out.println(pastTime); SimpleDateFormat testformat1=new SimpleDateFormat("'现在时间是'：yyyy年MM月dd日E"); System.out.println(testformat1.format(nowTime)); SimpleDateFormat testformat2=new SimpleDateFormat("'过去时间是'：yyyy年MM月dd日HH 时mm分ss秒"); System.out.println(testformat2.format(pastTime)); System.out.println(new Date(System.currentTimeMillis())); }

163 2）日历类（Calendar） 使用Calendar类的static方法getInstance( )可以初始化一个日历对象:
Calendar myCalendar= Calendar. getInstance( ) Calendar对象可以调用方法来设置时间： public final void set(int year,int month,int date) public final void set(int year,int month,int date,int hour,int minute) public final void set(int year,int month,int date,int hour,int minute,int second)

164 //测试日历的使用 import java.util.*; class testCalendar { public static void main(String args[]) Calendar myCalendar=Calendar.getInstance(); myCalendar.setTime(new Date()); String 年=String.valueOf(myCalendar.get(Calendar.YEAR)), 月=String.valueOf(myCalendar.get(Calendar.MONTH)+1), 日=String.valueOf(myCalendar.get(Calendar.DAY_OF_MONTH)), 星期=String.valueOf(myCalendar.get(Calendar.DAY_OF_WEEK)-1); int hour=myCalendar.get(Calendar.HOUR_OF_DAY), minute=myCalendar.get(Calendar.MINUTE), second=myCalendar.get(Calendar.SECOND); System.out.println("现在时间是："+年+"年"+月+"月"+日+"日"+"星期"+星期); System.out.println(""+hour+"时"+minute+"分"+second+"秒"); }

165 Java的向量 （1） 向量的概念 向量（Vector）是java.util包提供的一个用来实现不同类型元素共存的变长数组的工具类。Vector类的对象（不能是简单数据类型）不但可以保存顺序的一列数据，而且还封装了许多有用的方法来操作和处理这些数据，比数组功能强大。 适合用Vector类的情况： （1）需要处理的对象数目不定，序列中的元素都是对象，或可以表示为对象； （2）需要将不同类的对象组合成一个数据系列； （3）需要做频繁的对象序列中元素的插入和删除； （4）经常需要定位序列中的对象或其他查找操作； （5）在不同类之间传递大量的数据。

166 （2）创建向量类的对象 Vector类有三个构造函数，最复杂的是：
Public Vector（int initCapacity，int capacityIncrement）; initCapacity——表示刚创建时Vector序列包含的元素个数 capacityIncrement——表示每次向Vector中追加元素时的增量 例： Vector MyVector = new Vector（10，5） 表示创建的MyVector 向量序列初始有10个元素，以后不够用时，按5为单位递增。创建时不需要指明元素类型，使用时再确定。

167 （3） 向向量序列中添加元素 方法1：用addElement（）方法将新元素添加在向量序列的尾部
（3） 向向量序列中添加元素 方法1：用addElement（）方法将新元素添加在向量序列的尾部 格式：addElement（Object obj）； 方法2：用insertElement（）方法将新元素插入在向量序列的指定位置处 格式：insertElement（Object obj, int index）； 其中index为插入位置,0表示第1个位置. 例: Vector MyVector=new Vector(); for ( int i=0; i<10;i++) { MyVector. addElement( new D200_Card( i, 1111, 50.0, ”200”, 0.10)); } MyVector. insertElement(new IP_Card(123000,22,10.0,”200”),0);

168 （4 ） 修改或删除向量序列中的元素 (1) void setElementAt(Object obj, int index)
将向量序列index位置处的对象元素设置成为obj，如果此位置原来有元素则被覆盖。 (2) boolean removeElement (Object obj) 删除向量序列中第一个与指定的obj对象相同的元素，同时将后面的元素前移。 (3) void removeElementAt(int index) 删除index指定位置处的元素,同时将后面的元素前移。 (4) void removeAllElements() 清除向量序列中的所有元素。

169 （5 ）查找向量序列中的元素 (1) Object elementAt(int index)
返回指定位置处的元素。通常需要进行强制类型转换。 (2) boolean contains (Object obj) 检查向量序列中是否包含与指定的obj对象相同的元素，是则返回true，否则返回false。 (3) int indexOf(Object obj,int start_index) 从指定的start_ index位置开始向后搜索，返回所找到的第一个与指定对象相同元素的下标位置，若指定对象不存在则返回-1。 (4) int lastindexOf(Object obj,int start_index) 从指定的start_ index位置开始向前搜索，返回所找到的第一个与指定对象相同元素的下标位置，若指定对象不存在则返回-1。

170 例 VectorExample.java import java.util.*; public class VectorExample {
public static void main(String args[]) Vector v = new Vector(2, 1); //初始大小是2，增量是1 System.out.println("向量初始大小: " + v.size()); System.out.println("向量初始容量: " + v.capacity()); v.addElement(new Integer(1)); v.addElement(new Integer(2)); v.addElement(new Integer(3)); v.addElement(new Integer(4)); System.out.println("加4个整数元素后的容量: " + v.capacity()); v.addElement(new Double(5.45)); System.out.println("当前容量: " + v.capacity()); v.addElement(new Double(6.08)); v.addElement(new Integer(7));

171 v.addElement(new Float(9.4));
v.addElement(new Integer(10)); System.out.println("当前容量: " + v.capacity()); v.addElement(new Integer(11)); v.addElement(new Integer(12)); System.out.println("第1个元素: " + (Integer)v.firstElement()); System.out.println("最后一个元素: " + (Integer)v.lastElement()); if(v.contains(new Integer(3))) System.out.println("向量容量 3."); Enumeration vEnum = v.elements(); //枚举向量中的元素 System.out.println("\n向量中元素:"); while(vEnum.hasMoreElements()) System.out.print(vEnum.nextElement() + " "); System.out.println(); }

172 集合框架与泛型编程 集合框架 在JDK1.2之后，Java提供了实现常见数据结构的类，这些实现数据结构的类通称为Java集合框架。 例如： 链表类： LinkedList 顺序表类：ArrayList 堆栈类：Stack<E> 树集类： TreeSet<E> 散列映射（哈希表）：HashMap<K,V> JDK1.5 之后有了泛型链表类： LinkedList <E> 优点： 使用泛型类建立的数据结构时，不必进行强制类型转换。

173 泛型编程 （1） 泛型（Generics）概述 泛型是在JDK1.5中推出的，目的是可以建立具有类型安全的集合框架。 在引入范型之前，Java数据类型分为基本数据类型、复合数据类型，其中复合类型分为数组和类。引入范型后，一个复合类型就可以在细分成更多的类型。 例如： 原先的类型List，现在在细分成List<Object>, List<String>等更多的类型。

174 在引入范型之前，要在类的方法中支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题（多态）。 例如： public void write(Integer i, Integer[] ia); public void write(Double d, Double[] da); 的范型版本为： public <T> void write(T t, T[] ta);

175 声明格式： class 名称<泛型列表>{ ……} 泛型类的类体定义与普通类的类体完全类似。
可以是任何对象或接口， 但不可以是基本数据类型 (2) 泛型类的定义 声明格式： class 名称<泛型列表>{ ……} 泛型类的类体定义与普通类的类体完全类似。 例：public class Cone<E>{ //定义一个锥，用泛型E做底 double height; E bottom； public Cone(E b) { bottom=b; } public void setHeight（double h）{ height=h;

176 public double compVolume( ){ String s=bottom
public double compVolume( ){ String s=bottom.toString( ); / /泛型只能调用从Object 类继承或重写的方法 double area=Double.parseDouble(s)； return 1.0/3.0*area*height; } public class ExampleP452{ public static void main(String args[]){ Circle c=new Circle(10); // 创建一个圆形对象 Cone<Circle> cone1=new Cone<Circle>(c); //用圆形当锥底 Rect rec=new Rect(10,20); //创建一个矩形对象 Cone<Rect> cone2=new Cone<Rect>(rec); //用矩形当锥底 cone1.setHeight(15); cone2.setHeight(25); System.out.println(“圆锥体积：”+ cone1. compVolume( ) + “矩形锥体积：”+cone2. compVolume( ) ); } }

177 本章小结 面向对象的基本概念 类的定义与对象的创建 继承与多态 非访问控制符与访问控制符 包 接口 异常处理 系统类库与常用工具类

178 基本类型的参数传递——值传递 换 x ? public class Change { static int i=5;
public static void main(String args[]) System.out.println("Bfore change i is "+i); change(i); System.out.println("After change i is "+i); } public static void change(int i) i=10; } 程序执行后，显示结果是什么？为什么？ 换 x ?

179 对象类型的参数传递——引用传递 class Employee { private String name;
private double salary; Employee(String name,double income) { this.name=name; salary=income;} void raiseSalary(double d) salary=salary+d; } public String toString() return name+"的工资是:"+salary; public class TestReference { public static void Value(Employee e) e.raiseSalary(200); } public static void main(String args[]) Employee zhang=new Employee("张三” ,6000); Value(zhang); System.out.println(zhang.toString()); 黑板图示。

180 （7）类中的“变量”概念辨析： （1）成员变量： 在类体变量定义处定义的变量，在整个类内都有效；
成员变量包括实例变量和类变量，用static定义的变量是类变量，也叫静态变量； 所有对象独享实例变量，但共享类变量； 实例变量只能通过对象名访问，类变量既可以通过某个对象名也可以通过类名来访问。 （2）局部变量： 在类的方法中定义的变量，仅在定义它的方法内有效

181 （8）类中的“方法”概念辨析： （1）实例方法： （2）类方法： 实例方法既可以操作实例变量，也可以操作类变量；
实例方法在创建类对象后才分配入口地址； 实例方法可以被类创建的任何对象访问，必须通过对象来调用；实例方法可以调用其它方法（包括类方法）。 （2）类方法： 用static修饰的方法是类方法，也叫静态方法； 类方法只能操作类变量； 类方法在类被加载到内存后就分配了入口地址； 类方法可以被类创建的任何对象调用，也可以通过类名来调用，类方法只能调用该类的类方法。