类对象和接口

《类对象和接口》由会员分享，可在线阅读，更多相关《类对象和接口（93页珍藏版）》请在金锄头文库上搜索。

1、第四讲第四讲 类、对象和接口类、对象和接口第四讲第四讲 类、对象和接口类、对象和接口4.11 abstract 4.11 abstract 类和类和abstractabstract方法方法4.12 super4.12 super关键字关键字4.13 4.13 接口接口4.14 4.14 内部类内部类4.15 4.15 匿名类匿名类4.16 4.16 异常类异常类4.17 Class4.17 Class类类4.18 4.18 基本类型的类包装基本类型的类包装4.19 4.19 反编译和文档生成器反编译和文档生成器4.20 jar4.20 jar文件文件第四讲第四讲 类、对象和接口类、对象和接口

2、一、教学目的一、教学目的 理解类、对象和接口之间的关系，熟练掌理解类、对象和接口之间的关系，熟练掌握类的设计方法、对象的使用方法，接口的定握类的设计方法、对象的使用方法，接口的定义方法，熟练运用实例成员和类成员编写程序，义方法，熟练运用实例成员和类成员编写程序，了解包的基本使用方法。了解包的基本使用方法。二、教学内容：二、教学内容： 本章主要介绍类和对象之间的关系，握类本章主要介绍类和对象之间的关系，握类的设计方法、对象的使用方法，以及包的基本的设计方法、对象的使用方法，以及包的基本使用方法。使用方法。第四讲第四讲 类、对象和接口类、对象和接口三、重点及难点内容：三、重点及难点内容： 重点：重

3、点： 1、仔细体会面向对象编程的思想；、仔细体会面向对象编程的思想； 2、熟练理解类和对象的概念，理解面向、熟练理解类和对象的概念，理解面向对象的特性；对象的特性； 3、会编写简单的类，逐渐掌握面向对象、会编写简单的类，逐渐掌握面向对象编程的方法。编程的方法。四、难点：四、难点： 面向对象编程思想的建立。面向对象编程思想的建立。第四讲第四讲 类、对象和接口类、对象和接口四、课前思考四、课前思考 1、什么是对象？什么是类？、什么是对象？什么是类？ 2、 面向对象编程的特性有哪三个？它面向对象编程的特性有哪三个？它们各自又有哪些特性？们各自又有哪些特性？ 3、 你知道你知道java语言在面向对象编

4、程方面语言在面向对象编程方面有何独特的特点吗？有何独特的特点吗？4.1编程语言的几个发展阶段 1、机器语言（汇编语言）、机器语言（汇编语言） 计算机处理信息的早期语言是所谓的机器语言，计算机处理信息的早期语言是所谓的机器语言，计算机处理信息的早期语言是所谓的机器语言，计算机处理信息的早期语言是所谓的机器语言，这种语言中的指令都是由这种语言中的指令都是由这种语言中的指令都是由这种语言中的指令都是由0,10,1组成的序列，称这样组成的序列，称这样组成的序列，称这样组成的序列，称这样的序列为一条机器指令。的序列为一条机器指令。的序列为一条机器指令。的序列为一条机器指令。 2、过程语言（、过程语言（C

5、语言）语言） 面向过程语言把代码组成叫做过程或函数的块。面向过程语言把代码组成叫做过程或函数的块。面向过程语言把代码组成叫做过程或函数的块。面向过程语言把代码组成叫做过程或函数的块。每个块的目标是完成某个任务，例如，一个每个块的目标是完成某个任务，例如，一个每个块的目标是完成某个任务，例如，一个每个块的目标是完成某个任务，例如，一个C C的源的源的源的源程序就是由若干个书写形式互相独立的函数组成。程序就是由若干个书写形式互相独立的函数组成。程序就是由若干个书写形式互相独立的函数组成。程序就是由若干个书写形式互相独立的函数组成。 3、面向对象语言（、面向对象语言（JAVA, C+） 面向对象编程

6、更符合人的思维模式，主要体现面向对象编程更符合人的思维模式，主要体现面向对象编程更符合人的思维模式，主要体现面向对象编程更符合人的思维模式，主要体现在以下三个特性上。在以下三个特性上。在以下三个特性上。在以下三个特性上。4.1编程语言的几个发展阶段 1）封装性）封装性 封装是面向对象编程的核心思想之一，就是将数封装是面向对象编程的核心思想之一，就是将数封装是面向对象编程的核心思想之一，就是将数封装是面向对象编程的核心思想之一，就是将数据和对数据的操作封装在一起，也就是一个对象将自据和对数据的操作封装在一起，也就是一个对象将自据和对数据的操作封装在一起，也就是一个对象将自据和对数据的操作封装在一

7、起，也就是一个对象将自己的数据和对这些数据的操作合理有效地封装在一起。己的数据和对这些数据的操作合理有效地封装在一起。己的数据和对这些数据的操作合理有效地封装在一起。己的数据和对这些数据的操作合理有效地封装在一起。 封装将类的外部界面与类的功能实现区分开来，封装将类的外部界面与类的功能实现区分开来，封装将类的外部界面与类的功能实现区分开来，封装将类的外部界面与类的功能实现区分开来，隐藏实现细节，（通过公共方法）保留有限的对外接隐藏实现细节，（通过公共方法）保留有限的对外接隐藏实现细节，（通过公共方法）保留有限的对外接隐藏实现细节，（通过公共方法）保留有限的对外接口，迫使用户使用外部界面，通过访

8、问接口实现对数口，迫使用户使用外部界面，通过访问接口实现对数口，迫使用户使用外部界面，通过访问接口实现对数口，迫使用户使用外部界面，通过访问接口实现对数据的操作。即使实现细节发生了改变，也还可通过界据的操作。即使实现细节发生了改变，也还可通过界据的操作。即使实现细节发生了改变，也还可通过界据的操作。即使实现细节发生了改变，也还可通过界面承担其功能而保留原样，确保调用它的代码还继续面承担其功能而保留原样，确保调用它的代码还继续面承担其功能而保留原样，确保调用它的代码还继续面承担其功能而保留原样，确保调用它的代码还继续工作。这使代码维护更简单。工作。这使代码维护更简单。工作。这使代码维护更简单。工

9、作。这使代码维护更简单。 4.1编程语言的几个发展阶段 2）继承）继承 3）多态）多态 多态是面向对象编程的有一个重要特征。多态多态是面向对象编程的有一个重要特征。多态多态是面向对象编程的有一个重要特征。多态多态是面向对象编程的有一个重要特征。多态有两种含义：有两种含义：有两种含义：有两种含义： 一种是：操作名称的多态，即有多个操作具有一种是：操作名称的多态，即有多个操作具有一种是：操作名称的多态，即有多个操作具有一种是：操作名称的多态，即有多个操作具有相同的名字，但这些操作所接收的消息类型必须不相同的名字，但这些操作所接收的消息类型必须不相同的名字，但这些操作所接收的消息类型必须不相同的名字

10、，但这些操作所接收的消息类型必须不同（在同（在同（在同（在JAVAJAVA中体现在方法重载上）。中体现在方法重载上）。中体现在方法重载上）。中体现在方法重载上）。 另一种：是和继承有关的多态，是指同一个操另一种：是和继承有关的多态，是指同一个操另一种：是和继承有关的多态，是指同一个操另一种：是和继承有关的多态，是指同一个操作被不同类型对象调用时可能产生不同的行为。作被不同类型对象调用时可能产生不同的行为。作被不同类型对象调用时可能产生不同的行为。作被不同类型对象调用时可能产生不同的行为。 例如：狗和猫都喊叫，狗发出的是例如：狗和猫都喊叫，狗发出的是例如：狗和猫都喊叫，狗发出的是例如：狗和猫都喊

11、叫，狗发出的是“汪汪汪汪汪汪汪汪” 而猫是而猫是而猫是而猫是“喵喵喵喵喵喵喵喵” ” ” ” （在在在在JAVAJAVA中体现在覆盖上中体现在覆盖上中体现在覆盖上中体现在覆盖上）。）。）。）。4.2类 类是类是类是类是JavaJava的核心，也是类是组成的核心，也是类是组成的核心，也是类是组成的核心，也是类是组成JavaJava程序的基本程序的基本程序的基本程序的基本要素。类封装了一类对象的状态和方法。类是用来定要素。类封装了一类对象的状态和方法。类是用来定要素。类封装了一类对象的状态和方法。类是用来定要素。类封装了一类对象的状态和方法。类是用来定义对象的模板。类是对具有相同属性和方法的一组相

12、义对象的模板。类是对具有相同属性和方法的一组相义对象的模板。类是对具有相同属性和方法的一组相义对象的模板。类是对具有相同属性和方法的一组相似对象的抽象，或者说类是对象的模板。似对象的抽象，或者说类是对象的模板。似对象的抽象，或者说类是对象的模板。似对象的抽象，或者说类是对象的模板。 类的实现包括两部分类的实现包括两部分类的实现包括两部分类的实现包括两部分: :类声明和类体。类声明和类体。类声明和类体。类声明和类体。4.2类 1、类声明、类声明 类的声明格式如下：类的声明格式如下：类的声明格式如下：类的声明格式如下： 修饰符修饰符修饰符修饰符 class class extends extend

13、s 父类名父类名父类名父类名 implements implements 接口名接口名接口名接口名 类主体类主体类主体类主体 class People class People 4.2类 2、类体、类体 1 1）写类的目的是为了描述一类事物共有的属）写类的目的是为了描述一类事物共有的属）写类的目的是为了描述一类事物共有的属）写类的目的是为了描述一类事物共有的属性和功能，描述过程由类体来实现。类声明之后的性和功能，描述过程由类体来实现。类声明之后的性和功能，描述过程由类体来实现。类声明之后的性和功能，描述过程由类体来实现。类声明之后的一对大括号一对大括号一对大括号一对大括号“ “ ” ”，“ “

14、 ” ”以及它们之间的内容称做以及它们之间的内容称做以及它们之间的内容称做以及它们之间的内容称做类体，大括号之间的内容称做类体的内容。类体，大括号之间的内容称做类体的内容。类体，大括号之间的内容称做类体的内容。类体，大括号之间的内容称做类体的内容。 2 2）类体的内容由两部分构：一部分是）类体的内容由两部分构：一部分是）类体的内容由两部分构：一部分是）类体的内容由两部分构：一部分是变量的变量的变量的变量的定义定义定义定义，用来刻画属性；另一部分是方法的定义，用用来刻画属性；另一部分是方法的定义，用用来刻画属性；另一部分是方法的定义，用用来刻画属性；另一部分是方法的定义，用来刻画功能。来刻画功能

15、。来刻画功能。来刻画功能。4.2类 3 3）声明成员变量的格式为：）声明成员变量的格式为：）声明成员变量的格式为：）声明成员变量的格式为： 修饰符修饰符修饰符修饰符 声明成员方法的格式为：声明成员方法的格式为：声明成员方法的格式为：声明成员方法的格式为： ( ( 参数参数参数参数列表列表列表列表 ) throws ) throws 方法体方法体方法体方法体 4.2类class class 梯形梯形梯形梯形 float float 上底上底上底上底, ,下底下底下底下底, ,高高高高,laderArea; /,laderArea; /变量定义部分变量定义部分变量定义部分变量定义部分 float

16、float 计算面积计算面积计算面积计算面积() /() /方法定义方法定义方法定义方法定义 laderArea=( laderArea=(上底上底上底上底+下底下底下底下底)*)*高高高高/2.0f;/2.0f; return laderArea; return laderArea; void void 修改高修改高修改高修改高(float h) /(float h) /方法定义方法定义方法定义方法定义 高高高高=h;=h; 4.24.2类类 3、成员变量和局部变量、成员变量和局部变量 1 1）我们已经知道类体分为两部分。变量定义）我们已经知道类体分为两部分。变量定义）我们已经知道类体分为两

17、部分。变量定义）我们已经知道类体分为两部分。变量定义部分所定义的变量被称为类的成员变量。在方法部分所定义的变量被称为类的成员变量。在方法部分所定义的变量被称为类的成员变量。在方法部分所定义的变量被称为类的成员变量。在方法体中定义的变量和方法的参数被称为局部变量。体中定义的变量和方法的参数被称为局部变量。体中定义的变量和方法的参数被称为局部变量。体中定义的变量和方法的参数被称为局部变量。 2 2）成员变量在整个类内都有效，局部变量只）成员变量在整个类内都有效，局部变量只）成员变量在整个类内都有效，局部变量只）成员变量在整个类内都有效，局部变量只在定义它的方法内有效。在定义它的方法内有效。在定义它

18、的方法内有效。在定义它的方法内有效。 3 3）成员变量又分为实例成员变量（简称实例）成员变量又分为实例成员变量（简称实例）成员变量又分为实例成员变量（简称实例）成员变量又分为实例成员变量（简称实例变量）和类变量（也称静态变量）变量）和类变量（也称静态变量）变量）和类变量（也称静态变量）变量）和类变量（也称静态变量） 。如果成员变。如果成员变。如果成员变。如果成员变量的类型前面加上关键字量的类型前面加上关键字量的类型前面加上关键字量的类型前面加上关键字staticstatic，这样的成员变，这样的成员变，这样的成员变，这样的成员变量称做是类变量或静态变量。量称做是类变量或静态变量。量称做是类变量

19、或静态变量。量称做是类变量或静态变量。 4.24.2类类 4 4）如果局部变量的名字与成员变量的名字）如果局部变量的名字与成员变量的名字）如果局部变量的名字与成员变量的名字）如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，即这个成员变量在这相同，则成员变量被隐藏，即这个成员变量在这相同，则成员变量被隐藏，即这个成员变量在这相同，则成员变量被隐藏，即这个成员变量在这个方法内暂时失效个方法内暂时失效个方法内暂时失效个方法内暂时失效 。 5 5）如果局部变量的名字与成员变量的名字相）如果局部变量的名字与成员变量的名字相）如果局部变量的名字与成员变量的名字相）如果局部变量的名字与成员变量的名

20、字相同，则成员变量被隐藏。这时如果想在该方法内同，则成员变量被隐藏。这时如果想在该方法内同，则成员变量被隐藏。这时如果想在该方法内同，则成员变量被隐藏。这时如果想在该方法内使用成员变量，必须使用关键字使用成员变量，必须使用关键字使用成员变量，必须使用关键字使用成员变量，必须使用关键字thisthis。 4.24.2类类 4、方法、方法 方法的定义包括两部分：方法声明和方法体。方法的定义包括两部分：方法声明和方法体。方法的定义包括两部分：方法声明和方法体。方法的定义包括两部分：方法声明和方法体。一般格式为：一般格式为：一般格式为：一般格式为： 方法声明部分方法声明部分方法声明部分方法声明部分 方

21、法体内容方法体内容方法体内容方法体内容 1 1）方法声明）方法声明）方法声明）方法声明 最基本的方法声明包括方法名和方法类型。当最基本的方法声明包括方法名和方法类型。当最基本的方法声明包括方法名和方法类型。当最基本的方法声明包括方法名和方法类型。当方法不需要返回数据时，方法的类型必须是方法不需要返回数据时，方法的类型必须是方法不需要返回数据时，方法的类型必须是方法不需要返回数据时，方法的类型必须是voidvoid。4.24.2类类 2 2）方法体）方法体）方法体）方法体 方法声明之后的一对大括号以及之间的内容成方法声明之后的一对大括号以及之间的内容成方法声明之后的一对大括号以及之间的内容成方法

22、声明之后的一对大括号以及之间的内容成为方法的方法体。方法体的内容包括局部变量的定为方法的方法体。方法体的内容包括局部变量的定为方法的方法体。方法体的内容包括局部变量的定为方法的方法体。方法体的内容包括局部变量的定义和合法的义和合法的义和合法的义和合法的JavaJava语言。语言。语言。语言。 3 3）方法参数在整个方法内有效，方法内定义）方法参数在整个方法内有效，方法内定义）方法参数在整个方法内有效，方法内定义）方法参数在整个方法内有效，方法内定义的局部变量从它定义的位置之后开始有效。如果局的局部变量从它定义的位置之后开始有效。如果局的局部变量从它定义的位置之后开始有效。如果局的局部变量从它定

23、义的位置之后开始有效。如果局部变量的定义是在一个复合语句中，那么该局部变部变量的定义是在一个复合语句中，那么该局部变部变量的定义是在一个复合语句中，那么该局部变部变量的定义是在一个复合语句中，那么该局部变量的有效范围是该复合语句，即仅在该复合语句中量的有效范围是该复合语句，即仅在该复合语句中量的有效范围是该复合语句，即仅在该复合语句中量的有效范围是该复合语句，即仅在该复合语句中有效，如果局部变量的定义是在一个循环语句中，有效，如果局部变量的定义是在一个循环语句中，有效，如果局部变量的定义是在一个循环语句中，有效，如果局部变量的定义是在一个循环语句中，那么该局部变量的有效范围是该循环语句，即仅在

24、那么该局部变量的有效范围是该循环语句，即仅在那么该局部变量的有效范围是该循环语句，即仅在那么该局部变量的有效范围是该循环语句，即仅在该循环语句中有效该循环语句中有效该循环语句中有效该循环语句中有效 。4.24.2类类 5、方法重载、方法重载 方法重载的意思是：一个类中可以有多个方法具方法重载的意思是：一个类中可以有多个方法具方法重载的意思是：一个类中可以有多个方法具方法重载的意思是：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者有相同的名字，但这些方法的参数必须不同，即或者有相同的名字，但这些方法的参数必须不同，即或者有相同的名字，但这些方法的参数必须不同，即或者是参数

25、的个数不同，或者是参数的类型不同。重载是是参数的个数不同，或者是参数的类型不同。重载是是参数的个数不同，或者是参数的类型不同。重载是是参数的个数不同，或者是参数的类型不同。重载是Java Java 实现多态性的一种方式。实现多态性的一种方式。实现多态性的一种方式。实现多态性的一种方式。 有两个规则适用于重载方法：有两个规则适用于重载方法：有两个规则适用于重载方法：有两个规则适用于重载方法： 调用语句的参数表必须有足够的不同，以至调用语句的参数表必须有足够的不同，以至调用语句的参数表必须有足够的不同，以至调用语句的参数表必须有足够的不同，以至于允许区分出正确的方法被调用。于允许区分出正确的方法被

26、调用。于允许区分出正确的方法被调用。于允许区分出正确的方法被调用。 方法的返回类型可以各不相同，但它不足以方法的返回类型可以各不相同，但它不足以方法的返回类型可以各不相同，但它不足以方法的返回类型可以各不相同，但它不足以使返回类型变成唯一的差异。使返回类型变成唯一的差异。使返回类型变成唯一的差异。使返回类型变成唯一的差异。重载方法的参数表必须重载方法的参数表必须重载方法的参数表必须重载方法的参数表必须不同。不同。不同。不同。class Areaclass Area float getArea(float r) float getArea(float r) return 3.14f*r*r; r

27、eturn 3.14f*r*r; double getArea(float x,int y) double getArea(float x,int y) return x*y; return x*y; float getArea(int x,float y) float getArea(int x,float y) return x*y; return x*y; double getArea(float x,float y,float z) double getArea(float x,float y,float z) return (x*x+y*y+z*z)*2.0; return (x*x

28、+y*y+z*z)*2.0; 4.24.2类类 6、构造方法、构造方法 1）构造方法是一种特殊方法，用来对对象进）构造方法是一种特殊方法，用来对对象进行初始化。行初始化。 2 ）它的名字必须与它所在的类的名字完全相）它的名字必须与它所在的类的名字完全相同，而且没有类型，甚至连表示无返回值的空类型同，而且没有类型，甚至连表示无返回值的空类型（void）也没有）也没有 。构造方法一般应定义为。构造方法一般应定义为public构造方法也可以重载构造方法也可以重载 3 ）一般而言，每个类都至少有一个构造函数。）一般而言，每个类都至少有一个构造函数。如果程序员没有为类定义构造函数，如果程序员没有为类定义

29、构造函数，Java虚拟机虚拟机会自动为该类生成一个默认的构造函数。会自动为该类生成一个默认的构造函数。 4）要特别注意的是，如果程序员定义了一个）要特别注意的是，如果程序员定义了一个或多个构造函数，则自动屏蔽掉默认的构造函数。或多个构造函数，则自动屏蔽掉默认的构造函数。（详见例程）（详见例程） 5)构造方法重载示例构造方法重载示例 public class Employee public class Employee private String name; private String name; private int salary; private int salary; public

30、Employee(String n, int s) public Employee(String n, int s) name = n; name = n; salary = s;salary = s; public Employee(String n)public Employee(String n) this(n, 0);this(n, 0); public Employee()public Employee() this( Unknown ); this( Unknown ); 4.24.2类类 7 7、类方法和实例方法说明：、类方法和实例方法说明： 1 1）类中的方法分为实例方法和类方

31、法。）类中的方法分为实例方法和类方法。 2 2）方法声明时，方法类型前面不加关键字）方法声明时，方法类型前面不加关键字staticstatic的是实例方法、加关键字的是实例方法、加关键字staticstatic的是类方法。的是类方法。 3 3）构造方法是特殊的方法，不能用）构造方法是特殊的方法，不能用staticstatic修修饰构造方法。饰构造方法。 4 4）实例方法既能对类变量操作也能对实例变）实例方法既能对类变量操作也能对实例变量操作，而类方法只能对类变量进行操作。量操作，而类方法只能对类变量进行操作。 5 5）一个类中的方法可以互相调用，实例方法）一个类中的方法可以互相调用，实例方法可

32、以调用该类中的其他方法；类方法只能调用类方可以调用该类中的其他方法；类方法只能调用类方法，不能调用实例方法。法，不能调用实例方法。4.34.3对象对象 类是创建对象的模板。当使用一个类创建了一个类是创建对象的模板。当使用一个类创建了一个类是创建对象的模板。当使用一个类创建了一个类是创建对象的模板。当使用一个类创建了一个对象时，我们也说我们给出了这个类的一个实例。对象时，我们也说我们给出了这个类的一个实例。对象时，我们也说我们给出了这个类的一个实例。对象时，我们也说我们给出了这个类的一个实例。 1、创建对象、创建对象 创建一个对象包括对象的声明和为对象分配内存创建一个对象包括对象的声明和为对象分

33、配内存创建一个对象包括对象的声明和为对象分配内存创建一个对象包括对象的声明和为对象分配内存两个步骤。两个步骤。两个步骤。两个步骤。 (1)(1)对象的声明。对象的声明。对象的声明。对象的声明。 一般格式为：一般格式为：一般格式为：一般格式为： 类的名字类的名字类的名字类的名字 对象名字对象名字对象名字对象名字; ; 如：如：如：如： People zhangPing;People zhangPing;4.34.3对象对象 (2)为声明的对象分配内存为声明的对象分配内存 使用使用new运算符和类的构造方法为声明的运算符和类的构造方法为声明的对象分配内存，如果类中没有构造方法，系统对象分配内存，如

34、果类中没有构造方法，系统会调用默认的构造方法（默认的构造方法是无会调用默认的构造方法（默认的构造方法是无参数的）。如：参数的）。如： zhangPing=new People(); (3)对象的内存模型对象的内存模型 见下例见下例: class XiyoujiRenwu class XiyoujiRenwu float height,weight; float height,weight; String head, ear,hand,foot, mouth; String head, ear,hand,foot, mouth; void speak(String s) void speak(S

35、tring s) System.out.println(s); System.out.println(s); class A class A public static void main(String args) public static void main(String args) XiyoujiRenwu zhubajie; / XiyoujiRenwu zhubajie; /声明对象声明对象声明对象声明对象 zhubajie=new XiyoujiRenwu(); /zhubajie=new XiyoujiRenwu(); /为对象分为对象分为对象分为对象分/配内存配内存配内存配内存

36、 ，使用，使用，使用，使用new new 运运运运 算算算算 符和默认的构造方法符和默认的构造方法符和默认的构造方法符和默认的构造方法 4.34.3对象对象 当用当用XiyoujiRenwu类声明一个变量，类声明一个变量，即对象即对象zhubajie时，对象时的内存模型如时，对象时的内存模型如下：下：XiyoujiRenwu zhubajie;XiyoujiRenwu zhubajie;4.3对象 当系统见到：当系统见到：zhubajie=new XiyoujiRenwu(); 时，就会做两件事：时，就会做两件事： 为为height，weight，head，ear，mouth，hand，foo

37、t各个变量分配内存，各个变量分配内存，即即XiyoujiRenwu类的成员变量被分配内存类的成员变量被分配内存空间，然后执行构造方法中的语句。空间，然后执行构造方法中的语句。 new运算符在为变量运算符在为变量height，weight，head，ear，mouth，hand，foot分配内存后，将返回一个引用给对象变分配内存后，将返回一个引用给对象变量量zhubajie（分配实体后的内存模型如下：）。（分配实体后的内存模型如下：）。（分配实体后的内存模型如下：）。（分配实体后的内存模型如下：）。4.3对象4.34.3对象对象 2、对象的使用、对象的使用 1 1）对象不仅可以操作自己的变量改变

38、状态，而）对象不仅可以操作自己的变量改变状态，而）对象不仅可以操作自己的变量改变状态，而）对象不仅可以操作自己的变量改变状态，而且还拥有了使用创建它的那个类中的方法的能力，对且还拥有了使用创建它的那个类中的方法的能力，对且还拥有了使用创建它的那个类中的方法的能力，对且还拥有了使用创建它的那个类中的方法的能力，对象通过使用这些方法可以产生一定的行为。象通过使用这些方法可以产生一定的行为。象通过使用这些方法可以产生一定的行为。象通过使用这些方法可以产生一定的行为。 2 2）通过使用运算符）通过使用运算符）通过使用运算符）通过使用运算符“ “. .” ”，对象可以实现对自己，对象可以实现对自己，对象

39、可以实现对自己，对象可以实现对自己的变量访问和方法的调用。的变量访问和方法的调用。的变量访问和方法的调用。的变量访问和方法的调用。 3 3）当对象调用方法时，方法中出现的成员变量）当对象调用方法时，方法中出现的成员变量）当对象调用方法时，方法中出现的成员变量）当对象调用方法时，方法中出现的成员变量就是指该对象的成员变量（见例就是指该对象的成员变量（见例就是指该对象的成员变量（见例就是指该对象的成员变量（见例4.34.3）。）。）。）。 对象名成员变量名对象名成员变量名对象名成员变量名对象名成员变量名 对象名成员方法名（对象名成员方法名（对象名成员方法名（对象名成员方法名（ ）4.34.3对象对

40、象 3、对象的引用和实体、对象的引用和实体 1 1）当用类创建一个对象时，类中的成员变量）当用类创建一个对象时，类中的成员变量）当用类创建一个对象时，类中的成员变量）当用类创建一个对象时，类中的成员变量被分配内存空间，这些内存空间称做该对象的实体，被分配内存空间，这些内存空间称做该对象的实体，被分配内存空间，这些内存空间称做该对象的实体，被分配内存空间，这些内存空间称做该对象的实体，而对象中存放着引用，以确保实体由该对象操作使而对象中存放着引用，以确保实体由该对象操作使而对象中存放着引用，以确保实体由该对象操作使而对象中存放着引用，以确保实体由该对象操作使用。用。用。用。 2 2）一个类创建的

41、两个对象，如果具有相同的）一个类创建的两个对象，如果具有相同的）一个类创建的两个对象，如果具有相同的）一个类创建的两个对象，如果具有相同的引用，那么就具有完全相同的实体。引用，那么就具有完全相同的实体。引用，那么就具有完全相同的实体。引用，那么就具有完全相同的实体。 3 3）没有实体的对象称作空对象，空对象不能）没有实体的对象称作空对象，空对象不能）没有实体的对象称作空对象，空对象不能）没有实体的对象称作空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为。使用，即不能让一个空对象去调用方法产生行为。使用，即不能让一个空对象去调用方法产生行为。使用，即不能让一个空对象去调用方法产生行为

42、。4.34.3对象对象4.34.3对象对象4.34.3对象对象 4、参数传值、参数传值 在在在在JavaJavaJavaJava语言中，向方法传递参数的方式是语言中，向方法传递参数的方式是语言中，向方法传递参数的方式是语言中，向方法传递参数的方式是“按按按按值传递值传递值传递值传递”。按值传递意味着当将一个参数传递给一。按值传递意味着当将一个参数传递给一。按值传递意味着当将一个参数传递给一。按值传递意味着当将一个参数传递给一个方法时，首先创建了源参数的一个副本并将这个个方法时，首先创建了源参数的一个副本并将这个个方法时，首先创建了源参数的一个副本并将这个个方法时，首先创建了源参数的一个副本并将

43、这个副本传入了方法，这样方法接收的是原始值的一个副本传入了方法，这样方法接收的是原始值的一个副本传入了方法，这样方法接收的是原始值的一个副本传入了方法，这样方法接收的是原始值的一个副本。因此，即使在方法中修改了该参数，那仅仅副本。因此，即使在方法中修改了该参数，那仅仅副本。因此，即使在方法中修改了该参数，那仅仅副本。因此，即使在方法中修改了该参数，那仅仅是改变副本，而源参数值保持不变。是改变副本，而源参数值保持不变。是改变副本，而源参数值保持不变。是改变副本，而源参数值保持不变。 1 1 1 1）基本数据类型参数的传值）基本数据类型参数的传值）基本数据类型参数的传值）基本数据类型参数的传值 对

44、于基本数据类型的参数，向该参数传递的值对于基本数据类型的参数，向该参数传递的值对于基本数据类型的参数，向该参数传递的值对于基本数据类型的参数，向该参数传递的值的级别不可以高于该参数的级别，比如，不可以向的级别不可以高于该参数的级别，比如，不可以向的级别不可以高于该参数的级别，比如，不可以向的级别不可以高于该参数的级别，比如，不可以向intintintint型参数传递一个型参数传递一个型参数传递一个型参数传递一个floatfloatfloatfloat值，但可以向值，但可以向值，但可以向值，但可以向doubledoubledoubledouble型参型参型参型参数传递一个数传递一个数传递一个数传

45、递一个floatfloatfloatfloat值。值。值。值。4.34.3对象对象 2）引用类型参数的传值）引用类型参数的传值 JavaJava的引用型数据包括对象、数组和接口。当的引用型数据包括对象、数组和接口。当的引用型数据包括对象、数组和接口。当的引用型数据包括对象、数组和接口。当参数是引用类型时，参数是引用类型时，参数是引用类型时，参数是引用类型时，“ “传值传值传值传值” ”传递的是变量的引用而传递的是变量的引用而传递的是变量的引用而传递的是变量的引用而不是变量所引用的实体。不是变量所引用的实体。不是变量所引用的实体。不是变量所引用的实体。 当使用对象实例作为参数传递给方法时，参数的

46、当使用对象实例作为参数传递给方法时，参数的当使用对象实例作为参数传递给方法时，参数的当使用对象实例作为参数传递给方法时，参数的值是对对象的引用。也就是说，传递给到方法内部的值是对对象的引用。也就是说，传递给到方法内部的值是对对象的引用。也就是说，传递给到方法内部的值是对对象的引用。也就是说，传递给到方法内部的是对象的引用值而不是对象的内容。是对象的引用值而不是对象的内容。是对象的引用值而不是对象的内容。是对象的引用值而不是对象的内容。 在方法内这个引用值不会被改变。但如果通过该在方法内这个引用值不会被改变。但如果通过该在方法内这个引用值不会被改变。但如果通过该在方法内这个引用值不会被改变。但如

47、果通过该引用值修改了所指向的对象的内容，则方法结束后，引用值修改了所指向的对象的内容，则方法结束后，引用值修改了所指向的对象的内容，则方法结束后，引用值修改了所指向的对象的内容，则方法结束后，所修改的对象内容可以保留下来。（详见例程和课本所修改的对象内容可以保留下来。（详见例程和课本所修改的对象内容可以保留下来。（详见例程和课本所修改的对象内容可以保留下来。（详见例程和课本例例例例4.54.5）4.4 static4.4 static关键字关键字 在一个类中，使用在一个类中，使用在一个类中，使用在一个类中，使用staticstatic修饰的变量和方法分修饰的变量和方法分修饰的变量和方法分修饰的

48、变量和方法分别称为别称为别称为别称为类变量类变量类变量类变量（或称静态变量）和（或称静态变量）和（或称静态变量）和（或称静态变量）和类方法类方法类方法类方法（或称静（或称静（或称静（或称静态方法），没有使用态方法），没有使用态方法），没有使用态方法），没有使用staticstatic修饰的变量和方法分别修饰的变量和方法分别修饰的变量和方法分别修饰的变量和方法分别称为实例变量和实例方法。称为实例变量和实例方法。称为实例变量和实例方法。称为实例变量和实例方法。 1、实例变量和类变量的区别、实例变量和类变量的区别 一个类通过使用一个类通过使用一个类通过使用一个类通过使用newnew运算符可以创建多个

49、不同运算符可以创建多个不同运算符可以创建多个不同运算符可以创建多个不同的对象，不同的对象的实例变量将被分配不同的内的对象，不同的对象的实例变量将被分配不同的内的对象，不同的对象的实例变量将被分配不同的内的对象，不同的对象的实例变量将被分配不同的内存空间，如果类中的成员变量有类变量，那么所有存空间，如果类中的成员变量有类变量，那么所有存空间，如果类中的成员变量有类变量，那么所有存空间，如果类中的成员变量有类变量，那么所有的对象的这个类变量都分配给相同的一处内存，改的对象的这个类变量都分配给相同的一处内存，改的对象的这个类变量都分配给相同的一处内存，改的对象的这个类变量都分配给相同的一处内存，改变

50、其中一个对象的这个类变量会影响其它对象的这变其中一个对象的这个类变量会影响其它对象的这变其中一个对象的这个类变量会影响其它对象的这变其中一个对象的这个类变量会影响其它对象的这个类变量。个类变量。个类变量。个类变量。 4.4 static4.4 static关键字关键字 类变量是和该类创建的所有对象相关联的变量，类变量是和该类创建的所有对象相关联的变量，类变量是和该类创建的所有对象相关联的变量，类变量是和该类创建的所有对象相关联的变量，改变其中一个对象的这个类变量就同时改变了其它改变其中一个对象的这个类变量就同时改变了其它改变其中一个对象的这个类变量就同时改变了其它改变其中一个对象的这个类变量就

51、同时改变了其它对象的这个类变量。因此，类变量不仅可以通过某对象的这个类变量。因此，类变量不仅可以通过某对象的这个类变量。因此，类变量不仅可以通过某对象的这个类变量。因此，类变量不仅可以通过某个对象访问也可以直接通过类名访问。实例变量仅个对象访问也可以直接通过类名访问。实例变量仅个对象访问也可以直接通过类名访问。实例变量仅个对象访问也可以直接通过类名访问。实例变量仅仅是和相应的对象关联的变量，也就是说，不同对仅是和相应的对象关联的变量，也就是说，不同对仅是和相应的对象关联的变量，也就是说，不同对仅是和相应的对象关联的变量，也就是说，不同对象的实例变量互不相同，即分配不同的内存空间，象的实例变量互

52、不相同，即分配不同的内存空间，象的实例变量互不相同，即分配不同的内存空间，象的实例变量互不相同，即分配不同的内存空间，改变其中一个对象的实例变量不会影响其它对象的改变其中一个对象的实例变量不会影响其它对象的改变其中一个对象的实例变量不会影响其它对象的改变其中一个对象的实例变量不会影响其它对象的这个实例变量。实例变量可以通过对象访问，不能这个实例变量。实例变量可以通过对象访问，不能这个实例变量。实例变量可以通过对象访问，不能这个实例变量。实例变量可以通过对象访问，不能使用类名访问。使用类名访问。使用类名访问。使用类名访问。 4.4 static4.4 static关键字关键字 、实例方法和类方法

53、的区别、实例方法和类方法的区别 实例方法可以被类创建的任何对象调用执实例方法可以被类创建的任何对象调用执行。而类方法不仅可以被类创建的任何对象调行。而类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。用执行，也可以直接通过类名调用。 总结：总结： 1 1、类成员属于这个类而不是属于这个类的、类成员属于这个类而不是属于这个类的某个对象。某个对象。4.4 static4.4 static关键字关键字 2、对于类成员，既可以使用对象进行访问，、对于类成员，既可以使用对象进行访问，也可以使用类名直接进行访问，并且在也可以使用类名直接进行访问，并且在类方法类方法中只中只能访问能访问类成员

54、类成员，而不能访问实例成员。，而不能访问实例成员。 3、实例成员由每一个对象个体独有，对象的、实例成员由每一个对象个体独有，对象的存储空间中的确有一块空间用来存储该成员。对于存储空间中的确有一块空间用来存储该成员。对于实例成员，只能通过对象来访问，不能通过类名进实例成员，只能通过对象来访问，不能通过类名进行访问。行访问。 4、在实例方法中，既可以访问实例成员，也、在实例方法中，既可以访问实例成员，也可以访问类成员。可以访问类成员。4.5 this4.5 this关键字关键字 有关有关this的几点描述：的几点描述： 1）this是是Java的一个关键字，表示某个对象。的一个关键字，表示某个对象

55、。 2）this可以出现在实例方法和构造方法中，但可以出现在实例方法和构造方法中，但不可以出现在类方法中。不可以出现在类方法中。 3）this关键字出现在类的构造方法中时，代表关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。使用该构造方法所创建的对象。 4）this关键字出现在类的实例方法中时，代表关键字出现在类的实例方法中时，代表正在调用该方法的当前对象。正在调用该方法的当前对象。4.5 this4.5 this关键字关键字 5 5）需要注意的是，当一个变量被声明为）需要注意的是，当一个变量被声明为）需要注意的是，当一个变量被声明为）需要注意的是，当一个变量被声明为static

56、static时，是不能用时，是不能用时，是不能用时，是不能用thisthis来指向的，因为来指向的，因为来指向的，因为来指向的，因为thisthis指向指向指向指向某一具体对象，不能用来指示类本身。某一具体对象，不能用来指示类本身。某一具体对象，不能用来指示类本身。某一具体对象，不能用来指示类本身。 6 6）thisthis还可以用在某个构造函数的第一句，还可以用在某个构造函数的第一句，还可以用在某个构造函数的第一句，还可以用在某个构造函数的第一句，用来调用该类的另一个构造函数用来调用该类的另一个构造函数用来调用该类的另一个构造函数用来调用该类的另一个构造函数 。4.6 4.6 包包 1 1

57、1 1、 包语句包语句包语句包语句 1 1 1 1）包的概念）包的概念）包的概念）包的概念 包：是包：是包：是包：是JavaJavaJavaJava提供的文件组织方式。提供的文件组织方式。提供的文件组织方式。提供的文件组织方式。 为了便于管理大型软件系统中数目众多的类，为了便于管理大型软件系统中数目众多的类，为了便于管理大型软件系统中数目众多的类，为了便于管理大型软件系统中数目众多的类，解决类命名冲突的问题，解决类命名冲突的问题，解决类命名冲突的问题，解决类命名冲突的问题，JavaJavaJavaJava引入了包引入了包引入了包引入了包（packagepackagepackagepackage

58、）。一个包中可以包括很多类文件，包）。一个包中可以包括很多类文件，包）。一个包中可以包括很多类文件，包）。一个包中可以包括很多类文件，包中还可以有子包，形成包等级。使用包不仅方便中还可以有子包，形成包等级。使用包不仅方便中还可以有子包，形成包等级。使用包不仅方便中还可以有子包，形成包等级。使用包不仅方便了类文件的管理，而且扩大了了类文件的管理，而且扩大了了类文件的管理，而且扩大了了类文件的管理，而且扩大了JavaJavaJavaJava命名空间。命名空间。命名空间。命名空间。4.6 4.6 包包 2 2）包的创建）包的创建 创建包的语法格式为：创建包的语法格式为： Package Packag

59、e ; ; 例如：例如：package myPackage; package myPackage; 也可以创建包的层次。也可以创建包的层次。 例如：例如：package myPackage.secondPackage;package myPackage.secondPackage;4.6 4.6 包包 3）package语句的进一步说明语句的进一步说明 (1)package(1)package语句必须是文件中的第一条语语句必须是文件中的第一条语语句必须是文件中的第一条语语句必须是文件中的第一条语句。也就是说，在句。也就是说，在句。也就是说，在句。也就是说，在packagepackage语句之前

60、，除了空白语句之前，除了空白语句之前，除了空白语句之前，除了空白和注释之外不能有任何语句。和注释之外不能有任何语句。和注释之外不能有任何语句。和注释之外不能有任何语句。 (2)(2)如果不加如果不加如果不加如果不加packagepackage语句，则指定为缺省语句，则指定为缺省语句，则指定为缺省语句，则指定为缺省包或无名包。包或无名包。包或无名包。包或无名包。 (3)(3)包对应着文件系统的目录层次结构。包对应着文件系统的目录层次结构。包对应着文件系统的目录层次结构。包对应着文件系统的目录层次结构。 (4)(4)在在在在packagepackage语句中，用语句中，用语句中，用语句中，用“ “

61、. .” ”来指明包来指明包来指明包来指明包（目录）的层次。（目录）的层次。（目录）的层次。（目录）的层次。4.6 4.6 包包例：例：package myPackage;public class HelloWorldpublic static void main(String args)System.out.print(Hello World!);4.6 4.6 包包 2、import语句语句 在编写源文件时，除了自己编写类外，我们经常在编写源文件时，除了自己编写类外，我们经常在编写源文件时，除了自己编写类外，我们经常在编写源文件时，除了自己编写类外，我们经常需要使用需要使用需要使用需要使用

62、JavaJava提供的许多类，这些类可能在不同的包提供的许多类，这些类可能在不同的包提供的许多类，这些类可能在不同的包提供的许多类，这些类可能在不同的包中，而使用中，而使用中，而使用中，而使用import import 语句可以引入包中的类。语句可以引入包中的类。语句可以引入包中的类。语句可以引入包中的类。 import import 语句的使用方式如下：语句的使用方式如下：语句的使用方式如下：语句的使用方式如下： 1 1）引入包中的类。）引入包中的类。）引入包中的类。）引入包中的类。 import java.io.File;import java.io.File; 2 2）引入整个包。）引入

63、整个包。）引入整个包。）引入整个包。 import java.io.*;import java.io.*; 3 3）在同一包中的类可以互相引用，无需）在同一包中的类可以互相引用，无需）在同一包中的类可以互相引用，无需）在同一包中的类可以互相引用，无需importimport语句。语句。语句。语句。 4.74.7访问权限访问权限 1、访问控制修饰符简介、访问控制修饰符简介 访问控制修饰符说明类或类的成员的可访问范访问控制修饰符说明类或类的成员的可访问范访问控制修饰符说明类或类的成员的可访问范访问控制修饰符说明类或类的成员的可访问范围。围。围。围。 1 1）publicpublic 用用用用pub

64、licpublic修饰的类或成员拥有公共作用域，表修饰的类或成员拥有公共作用域，表修饰的类或成员拥有公共作用域，表修饰的类或成员拥有公共作用域，表明此类或类的成员可以被任何明此类或类的成员可以被任何明此类或类的成员可以被任何明此类或类的成员可以被任何JavaJava中的类所访问，中的类所访问，中的类所访问，中的类所访问，是最广泛的作用范围。是最广泛的作用范围。是最广泛的作用范围。是最广泛的作用范围。 2 2）protectedprotected 用用用用protectedprotected修饰的变量或方法拥有受保护作修饰的变量或方法拥有受保护作修饰的变量或方法拥有受保护作修饰的变量或方法拥有受

65、保护作用域，可以被同一个包中所有的类及其他包中该类用域，可以被同一个包中所有的类及其他包中该类用域，可以被同一个包中所有的类及其他包中该类用域，可以被同一个包中所有的类及其他包中该类的子类所访问。的子类所访问。的子类所访问。的子类所访问。4.74.7访问权限访问权限 3 3）privateprivate 用用用用privateprivate修饰的变量或方法拥有私有作用域，修饰的变量或方法拥有私有作用域，修饰的变量或方法拥有私有作用域，修饰的变量或方法拥有私有作用域，只能在此类中访问，在其他类中，包括该类的子只能在此类中访问，在其他类中，包括该类的子只能在此类中访问，在其他类中，包括该类的子只能

66、在此类中访问，在其他类中，包括该类的子类中也是不允许访问的，类中也是不允许访问的，类中也是不允许访问的，类中也是不允许访问的，privateprivate是最保守的作用是最保守的作用是最保守的作用是最保守的作用范围。范围。范围。范围。 4 4）friendlyfriendly（默认）（默认）（默认）（默认） 没有使用任何修饰符的，拥有默认访问权限没有使用任何修饰符的，拥有默认访问权限没有使用任何修饰符的，拥有默认访问权限没有使用任何修饰符的，拥有默认访问权限（也称友好访问权限），表明此类或类的成员可（也称友好访问权限），表明此类或类的成员可（也称友好访问权限），表明此类或类的成员可（也称友好访

67、问权限），表明此类或类的成员可以被同一个包中的其它类访问。以被同一个包中的其它类访问。以被同一个包中的其它类访问。以被同一个包中的其它类访问。4.74.7访问权限访问权限 2、私有变量和私有方法、私有变量和私有方法 一个类在另外一个类中创建一个对象后，该一个类在另外一个类中创建一个对象后，该一个类在另外一个类中创建一个对象后，该一个类在另外一个类中创建一个对象后，该对象不能访问自己的私有变量和私有方法对象不能访问自己的私有变量和私有方法对象不能访问自己的私有变量和私有方法对象不能访问自己的私有变量和私有方法 对于一个类的私有类变量（静态成员变量），对于一个类的私有类变量（静态成员变量），对于一

68、个类的私有类变量（静态成员变量），对于一个类的私有类变量（静态成员变量），那么在另外一个类中，也不能通过类名来操作这那么在另外一个类中，也不能通过类名来操作这那么在另外一个类中，也不能通过类名来操作这那么在另外一个类中，也不能通过类名来操作这个私有类变量。个私有类变量。个私有类变量。个私有类变量。 对于私有成员变量或方法，只有在本类中创对于私有成员变量或方法，只有在本类中创对于私有成员变量或方法，只有在本类中创对于私有成员变量或方法，只有在本类中创建该类的对象时，这个对象才能访问自己的私有建该类的对象时，这个对象才能访问自己的私有建该类的对象时，这个对象才能访问自己的私有建该类的对象时，这个对

69、象才能访问自己的私有成员变量和类的私有方法。成员变量和类的私有方法。成员变量和类的私有方法。成员变量和类的私有方法。4.74.7访问权限访问权限 3、共（公）有变量和共（公）有方法、共（公）有变量和共（公）有方法 一个类在另外一个类中创建一个对象后，该一个类在另外一个类中创建一个对象后，该一个类在另外一个类中创建一个对象后，该一个类在另外一个类中创建一个对象后，该对象能访问自己的对象能访问自己的对象能访问自己的对象能访问自己的publicpublic变量和变量和变量和变量和publicpublic方法。方法。方法。方法。 对于一个类的对于一个类的对于一个类的对于一个类的publicpublic

70、类变量（静态成员变量）类变量（静态成员变量）类变量（静态成员变量）类变量（静态成员变量），那么在另外一个类中，也能通过类名来操作这，那么在另外一个类中，也能通过类名来操作这，那么在另外一个类中，也能通过类名来操作这，那么在另外一个类中，也能通过类名来操作这个个个个publicpublic类变量。类变量。类变量。类变量。 4.74.7访问权限访问权限 4、友好变量和友好方法友好变量和友好方法 不用不用不用不用privateprivate、public public 、protectedprotected修饰符的修饰符的修饰符的修饰符的成员变量和方法被称为友好变量和友好方法。成员变量和方法被称为友

71、好变量和友好方法。成员变量和方法被称为友好变量和友好方法。成员变量和方法被称为友好变量和友好方法。 一个类在另外一个类中创建一个对象后，如果一个类在另外一个类中创建一个对象后，如果一个类在另外一个类中创建一个对象后，如果一个类在另外一个类中创建一个对象后，如果两个类在同一包中，该对象能访问自己的友好变量两个类在同一包中，该对象能访问自己的友好变量两个类在同一包中，该对象能访问自己的友好变量两个类在同一包中，该对象能访问自己的友好变量和友好方法。和友好方法。和友好方法。和友好方法。 对于一个类的友好类变量（静态成员变量），对于一个类的友好类变量（静态成员变量），对于一个类的友好类变量（静态成员变

72、量），对于一个类的友好类变量（静态成员变量），如果两个类在同一包中，那么在另外一个类中，也如果两个类在同一包中，那么在另外一个类中，也如果两个类在同一包中，那么在另外一个类中，也如果两个类在同一包中，那么在另外一个类中，也能通过类名来操作这个友好类变量。能通过类名来操作这个友好类变量。能通过类名来操作这个友好类变量。能通过类名来操作这个友好类变量。4.74.7访问权限访问权限 5、受保护的成员变量和方法、受保护的成员变量和方法 一个类在另外一个类中创建一个对象后，如一个类在另外一个类中创建一个对象后，如一个类在另外一个类中创建一个对象后，如一个类在另外一个类中创建一个对象后，如果两个类在同一包

73、中，该对象能访问自己的果两个类在同一包中，该对象能访问自己的果两个类在同一包中，该对象能访问自己的果两个类在同一包中，该对象能访问自己的protectedprotected变量和变量和变量和变量和protectedprotected方法。方法。方法。方法。 对于一个类的对于一个类的对于一个类的对于一个类的protectedprotected类变量（静态成员变类变量（静态成员变类变量（静态成员变类变量（静态成员变量），如果两个类在同一包中，那么在另外一个量），如果两个类在同一包中，那么在另外一个量），如果两个类在同一包中，那么在另外一个量），如果两个类在同一包中，那么在另外一个类中，也能通过类名

74、来操作这个类中，也能通过类名来操作这个类中，也能通过类名来操作这个类中，也能通过类名来操作这个protectedprotected类变类变类变类变量。量。量。量。4.84.8类的继承类的继承 继承：是存在于面向对象程序中的两个类继承：是存在于面向对象程序中的两个类之间的一种关系。当一个类之间的一种关系。当一个类A能够获取另一个能够获取另一个类类B中所有非私有的数据和操作的定义作为自中所有非私有的数据和操作的定义作为自己的部分或全部成分时，就称这两个类之间具己的部分或全部成分时，就称这两个类之间具有继承关系。被继承的类有继承关系。被继承的类B称为父类或超类，称为父类或超类，继承了父类或超类的数据

75、和操作的类继承了父类或超类的数据和操作的类A称为子称为子类。类。4.84.8类的继承类的继承 一个父类可以同时拥有多个子类，这时这个父一个父类可以同时拥有多个子类，这时这个父一个父类可以同时拥有多个子类，这时这个父一个父类可以同时拥有多个子类，这时这个父类实际上是所有子类的公共域和公共方法的集合，类实际上是所有子类的公共域和公共方法的集合，类实际上是所有子类的公共域和公共方法的集合，类实际上是所有子类的公共域和公共方法的集合，而每一子类则是父类的特殊化，是在父类的基础之而每一子类则是父类的特殊化，是在父类的基础之而每一子类则是父类的特殊化，是在父类的基础之而每一子类则是父类的特殊化，是在父类的

76、基础之上对公共域和方法在功能、内涵方面的扩展和延伸。上对公共域和方法在功能、内涵方面的扩展和延伸。上对公共域和方法在功能、内涵方面的扩展和延伸。上对公共域和方法在功能、内涵方面的扩展和延伸。 使用继承具有以下的好处：降低代码编写中的使用继承具有以下的好处：降低代码编写中的使用继承具有以下的好处：降低代码编写中的使用继承具有以下的好处：降低代码编写中的冗余度，更好地实现了代码复用的功能，提高程序冗余度，更好地实现了代码复用的功能，提高程序冗余度，更好地实现了代码复用的功能，提高程序冗余度，更好地实现了代码复用的功能，提高程序编写的效率。由于降低了代码的冗余度，使得程序编写的效率。由于降低了代码的

77、冗余度，使得程序编写的效率。由于降低了代码的冗余度，使得程序编写的效率。由于降低了代码的冗余度，使得程序在维护时就变得非常的方便。在维护时就变得非常的方便。在维护时就变得非常的方便。在维护时就变得非常的方便。 4.84.8类的继承类的继承 1、子类、子类 在类的声明中，通过使用关键字在类的声明中，通过使用关键字在类的声明中，通过使用关键字在类的声明中，通过使用关键字extendsextends来创来创来创来创建一个类的子类，格式如下建一个类的子类，格式如下建一个类的子类，格式如下建一个类的子类，格式如下: : class 子类名子类名 extends 父类名父类名 例如：例如： class S

78、tudents extends People 4.84.8类的继承类的继承 2、子类的继承、子类的继承 类可以有两种重要的成员：成员变量和方法。类可以有两种重要的成员：成员变量和方法。类可以有两种重要的成员：成员变量和方法。类可以有两种重要的成员：成员变量和方法。子类的成员中有一部分是子类自己声明定义的，另子类的成员中有一部分是子类自己声明定义的，另子类的成员中有一部分是子类自己声明定义的，另子类的成员中有一部分是子类自己声明定义的，另一部分是从它的父类继承的。一部分是从它的父类继承的。一部分是从它的父类继承的。一部分是从它的父类继承的。 所谓子类继承父类的成员变量作为自己的一个所谓子类继承父

79、类的成员变量作为自己的一个所谓子类继承父类的成员变量作为自己的一个所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，成员变量，就好象它们是在子类中直接声明一样，成员变量，就好象它们是在子类中直接声明一样，成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法操作。可以被子类中自己声明的任何实例方法操作。可以被子类中自己声明的任何实例方法操作。可以被子类中自己声明的任何实例方法操作。 所谓子类继承父类的方法作为子类中的一个方所谓子类继承父类的方法作为子类中的一个方所谓子类继承父类的方法作为子类中的一个方所谓子类继承父类的方法作为子类中的一

80、个方法，就象它们是在子类中直接声明一样，可以被子法，就象它们是在子类中直接声明一样，可以被子法，就象它们是在子类中直接声明一样，可以被子法，就象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法调用。类中自己声明的任何实例方法调用。类中自己声明的任何实例方法调用。类中自己声明的任何实例方法调用。4.84.8类的继承类的继承 类中继承的实现主要有以下几个步骤：类中继承的实现主要有以下几个步骤：类中继承的实现主要有以下几个步骤：类中继承的实现主要有以下几个步骤： 确定父类。确定父类。确定父类。确定父类。 定义子类。它的具体语法是：定义子类。它的具体语法是：定义子类。它的具体语法是：定义

81、子类。它的具体语法是： 类修饰符类修饰符类修饰符类修饰符 class class 子类名子类名子类名子类名 extends extends 父类名父类名父类名父类名 实现子类的功能。实现子类的功能。实现子类的功能。实现子类的功能。 class A public int a1; private float a2； int getA() return(a1); void setA()class B extends A int b1; String b2; String getB() return(b2); class C extends B int c; int printC() System.

82、out. println(c); 4.84.8类的继承类的继承 1）子类和父类在同一包中的继承性）子类和父类在同一包中的继承性 如果子类和父类在同一个包中，那么，如果子类和父类在同一个包中，那么，子类自然地继承了其父类中不是子类自然地继承了其父类中不是private的的成员变量作为自己的成员变量，并且也自成员变量作为自己的成员变量，并且也自然地继承了父类中不是然地继承了父类中不是private的方法作为的方法作为自己的方法自己的方法, 继承的成员或方法的访问权限继承的成员或方法的访问权限保持不变。保持不变。 4.84.8类的继承类的继承 2）子类和父类不在同一包中的继承性）子类和父类不在同一包

83、中的继承性 如果子类和父类不在同一个包中，那么，如果子类和父类不在同一个包中，那么，子类继承了父类的子类继承了父类的protected、public成员变成员变量做为子类的成员变量，并且继承了父类的量做为子类的成员变量，并且继承了父类的protected、public方法为子类的方法方法为子类的方法, 继承继承的成员或方法的访问权限保持不变。如果子的成员或方法的访问权限保持不变。如果子类和父类不在同一个包里，子类不能继承父类和父类不在同一个包里，子类不能继承父类的友好变量和友好方法。类的友好变量和友好方法。4.84.8类的继承类的继承 3、成员变量的隐藏和方法的重写、成员变量的隐藏和方法的重写

84、 1 1）隐藏：）隐藏：）隐藏：）隐藏：只要子类中定义的成员变量和父类中的只要子类中定义的成员变量和父类中的只要子类中定义的成员变量和父类中的只要子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量成员变量同名时，子类就隐藏了继承的成员变量成员变量同名时，子类就隐藏了继承的成员变量成员变量同名时，子类就隐藏了继承的成员变量 。 2 2）重写（覆盖）：）重写（覆盖）：）重写（覆盖）：）重写（覆盖）：指子类中定义一个方法，并且指子类中定义一个方法，并且指子类中定义一个方法，并且指子类中定义一个方法，并且这个方法的名字、返回类型、参数个数和类型与从父类这个方法的名字、返回类型、参

85、数个数和类型与从父类这个方法的名字、返回类型、参数个数和类型与从父类这个方法的名字、返回类型、参数个数和类型与从父类继承的方法完全相同。继承的方法完全相同。继承的方法完全相同。继承的方法完全相同。 3 3）覆盖的实现：）覆盖的实现：）覆盖的实现：）覆盖的实现：就是在就是在就是在就是在子类子类子类子类中对需要覆盖的中对需要覆盖的中对需要覆盖的中对需要覆盖的父类父类父类父类成员以父类中相同的格式再重新声明定义一次。这样就成员以父类中相同的格式再重新声明定义一次。这样就成员以父类中相同的格式再重新声明定义一次。这样就成员以父类中相同的格式再重新声明定义一次。这样就完成了对父类成员的覆盖。它是一种很重

86、要的多态形式完成了对父类成员的覆盖。它是一种很重要的多态形式完成了对父类成员的覆盖。它是一种很重要的多态形式完成了对父类成员的覆盖。它是一种很重要的多态形式。4.84.8类的继承类的继承 4）被覆盖的成员的使用）被覆盖的成员的使用 （1 1）域变量的使用）域变量的使用）域变量的使用）域变量的使用 当子类重新定义一个与从父类那里继承来的完全相同当子类重新定义一个与从父类那里继承来的完全相同当子类重新定义一个与从父类那里继承来的完全相同当子类重新定义一个与从父类那里继承来的完全相同的属性变量时，子类就隐藏了父类的该变量（称为域变量的属性变量时，子类就隐藏了父类的该变量（称为域变量的属性变量时，子类

87、就隐藏了父类的该变量（称为域变量的属性变量时，子类就隐藏了父类的该变量（称为域变量的隐藏）。的隐藏）。的隐藏）。的隐藏）。对于域变量的隐藏来说，父类定义的域变量在对于域变量的隐藏来说，父类定义的域变量在对于域变量的隐藏来说，父类定义的域变量在对于域变量的隐藏来说，父类定义的域变量在子类对象实例化时仍然分配一个存储空间。子类对象实例化时仍然分配一个存储空间。子类对象实例化时仍然分配一个存储空间。子类对象实例化时仍然分配一个存储空间。 当子类执行继承自父类的操作时，处理的是继承自父当子类执行继承自父类的操作时，处理的是继承自父当子类执行继承自父类的操作时，处理的是继承自父当子类执行继承自父类的操作

88、时，处理的是继承自父类的变量，而当子类执行它自己定义的方法时，所操作的类的变量，而当子类执行它自己定义的方法时，所操作的类的变量，而当子类执行它自己定义的方法时，所操作的类的变量，而当子类执行它自己定义的方法时，所操作的就是它自己定义的变量，而把继承自父类的变量就是它自己定义的变量，而把继承自父类的变量就是它自己定义的变量，而把继承自父类的变量就是它自己定义的变量，而把继承自父类的变量“ “隐藏隐藏隐藏隐藏” ”起来。起来。起来。起来。4.84.8类的继承类的继承 （2）方法的使用）方法的使用 当子类重新定义与父类同名的方法时，就实现当子类重新定义与父类同名的方法时，就实现当子类重新定义与父类

89、同名的方法时，就实现当子类重新定义与父类同名的方法时，就实现了对父类方法的覆盖（了对父类方法的覆盖（了对父类方法的覆盖（了对父类方法的覆盖（OverloadOverload）。）。）。）。 方法的覆盖与域的隐藏的不同之处在于：方法的覆盖与域的隐藏的不同之处在于：方法的覆盖与域的隐藏的不同之处在于：方法的覆盖与域的隐藏的不同之处在于：子类隐子类隐子类隐子类隐藏父类的域只是使之不可见，父类的同名域在子类藏父类的域只是使之不可见，父类的同名域在子类藏父类的域只是使之不可见，父类的同名域在子类藏父类的域只是使之不可见，父类的同名域在子类对象中仍然占有自己的独立内存空间；而子类方法对象中仍然占有自己的独

90、立内存空间；而子类方法对象中仍然占有自己的独立内存空间；而子类方法对象中仍然占有自己的独立内存空间；而子类方法对父类同名方法的覆盖将清除父类方法占用的内存对父类同名方法的覆盖将清除父类方法占用的内存对父类同名方法的覆盖将清除父类方法占用的内存对父类同名方法的覆盖将清除父类方法占用的内存空间，从而使父类方法在子类对象中不复存在。空间，从而使父类方法在子类对象中不复存在。空间，从而使父类方法在子类对象中不复存在。空间，从而使父类方法在子类对象中不复存在。4.84.8类的继承类的继承 方法的覆盖中需要注意的问题是：子类在重新方法的覆盖中需要注意的问题是：子类在重新方法的覆盖中需要注意的问题是：子类在

91、重新方法的覆盖中需要注意的问题是：子类在重新定义父类已有的方法时，定义父类已有的方法时，定义父类已有的方法时，定义父类已有的方法时，应保持与父类完全相同的应保持与父类完全相同的应保持与父类完全相同的应保持与父类完全相同的方法头声明，即应与父类有完全相同的方法名、返方法头声明，即应与父类有完全相同的方法名、返方法头声明，即应与父类有完全相同的方法名、返方法头声明，即应与父类有完全相同的方法名、返回值和参数列表回值和参数列表回值和参数列表回值和参数列表。否则就不是方法的覆盖，而是子。否则就不是方法的覆盖，而是子。否则就不是方法的覆盖，而是子。否则就不是方法的覆盖，而是子类定义自己的与父类无关的方法

92、，父类的方法未被类定义自己的与父类无关的方法，父类的方法未被类定义自己的与父类无关的方法，父类的方法未被类定义自己的与父类无关的方法，父类的方法未被覆盖，所以仍然存在。覆盖，所以仍然存在。覆盖，所以仍然存在。覆盖，所以仍然存在。4.84.8类的继承类的继承 4 4、fianlfianl关键字关键字 1 1）finalfinal关键子可以修饰类、成员变量和方关键子可以修饰类、成员变量和方法中的参数。法中的参数。 2 2）finalfinal类不能被继承，即不能有子类。类不能被继承，即不能有子类。 3 3）如果一个方法被修饰为）如果一个方法被修饰为finalfinal方法，则这方法，则这个方法不能

93、被重写。个方法不能被重写。 4 4）如果一个成员变量被修饰为）如果一个成员变量被修饰为finalfinal的，就的，就是常量，常量必须赋给初值，而且不能再发生变是常量，常量必须赋给初值，而且不能再发生变化。化。 5 5）如果方法的参数被修饰为）如果方法的参数被修饰为finalfinal的，该参的，该参数的值不能被改变。数的值不能被改变。4.9 4.9 对象的上转型对象对象的上转型对象 1 1）假设）假设）假设）假设B B类是类是类是类是A A类子类或间接子类，当我们用子类子类或间接子类，当我们用子类子类或间接子类，当我们用子类子类或间接子类，当我们用子类类类类B B创建一个对象，并把这个对象的

94、引用放到创建一个对象，并把这个对象的引用放到创建一个对象，并把这个对象的引用放到创建一个对象，并把这个对象的引用放到A A类的类的类的类的对象中时对象中时对象中时对象中时: : A a; A a; B b=new B(); B b=new B(); a=b; a=b; 称这个称这个称这个称这个A A类对象：类对象：类对象：类对象：a a，是子类对象，是子类对象，是子类对象，是子类对象b b的上转型对的上转型对的上转型对的上转型对象。象。象。象。 2 2）对象的上转型对象的实体是子类负责创建的，）对象的上转型对象的实体是子类负责创建的，）对象的上转型对象的实体是子类负责创建的，）对象的上转型对象

95、的实体是子类负责创建的，但上转型对象会失去原子类对象的一些属性和功能。但上转型对象会失去原子类对象的一些属性和功能。但上转型对象会失去原子类对象的一些属性和功能。但上转型对象会失去原子类对象的一些属性和功能。4.9 4.9 对象的上转型对象对象的上转型对象 3 3）上转对象不能操作子类新增的成员变量（失）上转对象不能操作子类新增的成员变量（失）上转对象不能操作子类新增的成员变量（失）上转对象不能操作子类新增的成员变量（失掉了这部分属性）；不能使用子类新增的方法（失掉掉了这部分属性）；不能使用子类新增的方法（失掉掉了这部分属性）；不能使用子类新增的方法（失掉掉了这部分属性）；不能使用子类新增的方

96、法（失掉了一些功能）。了一些功能）。了一些功能）。了一些功能）。 4 4）上转型对象可以操作子类继承或隐藏成员变）上转型对象可以操作子类继承或隐藏成员变）上转型对象可以操作子类继承或隐藏成员变）上转型对象可以操作子类继承或隐藏成员变量，也可以使用子类继承的或重写的方法。量，也可以使用子类继承的或重写的方法。量，也可以使用子类继承的或重写的方法。量，也可以使用子类继承的或重写的方法。 5 5）上转型对象操作子类继承或重写的方法时，）上转型对象操作子类继承或重写的方法时，）上转型对象操作子类继承或重写的方法时，）上转型对象操作子类继承或重写的方法时，就是通知对应的子类对象去调用这些方法。因此，如就

97、是通知对应的子类对象去调用这些方法。因此，如就是通知对应的子类对象去调用这些方法。因此，如就是通知对应的子类对象去调用这些方法。因此，如果子类重写了父类的某个方法后，对象的上转型对象果子类重写了父类的某个方法后，对象的上转型对象果子类重写了父类的某个方法后，对象的上转型对象果子类重写了父类的某个方法后，对象的上转型对象调用这个方法时，一定是调用了这个重写的方法。调用这个方法时，一定是调用了这个重写的方法。调用这个方法时，一定是调用了这个重写的方法。调用这个方法时，一定是调用了这个重写的方法。 6 6）可以将对象的上转型对象再强制转换到一个）可以将对象的上转型对象再强制转换到一个）可以将对象的上

98、转型对象再强制转换到一个）可以将对象的上转型对象再强制转换到一个子类对象，这时，该子类对象又具备了子类所有属性子类对象，这时，该子类对象又具备了子类所有属性子类对象，这时，该子类对象又具备了子类所有属性子类对象，这时，该子类对象又具备了子类所有属性和功能。和功能。和功能。和功能。4.104.10多态性多态性 1、多态的概念、多态的概念 多态：是指一个程序中同名的不同方法多态：是指一个程序中同名的不同方法共存的情况。共存的情况。 2、实现多态的方法、实现多态的方法 1) 通过子类对父类成员的覆盖实现多态。通过子类对父类成员的覆盖实现多态。 2) 利用重载在同一个类中定义多个同名利用重载在同一个类

99、中定义多个同名的不同方法实现多态。的不同方法实现多态。4.11 abstract 4.11 abstract 类和类和abstractabstract方法方法 1、抽象类和抽象方法、抽象类和抽象方法 1 1）抽象类）抽象类）抽象类）抽象类 (1)(1)定义：定义：定义：定义： 在在在在JavaJava中，凡是用中，凡是用中，凡是用中，凡是用abstractabstract修饰符修饰的类称为抽象修饰符修饰的类称为抽象修饰符修饰的类称为抽象修饰符修饰的类称为抽象类。类。类。类。 (2)(2)格式：格式：格式：格式： 定义一个抽象类的格式如下：定义一个抽象类的格式如下：定义一个抽象类的格式如下：定义

100、一个抽象类的格式如下： abstract class ClassNameabstract class ClassName . /. /类的主体部分类的主体部分类的主体部分类的主体部分 4.11 abstract 4.11 abstract 类和类和abstractabstract方法方法 2）抽象方法）抽象方法 (1)(1)定义：定义：定义：定义： 在在在在JavaJava中，凡是用中，凡是用中，凡是用中，凡是用abstractabstract修饰符修饰的方法修饰符修饰的方法修饰符修饰的方法修饰符修饰的方法称为抽象方法。称为抽象方法。称为抽象方法。称为抽象方法。 (2)(2)格式：格式：格式：

101、格式： 定义一个抽象方法的格式如下：定义一个抽象方法的格式如下：定义一个抽象方法的格式如下：定义一个抽象方法的格式如下： abstract public abstract public 方法名方法名方法名方法名( (参数列表参数列表参数列表参数列表) )； 4.11 abstract 4.11 abstract 类和类和abstractabstract方法方法 2、抽象类和一般类的区别、抽象类和一般类的区别 如果一个类中含有未实现的抽象方法，那么如果一个类中含有未实现的抽象方法，那么如果一个类中含有未实现的抽象方法，那么如果一个类中含有未实现的抽象方法，那么这个类就必须通过关键字这个类就必须通

102、过关键字这个类就必须通过关键字这个类就必须通过关键字abstractabstract进行标记声明为进行标记声明为进行标记声明为进行标记声明为抽象类。抽象类。抽象类。抽象类。 抽象类中可以包含抽象方法，但不是一定要抽象类中可以包含抽象方法，但不是一定要抽象类中可以包含抽象方法，但不是一定要抽象类中可以包含抽象方法，但不是一定要包含抽象方法。它也可以包含非抽象方法和域变量，包含抽象方法。它也可以包含非抽象方法和域变量，包含抽象方法。它也可以包含非抽象方法和域变量，包含抽象方法。它也可以包含非抽象方法和域变量，就像一般类一样。就像一般类一样。就像一般类一样。就像一般类一样。 抽象类是没有具体对象的概

103、念类，也就是说抽象类是没有具体对象的概念类，也就是说抽象类是没有具体对象的概念类，也就是说抽象类是没有具体对象的概念类，也就是说抽象类不能实例化为对象。抽象类不能实例化为对象。抽象类不能实例化为对象。抽象类不能实例化为对象。 抽象类必须被继承。子类为它们父类中的所抽象类必须被继承。子类为它们父类中的所抽象类必须被继承。子类为它们父类中的所抽象类必须被继承。子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。有抽象方法提供实现，否则它们也是抽象类。有抽象方法提供实现，否则它们也是抽象类。有抽象方法提供实现，否则它们也是抽象类。4.11 abstract 4.11 abstract 类和类

104、和abstractabstract方法方法 和普通的类相比，和普通的类相比，和普通的类相比，和普通的类相比，abstractabstract类可以有类可以有类可以有类可以有abstractabstract方方方方法。对于法。对于法。对于法。对于abstractabstract方法，只允许声明，不允许实现，方法，只允许声明，不允许实现，方法，只允许声明，不允许实现，方法，只允许声明，不允许实现，而且不允许使用而且不允许使用而且不允许使用而且不允许使用finalfinal修饰修饰修饰修饰abstractabstract方法。方法。方法。方法。 abstract class A abstract c

105、lass A abstract int min(int x,int y); abstract int min(int x,int y); int max(int x,int y) int max(int x,int y) return xy?x:y; return xy?x:y; 4.11 abstract 4.11 abstract 类和类和abstractabstract方法方法 3、abstract类不能用类不能用new运算创建对象运算创建对象 对于对于对于对于abstractabstract类，我们不能使用类，我们不能使用类，我们不能使用类，我们不能使用newnew运算符运算符运算符运

106、算符创建该类的对象，需产生其子类，由子类创建对象，创建该类的对象，需产生其子类，由子类创建对象，创建该类的对象，需产生其子类，由子类创建对象，创建该类的对象，需产生其子类，由子类创建对象，如果一个类是如果一个类是如果一个类是如果一个类是abstractabstract类的子类，它必须具体实现类的子类，它必须具体实现类的子类，它必须具体实现类的子类，它必须具体实现父类的父类的父类的父类的abstractabstract方法，这就是为什么不允许使用方法，这就是为什么不允许使用方法，这就是为什么不允许使用方法，这就是为什么不允许使用finalfinal修饰修饰修饰修饰abstractabstract

107、方法的原因。方法的原因。方法的原因。方法的原因。 一个一个abstract类只关心它的子类是否具类只关心它的子类是否具有某种功能，并不关心功能的具体行为，功有某种功能，并不关心功能的具体行为，功能的具体行为由子类负责实现。能的具体行为由子类负责实现。4.12 super4.12 super关键字关键字 Super Super关键字主要是用来调用父类的成员变量和方法的。关键字主要是用来调用父类的成员变量和方法的。关键字主要是用来调用父类的成员变量和方法的。关键字主要是用来调用父类的成员变量和方法的。 1 1、使用关键字、使用关键字、使用关键字、使用关键字supersuper调用父类的构造方法调用

108、父类的构造方法调用父类的构造方法调用父类的构造方法 JavaJava中子类不继承父类的构造方法，因此，子类如果想中子类不继承父类的构造方法，因此，子类如果想中子类不继承父类的构造方法，因此，子类如果想中子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须且必须使用关键字使用父类的构造方法，必须且必须使用关键字使用父类的构造方法，必须且必须使用关键字使用父类的构造方法，必须且必须使用关键字supersuper来表示，来表示，来表示，来表示，而且而且而且而且supersuper必须是子类构造方法中的头一条语句。必须是子类构造方法中的头一条语句。必须是子类构造方法中的头一条语句。必须是

109、子类构造方法中的头一条语句。 如：如：如：如： class Aclass A super(); super(); 4.12 super4.12 super关键字关键字 2、使用关键字、使用关键字super操作被隐藏的成员变量操作被隐藏的成员变量和方法和方法 如果我们在子类中想使用被子类隐藏了的如果我们在子类中想使用被子类隐藏了的父类的成员变量或方法就可以使用关键字父类的成员变量或方法就可以使用关键字super。 比如：比如：super.x ，super.play()4.13 4.13 接口接口 接口的引入可以克服单继承的缺点，一个类可以实接口的引入可以克服单继承的缺点，一个类可以实接口的引入可

110、以克服单继承的缺点，一个类可以实接口的引入可以克服单继承的缺点，一个类可以实现多个接口。现多个接口。现多个接口。现多个接口。 1 1、接口的声明与使用、接口的声明与使用、接口的声明与使用、接口的声明与使用 1 1）接口声明）接口声明）接口声明）接口声明 格式：格式：格式：格式： public interface public interface 接口名接口名接口名接口名 extendsextends父接口名列表父接口名列表父接口名列表父接口名列表 2 2）接口体）接口体）接口体）接口体 接口体中包含常量定义和方法定义两部分。接口体接口体中包含常量定义和方法定义两部分。接口体接口体中包含常量定义

111、和方法定义两部分。接口体接口体中包含常量定义和方法定义两部分。接口体中只进行方法的声明，不许提供方法的实现，所以，方中只进行方法的声明，不许提供方法的实现，所以，方中只进行方法的声明，不许提供方法的实现，所以，方中只进行方法的声明，不许提供方法的实现，所以，方法的定义没有方法体，且用分号法的定义没有方法体，且用分号法的定义没有方法体，且用分号法的定义没有方法体，且用分号“ “；” ”结尾。如：结尾。如：结尾。如：结尾。如：4.13 4.13 接口接口 interface Printable final int MAX=100; void add(); float sum(float x ,fl

112、oat y); 3）接口的使用）接口的使用 一个类通过使用关键字一个类通过使用关键字一个类通过使用关键字一个类通过使用关键字implements implements 声明自声明自声明自声明自己使用一个或多个接口。如果使用多个接口，用己使用一个或多个接口。如果使用多个接口，用己使用一个或多个接口。如果使用多个接口，用己使用一个或多个接口。如果使用多个接口，用逗号隔开接口名。如：逗号隔开接口名。如：逗号隔开接口名。如：逗号隔开接口名。如： class A implements Printable,Addableclass A implements Printable,Addable4.13 4.

113、13 接口接口 如果一个类使用了某个接口，那么这个类必须实如果一个类使用了某个接口，那么这个类必须实如果一个类使用了某个接口，那么这个类必须实如果一个类使用了某个接口，那么这个类必须实现该接口的所有方法，即为这些方法提供方法体现该接口的所有方法，即为这些方法提供方法体现该接口的所有方法，即为这些方法提供方法体现该接口的所有方法，即为这些方法提供方法体 ，但，但，但，但在类中实现接口的方法时，方法的名字、返回类型、在类中实现接口的方法时，方法的名字、返回类型、在类中实现接口的方法时，方法的名字、返回类型、在类中实现接口的方法时，方法的名字、返回类型、参数个数及类型必须与接口中的完全一致。接口实现

114、参数个数及类型必须与接口中的完全一致。接口实现参数个数及类型必须与接口中的完全一致。接口实现参数个数及类型必须与接口中的完全一致。接口实现时必须给出方法体，且一定要用时必须给出方法体，且一定要用时必须给出方法体，且一定要用时必须给出方法体，且一定要用publicpublic来修饰。来修饰。来修饰。来修饰。 2、理解接口、理解接口 接口的思想在于它可以增加很多类都需要实现的接口的思想在于它可以增加很多类都需要实现的接口的思想在于它可以增加很多类都需要实现的接口的思想在于它可以增加很多类都需要实现的功能，使用相同的接口类不一定有继承关系。功能，使用相同的接口类不一定有继承关系。功能，使用相同的接口

115、类不一定有继承关系。功能，使用相同的接口类不一定有继承关系。 同一个类也可以实现多个接口。接口只关心功能，同一个类也可以实现多个接口。接口只关心功能，同一个类也可以实现多个接口。接口只关心功能，同一个类也可以实现多个接口。接口只关心功能，并不关心功能的具体实现。并不关心功能的具体实现。并不关心功能的具体实现。并不关心功能的具体实现。4.13 4.13 接口接口 在在Java中接口是一种专门的类型。用中接口是一种专门的类型。用interface关键字定义接口。关键字定义接口。 接口中只能定义抽象方法，不能有方法体，接口中只能定义抽象方法，不能有方法体，一定是一定是public修饰的。修饰的。 接

116、口中可以定义变量，但实际上是接口中可以定义变量，但实际上是static final修饰的常量。修饰的常量。 接口中不能定义静态方法，接口不能包含任接口中不能定义静态方法，接口不能包含任何可以执行的方法，而抽象类可以。何可以执行的方法，而抽象类可以。 类可以实现多个接口，但只有一个父类。类可以实现多个接口，但只有一个父类。 接口不是类分级结构的一部分，而没有联系接口不是类分级结构的一部分，而没有联系的类可以执行相同的接口。的类可以执行相同的接口。4.13 4.13 接口接口 3、接口回调、接口回调 接口回调是指：可以把实现某一接口的类创接口回调是指：可以把实现某一接口的类创接口回调是指：可以把实

117、现某一接口的类创接口回调是指：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中。建的对象的引用赋给该接口声明的接口变量中。建的对象的引用赋给该接口声明的接口变量中。建的对象的引用赋给该接口声明的接口变量中。那么该接口变量就可以调用被类实现的接口中的那么该接口变量就可以调用被类实现的接口中的那么该接口变量就可以调用被类实现的接口中的那么该接口变量就可以调用被类实现的接口中的方法。实际上，当接口变量调用被类实现的接口方法。实际上，当接口变量调用被类实现的接口方法。实际上，当接口变量调用被类实现的接口方法。实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方

118、中的方法时，就是通知相应的对象调用接口的方中的方法时，就是通知相应的对象调用接口的方中的方法时，就是通知相应的对象调用接口的方法。法。法。法。 4、接口做参数、接口做参数 一个方法的参数是接口类型，就可以将任何一个方法的参数是接口类型，就可以将任何一个方法的参数是接口类型，就可以将任何一个方法的参数是接口类型，就可以将任何实现该接口的类的实例的引用传递给该接口参数，实现该接口的类的实例的引用传递给该接口参数，实现该接口的类的实例的引用传递给该接口参数，实现该接口的类的实例的引用传递给该接口参数，接口参数就可以回调类实现的接口方法。接口参数就可以回调类实现的接口方法。接口参数就可以回调类实现的接

119、口方法。接口参数就可以回调类实现的接口方法。4.13 4.13 接口接口 一个类要实现接口时，请注意以下问题：一个类要实现接口时，请注意以下问题：一个类要实现接口时，请注意以下问题：一个类要实现接口时，请注意以下问题： 在类的声明部分，用在类的声明部分，用在类的声明部分，用在类的声明部分，用implementsimplements关键字关键字关键字关键字声明该类将要实现哪些接口。声明该类将要实现哪些接口。声明该类将要实现哪些接口。声明该类将要实现哪些接口。 如果实现某接口的类不是如果实现某接口的类不是如果实现某接口的类不是如果实现某接口的类不是abstractabstract抽象类，抽象类，抽

120、象类，抽象类，则在类的定义部分必须实现指定接口的所有抽象方则在类的定义部分必须实现指定接口的所有抽象方则在类的定义部分必须实现指定接口的所有抽象方则在类的定义部分必须实现指定接口的所有抽象方法。法。法。法。 如果实现某接口的的类是如果实现某接口的的类是如果实现某接口的的类是如果实现某接口的的类是abstractabstract的抽象的抽象的抽象的抽象类，则它可以不实现该接口所有的方法。但是对于类，则它可以不实现该接口所有的方法。但是对于类，则它可以不实现该接口所有的方法。但是对于类，则它可以不实现该接口所有的方法。但是对于这个抽象类任何一个非抽象的子类而言，它这个抽象类任何一个非抽象的子类而言

121、，它这个抽象类任何一个非抽象的子类而言，它这个抽象类任何一个非抽象的子类而言，它4.13 4.13 接口接口 们父类所实现的接口中的所有抽象方法都必须有实在的们父类所实现的接口中的所有抽象方法都必须有实在的们父类所实现的接口中的所有抽象方法都必须有实在的们父类所实现的接口中的所有抽象方法都必须有实在的方法体。方法体。方法体。方法体。 个类在实现某接口的抽象方法时，个类在实现某接口的抽象方法时，个类在实现某接口的抽象方法时，个类在实现某接口的抽象方法时，必须使用完必须使用完必须使用完必须使用完全相同方法头全相同方法头全相同方法头全相同方法头。如果所实现的方法与抽象方法有相同的。如果所实现的方法与

122、抽象方法有相同的。如果所实现的方法与抽象方法有相同的。如果所实现的方法与抽象方法有相同的方法名和不同的参数列表，则只是在重载一个新的方法，方法名和不同的参数列表，则只是在重载一个新的方法，方法名和不同的参数列表，则只是在重载一个新的方法，方法名和不同的参数列表，则只是在重载一个新的方法，而不是实现已有的抽象方法。而不是实现已有的抽象方法。而不是实现已有的抽象方法。而不是实现已有的抽象方法。 接口的抽象方法的访问限制符都已制定为接口的抽象方法的访问限制符都已制定为接口的抽象方法的访问限制符都已制定为接口的抽象方法的访问限制符都已制定为publicpublic，所以类在实现方法时，必须显式地使用，

123、所以类在实现方法时，必须显式地使用，所以类在实现方法时，必须显式地使用，所以类在实现方法时，必须显式地使用publicpublic修饰符，修饰符，修饰符，修饰符，否则将被系统警告为缩小了接口中定义的方法的访问控否则将被系统警告为缩小了接口中定义的方法的访问控否则将被系统警告为缩小了接口中定义的方法的访问控否则将被系统警告为缩小了接口中定义的方法的访问控制范围。制范围。制范围。制范围。4.14 4.14 内部类内部类 Java支持在一个类中声明另一个类，支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类成这样的类称作内部类，而包含内部类的类成为内部类的外嵌类。为内部类的外嵌类。 内

124、部类的类体中不可以声明类（静态的）内部类的类体中不可以声明类（静态的）变量和类（静态的）方法。外嵌类的类体中变量和类（静态的）方法。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。可以用内部类声明对象，作为外嵌类的成员。 4.15 4.15 匿名类匿名类 1、和类有关的匿名类、和类有关的匿名类 当使用类创建对象时，程序允许我们把类体与当使用类创建对象时，程序允许我们把类体与当使用类创建对象时，程序允许我们把类体与当使用类创建对象时，程序允许我们把类体与对象的创建组合在一起，也就是说，类创建对象时，对象的创建组合在一起，也就是说，类创建对象时，对象的创建组合在一起，也就是说，类创建对象时，

125、对象的创建组合在一起，也就是说，类创建对象时，除了构造方法还有类体，此类体被认为是该类的一除了构造方法还有类体，此类体被认为是该类的一除了构造方法还有类体，此类体被认为是该类的一除了构造方法还有类体，此类体被认为是该类的一个子类去掉类声明后的类体，称作匿名类。个子类去掉类声明后的类体，称作匿名类。个子类去掉类声明后的类体，称作匿名类。个子类去掉类声明后的类体，称作匿名类。 2、和接口有关的匿名类、和接口有关的匿名类 JavaJava允许直接用接口名和一个类体创建一个匿允许直接用接口名和一个类体创建一个匿允许直接用接口名和一个类体创建一个匿允许直接用接口名和一个类体创建一个匿名对象，此类体被认为

126、是实现了接口的类去掉类声名对象，此类体被认为是实现了接口的类去掉类声名对象，此类体被认为是实现了接口的类去掉类声名对象，此类体被认为是实现了接口的类去掉类声明后的类体，称作匿名类。明后的类体，称作匿名类。明后的类体，称作匿名类。明后的类体，称作匿名类。4.164.16异常类异常类因为重要：单独讲因为重要：单独讲4.17 Class4.17 Class类类 1、获取类的有关信息、获取类的有关信息 ClassClass是是是是java.langjava.lang包中的类，该类的实例用来封包中的类，该类的实例用来封包中的类，该类的实例用来封包中的类，该类的实例用来封装对象运行时的状态。当一个类被加载

127、且创建对象时，装对象运行时的状态。当一个类被加载且创建对象时，装对象运行时的状态。当一个类被加载且创建对象时，装对象运行时的状态。当一个类被加载且创建对象时，和该类相关的一个类型为和该类相关的一个类型为和该类相关的一个类型为和该类相关的一个类型为CalssCalss的对象就会自动创建。的对象就会自动创建。的对象就会自动创建。的对象就会自动创建。ClassClass类本身不提供构造方法，因此，不能使用类本身不提供构造方法，因此，不能使用类本身不提供构造方法，因此，不能使用类本身不提供构造方法，因此，不能使用newnew运算符和构造方法显示地创建一个运算符和构造方法显示地创建一个运算符和构造方法显

128、示地创建一个运算符和构造方法显示地创建一个ClassClass对象。任何对象。任何对象。任何对象。任何对象调用对象调用对象调用对象调用getClass()getClass()方法都可以获取和该对象相关的方法都可以获取和该对象相关的方法都可以获取和该对象相关的方法都可以获取和该对象相关的一个一个一个一个ClassClass对象，这个对象，这个对象，这个对象，这个ClassClass对象通过调用相应的方法对象通过调用相应的方法对象通过调用相应的方法对象通过调用相应的方法就可以获取创建对象的类的有关信息。就可以获取创建对象的类的有关信息。就可以获取创建对象的类的有关信息。就可以获取创建对象的类的有关

129、信息。4.17 Class4.17 Class类类 2 2、使用使用使用使用ClassClass实例化一个对象实例化一个对象实例化一个对象实例化一个对象 创建对象最常用的方式就是使用创建对象最常用的方式就是使用创建对象最常用的方式就是使用创建对象最常用的方式就是使用newnew运算符和类的运算符和类的运算符和类的运算符和类的构造方法，实际上我们也可以使用构造方法，实际上我们也可以使用构造方法，实际上我们也可以使用构造方法，实际上我们也可以使用ClassClass对象得到一个对象得到一个对象得到一个对象得到一个类的实例。为了得到一个类的对象，可以先得到一个和类的实例。为了得到一个类的对象，可以先

130、得到一个和类的实例。为了得到一个类的对象，可以先得到一个和类的实例。为了得到一个类的对象，可以先得到一个和该类相关的该类相关的该类相关的该类相关的ClassClass对象，做到这一点并不困难，只要使对象，做到这一点并不困难，只要使对象，做到这一点并不困难，只要使对象，做到这一点并不困难，只要使用用用用ClassClass的类方法：的类方法：的类方法：的类方法： public static Class forName(String className) public static Class forName(String className) throws ClassNotFoundExcept

131、ion throws ClassNotFoundException 就可以返回一个和参数就可以返回一个和参数就可以返回一个和参数就可以返回一个和参数classNameclassName指定的类相关的指定的类相关的指定的类相关的指定的类相关的ClassClass对象。再让这个对象。再让这个对象。再让这个对象。再让这个ClassClass对象调用：对象调用：对象调用：对象调用： public Object newInstance() throws public Object newInstance() throws InstantiationException,IllegalAccessExcep

132、tion InstantiationException,IllegalAccessException 方法就可以得到一个方法就可以得到一个方法就可以得到一个方法就可以得到一个classNameclassName类的对象。类的对象。类的对象。类的对象。4.184.18基本类型的类包装基本类型的类包装 Java Java的基本数据类型包括：的基本数据类型包括：的基本数据类型包括：的基本数据类型包括：bytebyte、intint、shortshort、longlong、floatfloat、doubledouble、charchar。JavaJava同时也提供了同时也提供了同时也提供了同时也提供了

133、基本数据类型相关的类，实现了对基本数据类型的基本数据类型相关的类，实现了对基本数据类型的基本数据类型相关的类，实现了对基本数据类型的基本数据类型相关的类，实现了对基本数据类型的封装。这些类在封装。这些类在封装。这些类在封装。这些类在java.langjava.lang包中，分别是：包中，分别是：包中，分别是：包中，分别是：ByteByte、IntegerInteger、ShortShort、LongLong、FloatFloat、DoubleDouble和和和和CharacterCharacter类。类。类。类。 1. Double1. Double和和和和FloatFloat类类类类 Dou

134、bleDouble类和类和类和类和FloatFloat类实现了对类实现了对类实现了对类实现了对doubledouble和和和和floatfloat基本型数据的类包装。基本型数据的类包装。基本型数据的类包装。基本型数据的类包装。 1 1）可以使用）可以使用）可以使用）可以使用DoubleDouble类的构造方法：类的构造方法：类的构造方法：类的构造方法： Double (double num)Double (double num) 创建一个创建一个创建一个创建一个DoubleDouble类型的对象。类型的对象。类型的对象。类型的对象。4.184.18基本类型的类包装基本类型的类包装 2 2）使用

135、）使用）使用）使用FloatFloat类的构造方法：类的构造方法：类的构造方法：类的构造方法： Float (float num)Float (float num) 创建一个创建一个创建一个创建一个FloatFloat类型的对象。类型的对象。类型的对象。类型的对象。 3 3）DoubleDouble对象调用对象调用对象调用对象调用doubleValue()doubleValue()方法可方法可方法可方法可以返回该对象含有的以返回该对象含有的以返回该对象含有的以返回该对象含有的doubledouble型数据。型数据。型数据。型数据。 4 4）FloatFloat对象调用对象调用对象调用对象调用f

136、loatValue()floatValue()方法可以返方法可以返方法可以返方法可以返回该对象含有的回该对象含有的回该对象含有的回该对象含有的floatfloat型数据。型数据。型数据。型数据。4.184.18基本类型的类包装基本类型的类包装 2. Byte、Integer、Short、Long类类 下述构造方法分别可以创建下述构造方法分别可以创建下述构造方法分别可以创建下述构造方法分别可以创建ByteByte、IntegerInteger、ShortShort和和和和LongLong类型的对象：类型的对象：类型的对象：类型的对象： Byte(byte num)Byte(byte num) I

137、nteger(int num)Integer(int num)Short(short num)Short(short num)Long(long num)Long(long num) Byte Byte、IntegerInteger、ShortShort和和和和LongLong对象分别调对象分别调对象分别调对象分别调用用用用byteValue ()byteValue ()、intValue()intValue()、shortValue ()shortValue ()和和和和longValue ()longValue ()方法可以返回该对象含有的基本型数方法可以返回该对象含有的基本型数方法可以返

138、回该对象含有的基本型数方法可以返回该对象含有的基本型数据。据。据。据。4.184.18基本类型的类包装基本类型的类包装 3. Character类类 1）Character类实现了对类实现了对char基本型基本型数据的类包装。数据的类包装。 2）可以使用）可以使用Character类的构造方法：类的构造方法： Character (char c) 创建一个创建一个Character类型的对象。类型的对象。 3）Character对象调用对象调用charValue()方法可以返回该对象含有的方法可以返回该对象含有的char型数据。型数据。4.19 4.19 反编译和文档生成器反编译和文档生成器使用SDK提供的反编译器:javap.exe可以将字节码反编译为源码，查看源码类中的方法名字和成员变量的名字 .使用SDK提供的javadoc.exe可以制做源文件类结构的html格式文档。 课后习题：课后习题： P100 2，6，7，17