第三讲 Java与面向对象技术 1、面向对象的概念 2、Java中的类、方法和变量 3、Java名字空间及访问规则 5、对象的构造方法

1、面向对象的概念 所谓面向对象的方法学，就是使我们分析、设计和实现一个系统的方法尽可能地接近我们认识一个系统的方法。包括： 面向对象的分析（OOA, Object-Oriented Analysis） 面向对象的设计（OOD, Object-Oriented Design） 面向对象的程序设计(OOPL, Object-Oriented Program) 面向对象技术主要围绕以下几个概念: 对象、抽象数据类型、类、类型层次（子类）、继承性、多态性。

1、面向对象的概念 ——对象 对象有两个层次的概念： 现实生活中对象指的是客观世界的实体； 程序中对象就是一组变量和相关方法的集合，其中变量表明对象的状态，方法表明对象所具有的行为。 变量 方法

1、面向对象的概念 ——对象 抽象数据类型 Class Car { int color_number; int door_number; int speed; void brake() { … } void speedUp() {…} void slowDown() { … } } 抽象数据类型 现实生活中的对象 可以将现实生活中的对象经过抽象，映射为程序中的对象。对象在程序中是通过一种抽象数据类型来描述的，这种抽象数据类型称为类（Class）。

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

1、面向对象的概念 ——类 …… Car car1; Car car2; … … Car carN;

1、面向对象的概念 ——类 变量：指对象的所知道的状态。 方法：指对象的功能单元。 消息 软件对象通过相互间传递消息来相互作用和通信，一个消息由三部分组成: 1. 接受消息的对象 2. 接收对象要采取的方法 3. 方法需要的参数 对象B 对象 A 消息

1、面向对象的概念 ——类 一个例子 class Hello { } 变量 方法showString() 方法changeString() private String s； public void showString() System.out.println(s); public void changeString(String str) s = str; 变量 方法showString() 方法changeString() 一个例子 在程序中所操作的对象是类的一个实例。 创建一个对象： Hello obj=new Hello(); 调用方法： obj.showString(); 调用对象的方法相当于给对象发送消息，收到消息的对象通过改 变自身的状态或者向其它对象发送消息来响应消息。

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

1、面向对象的概念 ——类 class BirthDate { public int day,month,year; public int tomorrow() …… } BirthDate mybirth, yourbirth; 类中不但有变量，还有与之相关的操作所定义的方法。将变量和方法封装在一个类中，可以对成员变量进行隐藏，外部对类成员的访问都通过方法进行，能够保护类成员不被非法修改。 BirthDate date; 已知当前日期对象，求第2天的日期对象：date.day =date.day+1; 如果date.day已经为31，操作结果是非法状态。可以定义一个成员方法tomorrow()，求第2天的日期对象。外部要获得当前日期的后一天时，只要调用： date.tomorrow();

1、面向对象的概念 ——封装 封装把对象的所有组成部分组合在一起 封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 私有数据 方法 数据 对象A 对象B 公有数据

1、面向对象的概念 ——子类 子类是作为另一个类的扩充或修正而定义的一个类。 bicycle (super class) sub class Mountain bikes Racing bikes Tandem bikes sub class

1、面向对象的概念 ——继承 继承是子类利用父类中定义的方法和变量，就像它们属于子类本身一样。 class Car { int color_number; int door_number; int speed; public void push_break() … } public void add_oil() { … } class Trash_Car extends Car { double amount; public void fill_trash() … }

1、面向对象的概念 ——方法的覆盖 方法的覆盖 覆盖使得在子类中可以重新定义父类中已有的方法，从而体现出子类自己的行为。 class Car { int color_number; int door_number; int speed; public void push_break() { speed = 0; } public void add_oil() { … } class Trash_Car extends Car { double amount; public void fill_trash() { … } public void push_break() speed = speed – 10; }

1、面向对象的概念 ——方法的重载（多态性） 重载指得是在同一个类中至少有两个方法用同一个名字，但有不同的参数。 void show(int int_num) void show(double double_num) void show(int int_num, float float_num) 123 1.23 123,1.23 例如对于StringBuffer类，它有方法 public StringBuffer append(int i); public StringBuffer append(double d); public StringBuffer append(String s); public StringBuffer append(char[] str, int offset, int len);

2、Java中的类、方法和变量 类、方法、变量定义的语法规范 对象的创建和使用 继承、覆盖、重载、多态等概念 内嵌类(inner class)

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

2、Java中的类、方法和变量 ——变量定义的语法规范 变量的定义及修饰字 [变量修饰字] 变量数据类型 变量名1,变量名2[=变量初值]…; [public | protected | private ] [static] [final ] [transient ][volatile] 成员变量的类型可以是Java中任意的数据类型，包括简单类型，类，接口，数组。在一个类中的成员变量应该是唯一的。

2、Java中的类、方法和变量 ——变量定义的语法规范 方法的定义及修饰字 [方法修饰字] 返回类型 方法名称(参数1,参数2,…) [throws exceptionList] { …(statements;) //方法体：方法的内容 } [public | protected | private ] [static] [final | abstract] [native] [synchronized] 返回类型可以是任意的Java数据类型，当一个方法不需要返回值时，返回类型为void。 参数的类型可以是简单数据类型，也可以是引用数据类型（数组、类或接口），参数传递方式是值传递。 方法体是对方法的实现。它包括局部变量的声明以及所有合法的Java指令。局部变量的作用域只在该方法内部。

2、Java中的类、方法和变量 ——参数的传递方式是值传递 class A { static void change(String s, StringBuffer sb) { s = “aaaa”; //此语句不起作用 sb.setLength(0); sb.append(“aaaa”); } public static void main(String args[]) { String s = “bbbb”; StringBuffer sb = new StringBuffer(“bbbb”); change(s, sb); System.out.println(s); System.out.println(sb); 输出结果： bbbb aaaa

2、Java中的类、方法和变量 ——一个简单的类 一个简单的类 class Car { int car_number; class CarDemo { public static void main(String args[]) Car Democar=new Car(); DemoCar.set_number(3838); DemoCar.show_number(); } 一个简单的类 class Car { int car_number; void set_number(int car_num) car_number=car_num; } void show_number() System.out.println (“My car No. is : ”+car_number); My car No. is : 3838

2、Java中的类、方法和变量 ——对象 （1）对象的生成 通过new操作符生成一个对象；例如： Car demoCar; demoCar = new Car(); （2）对象的构造过程 为对象开辟空间，并对对象的成员变量进行缺省的初始化； 对成员变量进行指定的初始化； 调用构造方法。

2、Java中的类、方法和变量 ——对象 （3）对象的使用 对象的使用是通过一个引用类型的变量来实现，包括引用对象的成员变量和方法，通过运算符 · 可以实现对变量的访问和方法的调用。例如： BirthDate date; int day; day = date.day; //引用date的成员变量day date.tomorrow(); //调用date的方法tomorrow()

2、Java中的类、方法和变量 ——继承 类的继承 class Car { int car_number; void set_number(int car_num) car_number=car_num; } void show_number() System.out.println (“My car No. is :”+car_number);

2、Java中的类、方法和变量 ——继承 class TrashCar extends Car { int capacity; void set_capacity(int trash_car_capacity) capacity=trash_car_capacity; } void show_capacity() System.out.println(“My capacity is: ” + capacity);

2、Java中的类、方法和变量 ——继承 class CarDemo { public static void main(String args[]) TrashCar demoTrashCar = new TrashCar(); demoTrashCar.set_number(4949); demoTrashCar.show_number(); demoTrashCar.set_capacity(20); demoTrashCar.show_capacity(); } 继承的方法 新增加的方法 Car是父类，TrashCar是子类。TrashCar中继承了Car中的两个方法，同时又增加了两个新方法。

2、Java中的类、方法和变量 ——继承 继承性是面向对象程序设计语言的另一基本特征，通过继承可以实现代码的复用。继承而得到的类为子类，被继承的类为父类，父类包括所有直接或间接被继承的类。Java中不支持多重继承。通过在类的声明中加入extends子句来创建一个类的子类： class SubClass extends SuperClass { …… } 如果缺省extends子句，则该类为java.lang.Object的子类。 子类可以继承父类中访问权限设定为public、 protected、 default的成员变量和方法，但是不能继承访问权限为private的成员变量和方法。

常犯的错误A有一个B吗? 例如让汽车轮子成为汽车的子类是错误的 2、Java中的类、方法和变量 ——继承 何时选择继承? 一个很好的经验：“B是一个A吗?” 如果是则让B做A的子类. 常犯的错误A有一个B吗? 例如让汽车轮子成为汽车的子类是错误的

2、Java中的类、方法和变量 ——继承 Shape Point Circle Cylinder Shape Point Circle 在更多的时候，组成（聚集）关系比继承更能使系统具有高度的灵活性，可维护性，并且提高系统的可重用性。

2、Java中的类、方法和变量 ——覆盖 类方法的覆盖 方法覆盖即指在子类中重新定义父类中已有的方法。 class Car { int color_number; int door_number; int speed; public void push_break() { speed = 0; } public void add_oil() { … } class Trash_Car extends Car { double amount; public void fill_trash() { … } public void push_break() speed = speed – 10; }

2、Java中的类、方法和变量 ——覆盖 覆盖方法的调用 public class DemoCar { public static void main( String args[ ] ) Car aCar = new Trash_Car( ); aCar. push_break( ); } 在这里， 类Trash_Car中的push_break( )方法将被调用。

2、Java中的类、方法和变量 ——覆盖 方法覆盖时应遵循的原则 （1）覆盖后的方法不能比被覆盖的方法有更严格的访问权限。 （2）覆盖后的方法不能比被覆盖的方法产生更多的例外。

2、Java中的类、方法和变量 ——重载 类方法的重载 方法重载即指多个方法可以享有相同的名字。但是这些方法的参数必须不同，或者是参数个数不同，或者是参数类型不同。 例如，要打印不同类型的数据，int, float, String,不需要定义不同名的方法： printInt(int); printFloat(float); printString(String)。 利用方法重载，只需要定义一个方法名：println()，接收不同的参数： println(int); println(float); println(String); StringBuffer vs. ResultSet

2、Java中的类、方法和变量 ——多态性 多态性 类方法的重载是一种多态性。除此之外，多态性还可以是指在程序中需要使用父类对象的地方，都可以用子类对象来代替。 例如： public class Employee extends Object {……} public class Manager extends Employee 则： Employee e = new Manager(); //合法语句 通过 instanceof 可以判断父类引用所引用的对象实例的实际类型。

2、Java中的类、方法和变量 ——成员变量的隐藏 可以用方法来实现对成员变量的隐藏： 设置变量方法：setVariable() 获取变量方法：getVariable() class Sample { protected int x; …… void setX(int var ) x = var; } int getX() return x;

2、Java中的类、方法和变量 ——对象状态的确定 在Java语言中，提供了操作符instanceof用来判断对象是否属于某个类的实例。 public void method (Employee e) { if ( e instanceof Manager ) …//do something as a Manager } else if ( e instanceof Contractor ) …//do something as a Contractor else … //do something else Employee Manager Contractor

2、Java中的类、方法和变量 ——内嵌类（inner class） 在一个类的内部声明的类，称为内嵌类。 内嵌类只能在包含它的类中使用，同时它可以看作是该包含类的一段特殊代码，可以直接使用该包含类的变量和方法。 内嵌类编译后也会形成一个单独的class，但它附属于其包含类。 public class Stack { private Vector items; ...//code for Stack's methods and constructors not shown... public Enumeration enumerator() { return new StackEnum(); } class StackEnum implements Enumeration { int currentItem = items.size() - 1; public boolean hasMoreElements() { return (currentItem >= 0); public Object nextElement() { if (!hasMoreElements()) throw new NoSuchElementException(); else return items.elementAt(currentItem--); Stack$StackEnum.class

3、Java名字空间及访问规则 每个类都拥有自己的名字空间，即指类及其方法和变量可以在一定的范围内知道彼此的存在，可以相互使用。对类而言： abstract类：不能直接产生属于这个类的对象； final类：不能被其他任何类所继承(安全的考虑)； public类：不但可以被同一程序包(package)中的其它类使用，别的程序包中的类也可以使用； friendly类(缺省，包访问类)：只能被本程序包中的其它类使用，不能被别的程序包中的类使用。

3、Java名字空间及访问规则 当一个类可以被访问时，对类内的成员变量和成员方法而言，其应用范围可以通过施以一定的访问权限来限定。 同一个类中 同一个包中 不同包中的子类 不同包中的非子类（任意类） private ★ default ★ ★ protected ★ ★ ★ public ★ ★ ★ ★

3、Java名字空间及访问规则 public: 任何其它类、对象只要可以看到这个类的话，那么它就可以存取变量的数据，或使用方法。 protected：同一类，同一包可以使用。不同包的类要使用，必须是该类的子类。 private：不允许任何其他类存取和调用。 friendly(default，前边没有修饰字的情况)：在同一程序包中出现的类才可以直接使用它的数据和方法.

3、Java名字空间及访问规则 当子类中的变量名与父类的相同，父类的变量被遮盖。 data_a=5 A.data_a=3 class A class B extends A { { int data_a=3; int data_a = 5; } } class C extends B { void print_out() System.out.println(“data_a= ”+data_a); System.out.println(“A.data_a= ”+A.data_a); System.out.println(“B.data_a= ”+B.data_a); } class demo public static void main(String args[]) C c = new C(); c.println_out(); data_a=5 A.data_a=3 B.data_a=5

3、Java名字空间及访问规则 final在类之前 final在方法之前 final在变量之前 —— final：到此为止 表示该类是最终类，不能再被继承。 final在方法之前 表示该方法是最终方法，该方法不能被任何派生的子类覆盖。 final在变量之前 表示变量的值在初始化之后就不能再改变；相当于定义了一个常量。

3、Java名字空间及访问规则 —— static：类变量和类方法 static 在变量或方法之前，表明它们是属于类的，称为类方法（静态方法）或类变量（静态变量）。若无static修饰，则是实例方法和实例变量。 object a char data object c Object b static int share_data object d 类变量在各实例间共享 class ABCD { char data; static int share_data; } class Demo ABCD a,b,c,d;

3、Java名字空间及访问规则 —— static：类变量和类方法 public class StaticVar { public static int number ＝ 5; } public class OtherClass public void method() int x = StaticVar.number; static { number =5; }

3、Java名字空间及访问规则 —— static：类变量和类方法 类方法则相当于C语言中的全局函数，其他的类也可以直接通过类名来访问类方法。（Java程序的入口方法main()就是一个类方法） public class GeneralFunction { public static int addUp(int x,int y) return x+y; } public class UseGeneral public void method() int a = 9; int b =10; int c = GeneralFunction.addUp(a,b);

同一个类的实例方法可以访问该类的类变量和类方法； 3、Java名字空间及访问规则 —— static：类变量和类方法 同一个类的实例方法可以访问该类的类变量和类方法； 而类方法只能访问该类的类变量和类方法，不能直接访问实例的变量和方法。

3、Java名字空间及访问规则 —— static：类变量和类方法 不正确的引用 class StaticError { String mystring=“hello”; public static void main(String args[]) System.out.println(mystring); } 编译时错误信息： nonstatic variable mystring cannot be referenced from a static context “System.out.println(mystring);”。 为什么不正确：只有对象的方法可以访问对象的变量。

3、Java名字空间及访问规则 解决的办法 —— static：类变量和类方法 1. 将变量改成类变量 class NoStaticError { static String mystring=“hello”; public static void main(String args[]) System.out.println(mystring); }

3、Java名字空间及访问规则 解决的办法 —— static：类变量和类方法 2. 先创建一个类的实例 class NoStaticError { String mystring=“hello”; public static void main(String args[]) NoStaticError noError; noError = new NoStaticError(); System.out.println(noError.mystring); }

4、Java中的抽象类、接口和程序包 ——抽象类与抽象方法 抽象类：用abstract关键字来修饰一个类时，该类叫做抽象类； 抽象类必须被继承。 抽象类不能被直接实例化。它只能作为其它类的超类，这一点与最终类（final类）正好相反。 抽象方法：用abstract来修饰一个方法时，该方法叫做抽象方法。 抽象方法必须被重写 抽象方法只有声明，不能有实现。 定义了抽象方法的类必须是抽象类。 abstract returnType abstractMethod ( [paramlist] );

4、Java中的抽象类、接口和程序包 ——抽象类与抽象方法 两个类Circle和Rectangle，完成相关参数的计算 class Circle { public float r; Circle(float r) this.r = r; //this指"这个对象的" } public float area() return 3.14*r*r; class Rectangle { public float width,height; Rectangle (float w, float h) width = w; //这里不需"this" height = h; } public float area() return width*height;

4、Java中的抽象类、接口和程序包 ——抽象类与抽象方法 假设有若干个Circle，以及若干个Rectangle，希望计算它们的总面积，直截了当的做法是将它们分别放到两个数组中，用两个循环，加上一个加法，这种做法是不漂亮的。 如果还有其它形状：Triangle，Ellipses等，上述方法显得“累赘”。我们希望有一种统一的表示，例如用一个数组shape[]，接受所有的形状，然后用： for (i=0; i<shape.length; i++) { area_total += shape[i].area(); }

4、Java中的抽象类、接口和程序包 ——抽象类与抽象方法 abstract class Shape { abstract float area(); } class Rectangle extends Shape public float width,height; Rectangle (float w, float h) width = w; //这里不需"this" height = h; public float area() return width*height; class Circle extends Shape public float r; Circle(float r) this.r = r; //this指"这个对象的" return 3.14*r*r;

4、Java中的抽象类、接口和程序包 ——接口 接口（interface）就是方法定义和常量值的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有方法的实现。 通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。 通过接口可以指明多个类需要实现的方法。 通过接口可以了解对象的交互界面，而不需了解对象所对应的类。

4、Java中的抽象类、接口和程序包 ——接口 接口的定义： { …… //常量定义和方法定义 } [public] interface interfaceName [extends SuperInterfaceList] { …… //常量定义和方法定义 } 接口（interface）作为特殊形式的抽象类，和类（class）在使用上具有类似的约束。 与类继承不同，一个接口可以继承多个父接口 一个public接口只能定义在同名的.java文件中

4、Java中的抽象类、接口和程序包 ——接口 用implements子句来表示一个类使用某个接口。 在类体中可以使用接口中定义的常量，而且必须实现接口中定义的所有方法。 利用接口可实现多重 继承，即一个类可以实现多个接口，在implements子句中用逗号分隔。 接口的作用和抽象类相似，只定义原型，不直接定义方法的内容。 接口中的方法和变量必须是public的。

4、Java中的抽象类、接口和程序包 ——接口 interface Collection { int MAX_NUM=100; class FIFOQueue implements Collection { void add ( Object obj ) …… } void delete( Object obj ) Object find( Object obj ) int currentCount() interface Collection { int MAX_NUM=100; void add (Object obj); void delete (Object obj); Object find (Object obj); int currentCount ( ); }

4、Java中的抽象类、接口和程序包 ——接口 <<interface>> Collection AbstractCollection AbstractList <<interface>> List LinkedList ArrayList java.util类包中的一些接口

4、Java中的抽象类、接口和程序包 ——程序包（类包） 由于Java编译器为每个类生成一个字节码文件，且文件名与类名相同，因此同名的类有可能发生冲突。为了解决这一问题，Java提供包来管理类名空间。 程序包相当于其它语言中的库函数。

package pkg1[.pkg2[.pkg3…]]; 4、Java中的抽象类、接口和程序包 ——程序包（类包） 打包 Java中用package语句来将一个Java源文件中的类打成一个包。package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为： package pkg1[.pkg2[.pkg3…]]; Java编译器把包对应于文件系统的目录管理，package语句中，用 . 来指明目录的层次。

4、Java中的抽象类、接口和程序包 ——程序包（类包） package myclass.graphics; class Square {…;} class Circle {…;} class Triangle {…;} Square.java package myclass.graphics; 这条语句指定这个包中的文件存储在目录 path/myclass/graphics 下。 包层次的根目录path是由环境变量CLASSPATH来确定的。

javac [-d destpath] Square.java ——程序包（类包） 编译和生成包 在前面Square.java中已定义了 myclass.graphics，编译时可以采用如下方式： javac [-d destpath] Square.java 则编译器会自动在destpath目录下建立子目录myclass/graphics ，并将生成的.class文件都放到destpath/ myclass/graphics下。 destpath应该是环境变量CLASSPATH中的一个。

import package1[.package2…].(classname |*); 4、Java中的抽象类、接口和程序包 ——程序包（类包） 为了能使用Java中已提供的类，我们需要用import语句来引入所需要的类。 import package1[.package2…].(classname |*); 例如： import myclass.graphics.*； import java.io.*； myclass path Square graphics 由环境变量CLASSPATH确定

5、对象的构造方法 构造方法(Constructor)是一种特殊的方法。Java中的每个类都有构造方法，用来初始化该类的一个新的对象。构造方法具有和类名相同的名称，而且不返回任何数据类型。系统在产生对象时会自动执行。 构造方法应包含的内容： 定义一些初值或内存配置工作； 一个类可以有多个构造方法(重载)，根据参数的不同决定执行哪一个； 如果程序中没有定义构造方法，则创建实例时使用的是缺省构造方法，它是一个无内容的空方法。

5、对象的构造方法 public class Employee{ private String name; private int salary; public Employee(String n,int s) { name = n; salary = s; } public Employee(String n){ this(n,0); public Employee() this(“Unknown”);

5、对象的构造方法 this this指向自己的引用，它的一个主要作用是要将自己这个对象当作参数，传送给别的对象中的方法。 class Circle { int r; Circle(int r) this.r=r; } public area() return r*r*3.14; class ThisClass { public static void main() Bank bank=new Bank(); bank.someMethod(this); }

5、对象的构造方法 super super指这个对象的父类。super可以用来引用父类中的(被覆盖的)方法、(被隐藏的)变量及构造方法。 public class apple extends fruits { public apple(int price) super(price); super.var = value; super.method(paraList); } 以上程序表示使用父类的构造方法生成实例，super必须是子类构造方法的第一条语句。

5、对象的构造方法 Finalize方法 在对对象进行垃圾收集前，Java运行时系统会自动调用对象的finalize() 方法来释放系统资源。该方法必须按如下方式声明： protected void finalize() throws throwable {……} finalize()方法是在java.lang.Object中实现的，在用户自定义的类中，它可以被覆盖，但一般在最后要调用父类的finalize()方法来清除对象所使用的所有资源。 { …… //释放本类中使用的资源 super.finalize(); }

练习 1、上机练习Java面向对象的各种特性。 2、结合Tutorial及其实例来学习Java。 3、尝试使用Java类包中提供的各种类。

下一节课主要内容 1、数组 2、向量 3、字符处理 4、算法与数据结构

下课！