第3-1章类及对象.doc

教材第3章“类的封装、继承和多态”主要讲解了JAVA语言面向对象部分的语法、语义及样例程序。
封装、继承和多态是面向对象最核心的内容，对学习JAVA语言及其它面向对象语言都至关重要。由于教材第3章涵盖的内容太多，而且讲解顺序也不太好，所以，本课件将其分解为3章：

第3-1章 类和对象
这一章讲解单个类和对象的构造。
主要内容是类、属性、方法及方法传参、方法的重载、构造方法和析构方法、对象实例化、对象成员的引用等核心的语法及语义。
另外介绍几个零散的JAVA关键字和操作符。
第3-2章 继承
这一章主要内容是：
（1）类的继承关系。
（3）类的组合关系【补充教材】。
第3-3 章 抽象类、接口、多态
主要讲解2个以上类和对象通过对接口（或抽象类）的继承实现多态。这一部分是JAVA语言较高级的内容。

第3-1章 类和对象

本章主要内容:

PART1 类
“类”是对客观世界“一类事物”的抽象描述，或“一类问题”的解决方案。同时，类又是面向对象的可重复使用的封装模块。本部分主要讨论JAVA语言有关类的声明、属性、方法、重载方法、构造方法的语法和语义。
PART2 对象
对象是具体的概念，是对“一类问题”下的某个具体问题的解决方案。可以认为：类是用户自定义的类型，而对象是类的变量。
本部分主要讨论构造方法和析构方法、对象实例化、对象属性和方法的调用、对象的引用特性。
PART3 访问控制关键字public/private/protected的使用

PART4 有关类和对象的其它语法
主要讨论与面向对象核心概念关系不大，但比较常用的几个JAVA语言关键字。
=====================================

PART1 类
本部分主要讨论JAVA语言有关类的声明、属性、方法、重载方法、构造方法的语法和语义。

1 类的定义
（1）语法
JAVA语言定义类最简单的语法是这样的：
class 类名
{ //属性的定义….
//方法的定义….
}
class是JAVA 的关键字，“类名”是用户自定义的标识符，作为编程风格的约定，“类名”首字母应大写。
示例1：
class Car
{
int speed; //属性
float weight, height;
void changeSpeed(int newSpeed) //方法声明
{ //……..} // 方法体
float getWeight()
{ return weight; }
float getHeight()
{return height;}
}

（2）语义
l 类是对“一类事物”的抽象描述，“类名”(比如car)是这类事物的名字
l “类名”是用户自定义的抽象类型名（而不是一个变量名），“类名”的级别与int,float,char等是同级的，它们都代表“一类事物”。
l 类是引用类型的，在赋值和方法（函数）传参上体现的是“地址”特性。
l 属性描述这类事物的静态特性（是什么），一般是名词性的。
l 方法描述这类事物的动态特性（做什么），一般是动词性的。
l “一类事物”的属性集，和围绕该属性集进行的操作（方法集），聚合成了一个类，类描述了“一类事物”。

阅读教材P68-69 “3.1.1类

2 类的属性和方法
类由属性和方法聚合而成，属性又叫类的成员变量，方法又叫类的成员方法。
（1）成员变量：
语法：
成员变量可以是基本类型的，也可以是引用类型的，还可以使用关键字final修饰为常量（作为编程风格的约定，常量名字应该大写）。

示例2：
class Engine{//…..} //声明另一个类
class Car
{
int speed; //属性，基本类型
float weight, height; //属性，基本类型
final int MAX=100; //属性，常量，定义时要直接赋值
int[] a; //属性，数组，引用类型
Engine e; //属性，e是引用类型
//类的其它部分
}

语义：属性描述这类事物的静态特性（是什么），一般是名词性的。
注意：
l 类的成员变量是在类的成员方法之外定义的，参见本课件【示例1】，成员变量的作用域是类，JAVA语言没有“全局变量”的概念。
l 方法体内定义的变量不是类的成员变量，其作用域仅限于定义它的方法内。
l JAVA语言任何的变量和常量，只能在类、方法、语句块内定义，不能在类以外定义。

（2）方法
语法
返回类型 方法名（形参类型 形参名。。。。）
{
//方法体的代码。。
return；//返回方法的运行结果，
//如“返回类型”是void,则不必写return
}

JAVA方法的语法与C语言的“函数”语法的基本一样。JAVA方法的形参不仅可以是基本类型的，还可以是引用类型的。
JAVA方法的返回类型不仅可以是基本类型的，还可以是引用类型的，这一点在JAVA实际编程中很常用。比如：在方法内查询数据库的表，返回若干条记录，这就需要方法返回引用类型。该知识点以后结合例题讲解。

语义:
l 方法描述这类事物的动态特性（做什么），一般是动词性的。
l 方法代表类的一个操作，有时是简单操作（比如赋值），有时实现一个算法（比如排序），但无论如何，从软件设计的角度（不是语法角度）一个方法应该实现一个“单一功能”，而不是多个功能。

注意：
JAVA语言的方法只能在类的内部定义，换句话说，方法必需从属于某个类。
JAVA语言的方法不需要像C语言函数那样“先声明后实现”。

重要问题：重视写函数的能力：
编程初学者最重要的是要学会两件事：
一是要学会使用循环语句，适应计算机解题的“思路”。
二是要学会写方法（函数），实现对功能单一的算法的“封装”，并正确使用形参和实参。
另外，当遇到一个编程问题时，不要先想语法如何如何（解数学题时是想想解题办法还是先想怎样使用数学符号？），而是要脱离具体编程语言，先去做一个“设计”，要先想程序应完成什么功能，如果是复杂程序，将其分解为多个功能，分而治之，上机一点点调试出来。

方法传参
对于方法的编写，形参和实参的传递是难点，也是必需掌握的重点。JAVA方法的形参不仅可以是基本类型的，还可以是引用类型的（数组、类）。当形参是基本类型时，传递规则同C语言基本类型（函数内形参的改变后，不改变实参），当形参是引用类型时，传递规则同C语言指针类型的（函数内形参的改变后，改变实参）。

阅读教材P55“2.4.2参数传递”【例2.13】掌握基本类型和引用类型（数组）方法传参的基本特点。以后结合教材例题进行进一步讲解。【例2.14】和【例2。15】暂时先不用看。

3 方法的重载
（1）语法
在一个类内，允许使用同一个方法名，不同的形式参数个数反复重写同一个方法，如参数个数相同，则参数类型应该不同。但是不允许用不同的返回类型，相同的参数个数（或相同参数类型）重载方法。
阅读教材P59 “2.4.3方法重载”。及P69“3 成员方法重载”

（2）语义
l “封装”是面向对象最基本的特征之一，类本身就是个“封装”。方法的重载是更细致的封装，它可以使用户以为只有一个方法（实际上重载了多个），使用户简化对类的理解，更方便的使用它。
l 方法的重载同时又是类的多态性的体现，它可以使方法名所代表的概念有不同的实现方式。所谓多态为“一种概念，多种实现”，多态是面向对象另一个核心特征。
l 方法的重载是实际编程中常用的技术。

4 main()方法
一个JAVA程序可能有一个或多个类，多个类可能放在同一个或不同的源程序文件中，仅有一个类含有main()方法，程序从main()方法开始启动。
main()方法也是类的一个成员方法，只是该方法有几点特殊性而已，以后陆续讨论。

PART2 对象
类是抽象的概念，是对“一类问题”的解决方案。
对象是具体的概念，是对“一类问题”下的某个具体问题的解决方案。
类是用户自定义的类型，而对象是类的变量。

1 构造方法
每一个JAVA类都含有两种特殊的方法：构造方法和析构方法。
（1）构造方法语法：
l 构造方法没有返回类型，方法名与类名相同。
l 构造方法可以重载，重载规则同普通方法。
l 构造方法只能在实例化对象时调用。

下面是类的构造方法的样例：
public class MyDate
{ int year, month, day //类的属性
MyDate(int y, int m, int d) //构造方法
{year=y; month=m;day=d；} //构造方法初始化类的属性
MyDate() //构造方法，重载
{{year=1970; month=10;day=1；} //构造方法初始化类的属性
}

（2）构造方法语义：
l 类是个抽象类型，类的属性不能有具体的初值（常量属性除外，）而对象是具体的“类变量”，必需要有初值。构造方法用于给属性初值，从而产生某个具体的对象。
l 构造方法可以重载，意味着可以用多种方式给属性初值，这也是多态性的体现。

（3）其它事项
l 程序员可以不写构造方法，这样的话，系统给类默认一个构造方法，该构造方法是无参的。默认构造方法可以给类的属性默认值（例如：属性是数值型的默认为0，引用型的默认为null，null表示一个空对象）。
l 当程序员写了构造方法后（有参的或无参的），默认构造方法无效。
l 一般来说，作为程序功能的要求，程序员需要自已写构造方法，写好构造方法是面向对象编程人员的基本功。
l 构造方法的种类较多，比如拷贝构造方法，以后结合具体例子讲解。
阅读教材P73“3.2.1 构造方法”，本小节的“拷贝构造方法”稍后再讲。

2 析构方法
调用构造方法可以产生对象，而调用析构方法可以销毁对象，使之不占用内存。
（1）析构方法语法：
无论类的名字是什么，析构方法始终是：
public void finalize() //析构方法没有形参
{ //方法体内的其它代码 };

（2）析构方法语义：
可以用：
对象名. finalize()；
的调用方式销毁对象，释放对象占用的内存。

（3）其它事项
l 如果程序员不写析构方法，系统默认一个，在大多数类中，都不需要写析构方法。
l 由于JAVA有内存自动管理功能，所以程序员一般也不需调用析构方法。
l 对于初级JAVA程序员来说，如何写析构方法不是必需掌握的，只需知道析构方法是做什么用的即可。

阅读教材P81“3.2.5 析构方法”

3 对象的实例化
类是抽象的概念，是对“一类问题”的解决方案对象是具体的概念，是对“一类问题”下的某个具体问题的解决方案。可以用代数作类比，数学公式表示对“一类问题”的解决方案，当给公式具体的值时，解决一个具体的值，由此可见，公式表示抽象的问题，具体的值解决具体问题。
类是用户自定义的类型（表示抽象的问题），将类的属性集赋不同的初值，可以得到不同的对象，解决一个个不同的具体问题。
也可以认为，类是对象的模板，从类中可以“复制”出对象，这个复制过程叫对象的实例化。

（1）对象实例化的语法
类名 对象名；//首先定义一个对象，类名是类型，
//对象名是“类的变量”
对象名=new 构造方法名（）；//实例化对象，new是关键字

上面两步可以合并成一步：
类名 对象名=new 构造方法名（）；

示例3：
class MyClass //该类有一个属性两个方法
{ int z;
int m1(int x, int y) {return x+y; }
int m2(int x) { return x*x;}
//其它代码。。。
}
MyClass c1=new MyClass(); //用默认构造方法,实例化对象c1
MyClass c2=new MyClass(); //用默认构造方法,实例化对象c2

（2）对象实例化的语义
l 对象是实体，new表示给对象分配内存，构造方法为属性赋初值，上例中由于调用了默认构造方法，故对象c1,c2 的z值都为0。
l 虽然c1,c2 的z值都为0，但c1和c2不相等（不是同一个对象），因为对象是引用类型，对象名代表其引用（对象在内存中的首地址），由于c1和c2分别用new实例化，因此占用不同的内存空间。

问题：为什么要用构造方法为对象的属性赋初值？
答：先看一个简单例子：
int a; a=10;
int是抽象类型（JAVA预定义的），表示“整数”这一类事物，a是表示“整数”这一类事物下面一个具体整数，应该有值。
比较：
MyClass c1；
c1=new MyClass();
MyClass是抽象类型（用户自定义的），表示“MyClass”这一类事物，c1是表示这一类事物下面一个具体事物，应该有值，对象的值就是类的属性集值的集合。

4 使用对象的属性和方法
对象的属性和方法就是它对所属的类的属性和方法，但由于类不是实体，所以不能直接使用类的属性和方法（static属性和方法例外），而要通过对象去调用它们。
使用对象的属性和方法要用到“.”操作符。语法是：
对象名.属性名；
对象名.方法名；

示例4：
class MyClass //该类有一个属性两个方法
{ int z;
int m1(int x, int y) {return x+y; }
int m2(int x) { return x*x;}
static void main(){
MyClass c1=new MyClass(); //用默认构造方法,实例化对象
MyClass c2=new MyClass();
int a,b;
c1.z=20; //调用c1对象的属性z
c2.z=20; //调用c2对象的属性z
a=c1.m1(100,200); //调用c1对象的方法
b=c2.m1(100,200); //调用c2对象的方法
}}
如上例所示，实例化对象的语法常写在main()方法体内，因为程序从这个方法内启动，程序启动时往往要先实例化对象，教材的例题大都这样写。但实例化对象的语法不是必须要写在main()方法体内，写到其它需要的位置也可以。

程序综合阅读：阅读教材P71【例3-1】该例题将前面讲过的类的定义、对象的实例化、对象成员的访问等知识点，做了综合性演示。问题1：这个例子没有写构造方法，说明它使用了系统默认的构造方法，你能为它重载几个构造方法吗？
问题2：该例public boolean equals(MyDate d)比较2个对象的属性是否一一相等，而不是直接比较2个对象相等，请结合本课件“5对象的引用特性”，解释为什么要这样写？

5 对象的引用特性
类是引用类型，对象自然也是引用类型的“类的变量”。
关于引用类型的特点，在前面介绍数组的引用特性，和方法参数的引用传参已讲过一些。下面对照前面的“示例4”回答几个问题：

问题1：示例4中，c1.z=20和 c2.z=20中的z是一回事吗？c1.m1（）和c2.m1（）呢？
答：c1和c2是同一个类的不同对象，一般情况下（特殊情况以后陆续讨论），各自占用不同的内存空间，对c1属性和方法的调用不影响c2，反之依然。

问题2：下面的代码执行后是什么效果？
MyClass c1=new MyClass();
MyClass c2=new MyClass();
c1=c2;
答:前2句代码c1和c2是不同对象，当c1=c2后，c1和c2是不同名字的同一个对象，原有的c1被JAVA垃圾自动回收机制销毁了。

阅读教材P72“4对象的引用模型”和“5对象的关系运算和比较相等”。
对象的引用特性是JAVA语言的重点和难点，要多下功夫，抓住“对象的引用就是对象在内存中的首地址”这个要点学习。
阅读教材P73“3 拷贝构造方法”，理解样例程序中d2调用了拷贝构造方法复制了d1，但它们是不同空间的2个对象，这是由对象是引用类型决定的。

PART3 访问控制关键字public/private/protected的使用
面向对象有三个最主要的特性：封装、继承和多态。
到目前为止，只讨论到类的封装，封装主要体现在以下方面：
首先，类本身就是一个封装，它封装了一组属性和对这组属性进行操作的一组方法。
其次，封装要尽可能“黑箱化”，即信息隐藏---隐藏不必要暴露给用户的类的信息，这主要不是为了安全，而是为了简化用户对类的理解，让用户更容易的使用类。
JAVA类的信息隐藏主要有两种方式：一是前面讲过的方法重载，二是本部分要介绍的这几个关键字。

封装的主要价值是使类作为一个较大的软件模块（比函数更大），可以重复使用。

本部分介绍private/public/protected关键字的语法和语义，这几个关键字体现了类的封装性（可以对类进行更精致的封装），同时与下一章将要讲的类的继承有密切关系。
这部分内容比较繁琐---因为精致而繁琐。
首先需要注意的是：private/public/protected只用于限制外部的对象（非本类创建的对象）对本类属性和方法的访问，不限制本类创建的对象对本类属性和方法的访问。外部对象可以看作是本类的用户。
阅读教材P75“3.2.3 访问控制”，我们只需关注public和private对类成员的修饰，无需关注protected和“缺省”对类成员的修饰。

实际编程中如何使用上述关键字？重要的是掌握以下设计原则：
原则1：属性尽可能的private，不暴露给外部对象，操作这些属性，要通过非private的get***（）方法去读，或set***（）方法去写，***是通配符。
阅读教材P76“3声明get()和set（）方法存取对象的属性”。
原则1几乎是JAVA程序在编程风格方面的强制性要求。同学们一定要记住。在大三年级学习JAVABEAN（一种JAVA组件技术）时会知道，原则1是写JAVABEAN的强制要求。
原则2：方法的开放，优先考虑private，最后考虑public.
上述2个原则体现了类的封装原则：类应该是个黑箱，暴露在外的功能越少越少，即可以简化用户对类的理解，也有利于安全。

上机提示:
public还可以修饰类，比如public class A{}
一个JAVA源程序文件可以声明多个类，但用public修饰的类只能有一个，而且该类名必需与源程序文件名相同（注意名字对大小写字母敏感），初次上机的同学要注意这一点。

PART4 有关类和对象的其它语法
下面的语法，与面向对象核心概念（封装、继承、多态）关系不大，但比较常用，一并介绍。

1关键字static
static可以修饰类的属性和方法。例如:
示例5
class Car
{ static priductCount; // static属性
int speed; //其它属性
static void changeSpeed(int newSpeed) //static方法声明
{ //……..} // 方法体
float getWeight()
{ return weight; }
}

（1）static修饰的属性
用static修饰的属性叫“静态属性”、“静态成员变量”或“类变量”“类成员”。static属性即可以使用：
对象名.属性名 的方式访问，也可以使用：
类名.属性名 的方式访问，此时不需要预先实例化对象。
其语义为：无论从类中实例化多个对象，这些对象共享使用该静态属性的值，也就是说，这些对象共享使用该静态属性占用的内存。而非静态属性是独立存放在各个对象各自内存中的。

（2）static修饰的方法
用static修饰的方法叫“静态方法”“类成员”。static方法即可以使用：
对象名.方法名（） 的方式访问，也可以使用：
类名.方法名（） 的方式访问，此时不需要预先实例化对象。

阅读教材P76“3.2.4静态成员”

（3）在实际的程序中如何使用static：
原则上，static是不推荐使用的，它与面向对象的设计概念有些不符，此外static属性和方法在程序的生命周期内始终占用内存。

只有在一个类的多个对象确实需要维护一个共享变量时，才使用static属性。
如果在一个方法确实被频繁使用，该方法又不占用过多资源时，才把方法声明为static的。

（4）关于main()方法的讨论
main()方法的原型是：
static void main(String args[])

问题1：为什么main()方法是static的？
答：程序从main()方法启动时，还没有实例化任何对象，main()方法只能是static的（不需要对象即可调用），然后在main()方法内执行一些实例化对象的操作。

问题2：main()方法的形参String args[]是什么意思？如何使用它？
答：从语法上看，String args[]是字符串数组，String是字符串类的名字。从语义上看，String args[]是“程序的参数”。
我们知道，命令行程序的格式是：
命令 参数列表
参数列表可以有多个参数，参数间用空格或其它符号分割。
比如命令行程序：c:> ping 219.231.160.1
ping是程序的名字，219.231.160.1是程序的参数，程序可以根据不同的参数执行不同的功能。
通过使用String args[]，可以获取程序的参数。
阅读教材P10【例1.3】。
问题：C语言main函数也有2个形参，其作用与JAVA的main类似，你怎样按【例1.3】的思路获取其值？

2关键字this
this指代“当前对象”，语法形式为：
this.对象的属性；
this.对象的方法；
实际上对象的属性和方法调用时，如果不写对象名，都隐含了this，如果可以明确知道“当前对象”是谁，可以省略不写this，否则不能省略。
阅读教材P74“1 this引用”

this最常用于构造方法内部，以后结合样例程序说明。

注意：static方法体内（包括main方法）不能使用this，因为this指代对象而不是类，static方法不需要实例化对象即可调用，如果方法体内有this，这个this对象可能还没创建出来。

3操作符instanceof
instanceof被列为JAVA关键字，它实际上是一个操作符，用于判断一个对象是否是从某一个类中实例化出来的，语法是：
对象名 instanceof 类名
instanceof返回true或 false：

示例6：
class A
{ //省略类的属性和方法声明
static void main()
{ A a=new A();
boolean b;
b= a instanceof A; // 返回true
}
}
实际编程中，程序员真的不知道对象从哪个类实例化出来的吗？有时确实需要instanceof去判断一下。实际上instanceof不常用于判断一个对象所属的类是谁（示例6所示），而更常用于判断一个对象的父类、祖父类是谁，这一点后续课程讲到“类的继承”再说。

4 关键字null
在定义变量的时候，如果定义后没有给变量赋值，则Java在运行时会自动给变量赋值（编译器可能会告警，但不会报错）。赋值原则是整数类型int、byte、short、long的自动赋值为0，带小数点的float、double自动赋值为0.0，boolean的自动赋值为false，其他各引用类型（对象、数组）变量自动赋值为null。

程序员也可以把一个对象赋值为null。例如：
class A
{
static void main(String args[])
{ A a=new A(); //对象a有确定引用，不是null
a=null; // a的引用不确定
A aa=new A();
a=aa; //现在 a又确定了
}
}
在实际编程中，null是很常用但又难以捉摸的，一个对象为null不表示这个对象被销毁，这个对象还是存在的，只是“暗示”垃圾自动回收机制可以销毁它，但是否真的销毁，还要看这个null对象和其他对象的关系。程序员可以把自已认为不再需要的对象设为null，让垃圾自动回收机制去定夺是否可以销毁它，这比程序员直接调用析构方法销毁对象要可靠，本课件前面介绍析构方法时讲过，程序员一般不要自行调用析构方法，而是让垃圾自动回收机制去自动调用。

5关键字package
一个JAVA程序项目有很多类，每个类编译成一个字节码文件，应该有一种办法管理这些文件，以免造成混乱。
JAVA使用“包”的概念，一个包的名字对应一个文件夹。
package用于声明你的程序打到那个包里。包名可以是自定义的，也可以是已有的。
阅读教材P11“1.3.3包”。P13【例1.4】讲解了打包的方法，但是用JAVA命令行工具操作的，同学们可以用eclipse实验打包操作。

6 关键字import
阅读教材P13“6 导入包”。
import与C语言include的作用类似，但也有区别:
import是JAVA关键字，而include不是C语言关键字，是C语言的预处理指令。
import导入的是包的JAVA字节码文件（文件扩展名是.class），include导入的是库的源程序。

推荐实验：
（1）你自已按P13【例1.4】开发的包，然后用import引用它。
（2）在C语言中编写一个.h头文件，然后用include引用它。

小知识：
一个JAVA项目可能有多个源程序文件，一个源程序文件可能有多个类，但编译成字节码文件后，一个类占用一个字节码文件。比如一个源程序文件有3个类，编译后就有3个字节码文件（上机时可以观察）。
一个项目如此多的字节码文件，使程序的发布很不方便，可以把这些字节码文件压缩成一个JAR文件，JAR是JAVA程序发布的主要方式。教材P15“10包可以压缩成JAR文件”简略提到，详细信息可以上网查询。

推荐实验：
写一个含有多个类的JAVA源程序文件，编译后查看生成了几个字节码文件（.class）

PART5 程序综合阅读理解
在本章最后，阅读教材几个样例程序，回顾本章学过的语法、语义、设计概念，请同学们在教材上做笔记。
P71【例3.1】
P72【例3.2】
P81【例3.3】该例的“对象深拷贝”不作为课程要求掌握的知识点。