第四章 类、对象和接口

教学目标 了解类和对象的基本概念 掌握类的定义方法 掌握对象的初始化 掌握类的方法的定义 掌握类的封装性、继承性 掌握类的多态性 掌握接口的定义

教学重难点 重点 Java中类的定义方法 方法重载 Java中对象的使用 不同访问修饰符的应用 Java中类继承的定义

教学重难点 难点 Java构造方法的定义 类变量和类方法的使用 类的继承特性 函数的重载

4.1 编程语言的几个发展阶段 机器语言（如汇编语言） 计算机处理信息的早期语言是所谓的机器语言，这种语言中的指令都是由0,1组成的序列，称这样的序列为一条机器指令。 过程语言 语言把代码组成叫做过程或函数的块。每个块的目标是完成某个任务，例如，一个C的源程序就是由若干个书写形式互相独立的函数组成。 面向对象编程 面向对象编程主要体现下列三个特性： 1.封装性 2.继承 3.多态 Java语言是面向对象语言，它的源程序是由若干个类组成，源文件是扩展名为.java的文本文件

1．封装性 封装性就是把对象的属性和服务结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节，包含两个含义： 　　封装性就是把对象的属性和服务结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节，包含两个含义： 　　 ◇ 把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位（即对象）。 　　 ◇ 信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界〔或者说形成一道屏障〕，只保留有限的对外接口使之与外部发生联系。 　　封装的原则在软件上的反映是：要求使对象以外的部分不能随意存取对象的内部数据（属性），从而有效的避免了外部错误对它的"交叉感染"，使软件错误能够局部化，大大减少查错和排错的难度。

2．继承性 　 特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。例如，轮船、客轮；人、大人。一个类可以是多个一般类的特殊类，它从多个一般类中继承了属性与服务，这称为多继承。例如，客轮是轮船和客运工具的特殊类。在java语言中，通常我们称一般类为父类（superclass,超类），特殊类为子类(subclass)。

3．多态性 　对象的多态性是指在一般类中定义的属性或服务被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或服务在一般类及其各个特殊类中具有不同的语义。例如："几何图形"的"绘图"方法，"椭圆"和"多边形"都是"几何图"的子类，其"绘图"方法功能不同。

4.2 面向对象的概念—类(一) 类是描述对象的“基本原型”，它定义一类对象所能拥有的数据和能完成的操作。在面向对象的程序设计中，类是程序的基本单元。 相似的对象可以归并到同一个类中去，就像传统语言中的变量与类型关系一样。 程序中的对象是类的一个实例，是一个软件单元，它由一组结构化的数据和在其上的一组操作构成。

4.2 面向对象的概念—类(二) …… Car car1; Car car2; … … Car carN;

4.2 面向对象的概念—类(三) 为什么要使用类？ 使用类可以把现实问题中的对象映射为程序中的一个整体——类。 采用简单数据类型表示现实世界中概念的局存在很大的限性。例如：采用int型数据表示一个日期概念，需要使用3个变量： int day, month, year; 如果要表示2个人的生日，就要使用6个变量 并且在使用中必须时刻注意三者的联系和约束关系 同时在使用日期概念时要同时对三个变量进行访问 使用类可以把现实问题中的对象映射为程序中的一个整体——类。

4. 2 类的定义(四) Java中的类 在Java程序中，类是由定义和主体构成的 右图是Java中一个完整的类 注：类体的内容由两部分组成：一部分是变量的定义，一部分是方法的定义。

4.2 类的定义语法规范(五) 类的严格定义及修饰字 类的修饰字： [public] [abstract | final] [类的修饰字] class 类名称 [extends 父类名称][implements 接口名称列表] { 变量定义及初始化； 方法定义及方法体； } 类体，其中定义了该类中所有的变量和该类所支持的方法，称为成员变量和成员方法。 类的修饰字： [public] [abstract | final] 缺省方式为 package

4.2 类的定义语法规范(六) 类定义中的修饰字含义 public：表示这个类不但能被同一个包中的其它类访问，而且能被其它包中的类访问 缺省情况下，类只能由和它在同一个包中的其它类访问 abstract：表示这个类是抽象类，不能被实例化，也就是说不能定义这个类的对象 final：表示这个类是最终类，它不能有子类。后面会详细讨论父类和子类的关系

4.2 类的定义语法规范(七) 类定义中的关键字含义 class 类名：表示这是一个类，后面紧接着的就是类的名字。这一项是必需项； extends 父类名：指示它所继承来的类的名称，也就是父类的名称 implements 接口名：表示这个类实现一个或多个接口，如果有多个接口，接口名之间应当用逗号隔开 类的主体中包括构造函数、成员变量、成员函数

3.成员变量和局部变量 我们已经知道类体分为两部分。变量定义部分所定义的变量被称为类的成员变量。在方法体中定义的变量和方法的参数被称为局部变量。 成员变量在整个类内都有效，局部变量只在定义它的方法内有效。 成员变量又分为实例成员变量（简称实例变量）和类变量（也称静态变量） .如果成员变量的类型前面加上关键字static，这样的成员变量称做是类变量或静态变量。 如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，即这个成员变量在这个方法内暂时失效 . 如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏。这时如果想在该方法内使用成员变量，必须使用关键字this。

class 三角形 { float sideA,sideB,sideC,lengthSum; void setSide(float sideA,float sideB,float sideC) { this.sideA=sideA; this.sideB=sideB; this.sideC=sideC; } this.sideA，this.sideB，this.sideC就分别表示成员变量sideA,sideB,sideC

4.方法 我们已经知道一个类的类体由两部分组成：变量的定义和方法的定义。方法的定义包括两部分：方法声明和方法体。 方法参数在整个方法内有效，方法内定义的局部变量从它定义的位置之后开始有效。如果局部变量的定义是在一个复合语句中，那么该局部变量的有效范围是该复合语句，即仅在该复合语句中有效，如果局部变量的定义是在一个循环语句中，那么该局部变量的有效范围是该循环语句，即仅在该循环语句中有效 . 写一个方法和C语言中写一个函数类似，只不过在这里称做方法

5.方法重载 方法重载的意思是：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。

class Area { float getArea(float r) { return 3.14f*r*r; } double getArea(float x,int y) { return x*y; float getArea(int x,float y) double getArea(float x,float y,float z) { return (x*x+y*y+z*z)*2.0;

6.构造方法 构造方法是一种特殊方法，它的名字必须与它所在的类的名字完全相同，而且没有类型，构造方法也可以重载。

class 梯形 { float 上底,下底,高; 梯形() { 上底=60; 下底=100; 高=20; } 梯形(float x,int y,float h) { 上底=x; 下底=y; 高=h;

7.类方法和实例方法 类中的方法也可分为实例方法和类方法. 方法声明时，方法类型前面不加关键字static的是实例方法、加关键字static的是类方法。 构造方法是特殊的方法，不能用static修饰构造方法。

4.3 对象 类是创建对象的模板。当使用一个类创建了一个对象时，我们也说我们给出了这个类的一个实例。

1.创建对象 创建一个对象包括对象的声明和为对象分配内存两个步骤。 (1)．对象的声明。 一般格式为： 类的名字 对象名字; 如： 类的名字 对象名字; 如： People zhangPing;

(2)为声明的对象分配内存 使用new运算符和类的构造方法为声明的对象分配内存，如果类中没有构造方法，系统会调用默认的构造方法（默认的构造方法是无参数的，你一定还记得构造方法的名字必须和类名相同这一规定）。如： zhangPing=new People();

(3)对象的内存模型 使用例子1来说明对象的内存模型 class XiyoujiRenwu { float height,weight; String head, ear,hand,foot, mouth; void speak(String s) { System.out.println(s); } class A { public static void main(String args[]) { XiyoujiRenwu zhubajie; //声明对象 zhubajie=new XiyoujiRenwu(); //为对象分配内存， //使用new 运 算 符和默认的构造方法

声明对象时的内存模型 当用XiyoujiRenwu类声明一个变量，即对象zhubajie时，如例子1中的对象zhubajie： 内存模型如左图所示

对象分配内存后的内存模型 当系统见到： 时，就会做两件事： zhubajie=new XiyoujiRenwu(); ① 为height，weight，head，ear，mouth，hand，foot各个变量分配内存，即XiyoujiRenwu类的成员变量被分配内存空间，然后执行构造方法中的语句。 ② new运算符在为变量height，weight，head，ear，mouth，hand，foot分配内存后，将返回一个引用给对象变量zhubajie。

2.使用对象 对象不仅可以操作自己的变量改变状态，而且还拥有了使用创建它的那个类中的方法的能力，对象通过使用这些方法可以产生一定的行为。 通过使用运算符“.”，对象可以实现对自己的变量访问和方法的调用。 当对象调用方法时，方法中出现的成员变量就是指该对象的成员变量。

3.对象的引用和实体 当用类创建一个对象时，类中的成员变量被分配内存空间，这些内存空间称做该对象的实体，而对象中存放着引用，以确保实体由该对象操作使用。 一个类创建的两个对象，如果具有相同的引用，那么就具有完全相同的实体。 没有实体的对象称作空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为。

4.参数传值 当方法被调用时，如果方法有参数，参数必须要实例化，即参数变量必须有具体的值。在Java中，方法的所有参数都是“传值”的，也就是说，方法中参数变量的值是调用者指定的值的拷贝。例如，如果向方法的int型参数x传递一个int值，那么参数x得到的值是传递值的拷贝。方法如果改变参数的值，不会影响向参数“传值”的变量的值。

基本数据类型参数的传值 对于基本数据类型的参数，向该参数传递的值的级别不可以高于该参数的级别，比如，不可以向int型参数传递一个float值，但可以向double型参数传递一个float值。

引用类型参数的传值 Java的引用型数据包括对象、数组和接口。当参数是引用类型时，“传值”传递的是变量的引用而不是变量所引用的实体。 如果改变参数变量所引用的实体，就会导致原变量的实体发生同样的变化。但是，改变参数的引用不会影响向其传值的变量的引用。

4.4 static 关键字 用static修饰的成员变量称为类变量 用static修饰的方法称为类方法

１．实例变量和类变量的区别 一个类通过使用new运算符可以创建多个不同的对象，不同的对象的实例变量将被分配不同的内存空间，如果类中的成员变量有类变量，那么所有的对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其它对象的这个类变量。 类变量是和该类创建的所有对象相关联的变量，改变其中一个对象的这个类变量就同时改变了其它对象的这个类变量。因此，类变量不仅可以通过某个对象访问也可以直接通过类名访问。实例变量仅仅是和相应的对象关联的变量，也就是说，不同对象的实例变量互不相同，即分配不同的内存空间，改变其中一个对象的实例变量不会影响其它对象的这个实例变量。实例变量可以通过对象访问，不能使用类名访问。

２.实例方法和类方法的区别 实例方法可以被类创建的任何对象调用执行。 类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用

4.5 this 关键字 this是Java的一个关键字，表示某个对象。 this可以出现在实例方法和构造方法中，但不可以出现在类方法中。

4.6 包 包是Java语言中有效地管理类的一个机制。

1.包语句 通过关键字package声明包语句。package 语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。package语句的一般格式为： package 包名; 如果源程序中省略了package语句，源文件中定义命名的类被隐含地认为是无名包的一部分，即源文件中定义命名的类在同一个包中，但该包没有名字。 包名可以是一个合法的标识符，也可以是若干个标识符加“.”分割而成 。

２. import 语句 使用import 语句可以引入包中的类。 在编写源文件时，除了自己编写类外，我们经常需要使用Java提供的许多类，这些类可能在不同的包中。 在学习Java语言时，使用已经存在的类，避免一切从头做起，这是面向对象编程的一个重要方面。

4.7访问权限 类创建了一个对象之后，该对象可以通过“.”运算符操作自己的变量、使用类中的方法，但对象操作自己的变量和使用类中的方法是有一定限制的。 所谓访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符使用类中的方法。 访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法。

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

２.共有变量和共有方法 一个类在另外一个类中创建一个对象后，该对象能访问自己的public变量和public方法

3.受保护的成员变量和方法 一个类在另外一个类中创建一个对象后，如果两个类在同一包中，该对象能访问自己的protected变量和protected方法 对于一个类的protected类变量（静态成员变量），如果两个类在同一包中，那么在另外一个类中，也能通过类名来操作这个protected类变量。 在后面学习类的继承时，将讲述protected和“友好”之间在继承方面的区别。

4.友好变量和友好方法 不用private、public 、protected修饰符的成员变量和方法被称为友好变量和友好方法。 一个类在另外一个类中创建一个对象后，如果两个类在同一包中，该对象能访问自己的友好变量和友好方法 对于一个类的友好类变量（静态成员变量），如果两个类在同一包中，那么在另外一个类中，也能通过类名来操作这个友好类变量。

4.8 类的继承 继承是一种由已有的类创建新类的机制。利用继承，我们可以先创建一个共有属性的一般类，根据该一般类再创建具有特殊属性的新类，新类继承一般类的状态和行为，并根据需要增加它自己的新的状态和行为。由继承而得到的类称为子类，被继承的类称为父类（超类）。Java不支持多重继承（子类只能有一个父类）。

1.子类 在类的声明中，通过使用关键字extends来创建一个类的子类，格式如下: class 子类名 extends 父类名 {… } 例如： class Students extends People

2.子类的继承性 类有可以有两种重要的成员：成员变量和方法。子类的成员中有一部分是子类自己声明定义的，另一部分是从它的父类继承的。 所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法操作. 所谓子类继承父类的方法作为子类中的一个方法，就象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法调用。

子类和父类在同一包中的继承性 如果子类和父类在同一个包中，那么，子类自然地继承了其父类中不是private的成员变量作为自己的成员变量，并且也自然地继承了父类中不是private的方法作为自己的方法, 继承的成员或方法的访问权限保持不变。

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

3.成员变量的隐藏和方法的重写 子类也可以隐藏继承的成员变量，对于子类可以从父类继承的成员变量，只要子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量 . 子类通过方法的重写可以隐藏继承的方法 ,方法重写是指：子类中定义一个方法，并且这个方法的名字、返回类型、参数个数和类型与从父类继承的方法完全相同。 对于子类创建的一个对象，如果子类重写了父类的方法，则运行时系统调用子类重写的方法，如果子类继承了父类的方法（未重写），那么子类创建的对象也可以调用这个方法，只不过方法产生的行为和父类的相同而已. 注：重写父类的方法时，不可以降低方法的访问权限。

4. final关键字 final关键子可以修饰类、成员变量和方法中的参数。 final类不能被继承，即不能有子类。

4.9 对象的上转型对象 假设B类是A类子类或间接子类，当我们用子类B创建一个对象，并把这个对象的引用放到A类的对象中时: A a; B b=new B(); a=b; 称这个A类对象：a，是子类对象b的上转型对象. 对象的上转型对象的实体是子类负责创建的，但上转型对象会失去原子类对象的一些属性和功能。

上转对象不能操作子类新增的成员变量（失掉了这部分属性）；不能使用子类新增的方法（失掉了一些功能）。 上转型对象可以操作子类继承或隐藏成员变量，也可以使用子类继承的或重写的方法。 上转型对象操作子类继承或重写的方法时，就是通知对应的子类对象去调用这些方法。因此，如果子类重写了父类的某个方法后，对象的上转型对象调用这个方法时，一定是调用了这个重写的方法。 可以将对象的上转型对象再强制转换到一个子类对象，这时，该子类对象又具备了子类所有属性和功能。

4.10 多态性 多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为 . 当一个类有很多子类时，并且这些子类都重写了父类中的某个方法。那么当我们把子类创建的对象的引用放到一个父类的对象中时，就得到了该对象的一个上转型对象，那么这个上转的对象在调用这个方法时就可能具有多种形态.

4.11 abstract 类和abstract方法 abstract class A { … }

abstract类有如下特点 和普通的类相比，abstract类可以有abstract方法。对于abstract方法，只允许声明，不允许实现，而且不允许使用final修饰abstract方法。 abstract class A { abstract int min(int x,int y); int max(int x,int y) { return x>y?x:y; }

abstract类不能用new运算创建对象 对于abstract类，我们不能使用new运算符创建该类的对象，需产生其子类，由子类创建对象，如果一个类是abstract类的子类，它必须具体实现父类的abstract方法，这就是为什么不允许使用final修饰abstract方法的原因。 一个abstract类只关心它的子类是否具有某种功能，并不关心功能的具体行为，功能的具体行为由子类负责实现，抽象类中的抽象方法可以强制子类必须给出这些方法的具体实现。

4.12 super关键字 子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。 如果我们在子类中想使用被子类隐藏了的父类的成员变量或方法就可以使用关键字super。比如：super.x、super.play()，就是被子类隐藏的父类的成员变量x和方法play()。

4.13 接口 Java不支持多继承性，即一个类只能有一个父类。单继承性使得Java简单，易于管理程序。为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。

1.接口的声明与使用 使用关键字interface来定义一个接口。接口的定义和类的定义很相似，分为接口的声明和接口体。 接口体中包含常量定义和方法定义两部分。接口体中只进行方法的声明，不许提供方法的实现，所以，方法的定义没有方法体，且用分号“；”结尾。如： interface Printable { final int MAX=100; void add(); float sum(float x ,float y); }

接口的使用 一个类通过使用关键字implements 声明自己使用一个或多个接口。如果使用多个接口，用逗号隔开接口名。如： class A implements Printable,Addable 如果一个类使用了某个接口，那么这个类必须实现该接口的所有方法，即为这些方法提供方法体 .

2.理解接口 接口的思想在于它可以增加很多类都需要实现的功能，使用相同的接口类不一定有继承关系. 同一个类也可以实现多个接口。接口只关心功能，并不关心功能的具体实现.

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

4.接口做参数 一个方法的参数是接口类型，就可以将任何实现该接口的类的实例的引用传递给该接口参数，接口参数就可以回调类实现的接口方法。

4.14 内部类 Java支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类成为内部类的外嵌类。 内部类的类体中不可以声明类变量和类方法。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。

4.15 匿名类 和类有关的匿名类 和接口有关的匿名类 　　　当使用类创建对象时，程序允许我们把类体与对象的创建组合在一起，也就是说，类创建对象时，除了构造方法还有类体，此类体被认为是该类的一个子类去掉类声明后的类体，称作匿名类。 和接口有关的匿名类 　　　Java允许直接用接口名和一个类体创建一个匿名对象，此类体被认为是实现了接口的类去掉类声明后的类体，称作匿名类 .

4.16 异常类 程序运行出现异常时，Java运行环境就用异常类Exception的相应子类创建一个异常对象，并等待处理，例如，读取一个不存在的文件时，运行环境就用异常类IOException创建一个对象，异常对象可以调用如下方法得到或输出有关异常的信息： public String getMessage() //得到有关异常事件的信息 public void printStackTrace() //跟踪异常事件发生时执行堆栈的内容。 public String toString()//输出对象的简短描述信息

使用try~catch~finally语句来处理异常，将可能出现的异常操作放在try~catch~finally语句的try部分，当try部分中的某个语句发生异常后，try部分将立刻结束执行，而转向执行相应的catch部分； finally为异常处理提供一个统一的出口，不论在try代码块中是否发生了异常事件，finally块中的语句都会被执行。 try~catch~finally语句可以由几个catch组成，分别处理发生的相应异常。

try-catch-finally语句的功能为： 所有可能抛出异常的语句都放入try模块中。try模块中的语句是程序正常流程要执行的语句，但是在执行过程中有可能出现异常 （2）catch模块 主要负责对抛出的异常做相应的处理。try模块中的语句可能抛出很多不同类型的异常，所以需要针对不同类型的异常分别设计catch模块，每一模块处理一种类型的异常 对于这些catch模块，其排列的先后顺序有如下规定：出现在前面的catch模块中的异常类一定要是后面的catch模块中的异常类的子类， 这是因为catch模块是按顺序执行的 程序中即使没有try模块，若出现了系统定义的异常，系统也会自动抛出，并由系统负责捕捉和处理 （3）finally模块 finally模块中的语句是必须执行的语句。无论try模块中是否抛出异常，finally模块中的语句时都要被执行。这个模块是可选的

在try语句中可以同时使用catch子句和finally子句，即try语句的一般行式是： catch (异常类1 e1){//括号内为处理异常类1的程序块  catch (异常类1 e2){//括号内为处理异常类2的程序块    catch (异常类1 e n){//括号内为处理异常类n的程序块  }finally {//括号内为必须要执行的程序块  } //以下为后续程序块

4.17 基本类型的类包装 Java是一种面向对象语言，java中的类把方法与数据连接在一起，并构成了自包含式的处理单元。但在Java中不能定义基本类型(primitive type)，为了能将基本类型视为对象来处理，并能连接相关的方法，Java为每个基本类型都提供了包装类，这样，我们便可以把这些基本类型转化为对象来处理了。这些包装类有:Boolean、Byte、Short、Character、Integer等。值得说明的是，java是可以直接处理基本类型的，但是在有些情况下我们需要将其作为对象来处理，这时就需要将其转化为包装类了。

Java的基本数据类型包括：byte、int、short、long、float、double、char。Java同时也提供了基本数据类型相关的类，实现了对基本数据类型的封装。这些类在java.lang包中，分别是：Byte、Integer、Short、Long、Float、Double和Character类。

1. Byte、Integer、Short、Long类 Byte(byte num) Integer(int num) Short(short num) Long(long num) Byte、Integer、Short和Long对象分别调用byteValue ()、intValue()、shortValue ()和longValue ()方法可以返回该对象含有的基本型数据。

例：要将字符串转换成基本数据类型，几乎都使用“xxx包装类．parsexxx”方式实现，要将包装类转换成基本数据，几乎都是“xxx包装类对象．xxxVaue”方式。 class TestInteger{  public static void main(String[] args){   int w = Integer.parseInt(args[0]);   int h = new Integer(args[1]).intValue();   for(int i = 0; i < w;i++){    StringBuffer str = new StringBuffer();    for(int j = 0 ; j < h;j++){     str.append("*");    }    System.out.println(str.toString());   }  } }

2. Double和Float类 Double类和Float类实现了对double和float基本型数据的类包装。 Double (double num) 创建一个Double类型的对象； 使用Float类的构造方法： Float (float num) 创建一个Float类型的对象。 Double对象调用doubleValue()方法可以返回该对象含有的double型数据； Float对象调用floatValue()方法可以返回该对象含有的float型数据。

3. Character类 Character类实现了对char基本型数据的类包装。 可以使用Character类的构造方法： Character对象调用charValue()方法可以返回该对象含有的char型数据。

作业 习题4.2 习题4.5 习题4.6 习题4.9