JAVA 第四讲 面向对象程序设计 崔震海 2004.3.19

面向对象主要特征 封装 (Encapsulation) 继承 (Inheritance) 多态 (Polymorphism)

源文件布局 基本语法： [<package语句>] 注意：一个源文件至多有一个public类，且文件名必须和此共有类名一致 [<import语句>] <类的定义>+ 注意：一个源文件至多有一个public类，且文件名必须和此共有类名一致

软件包 包帮助管理巨大的软件系统 包可以包含类和子包 JDK中java包的结构: 从逻辑上讲,是一组相关类的集合 从物理上讲,同包即同目录 JDK中java包的结构: lang,io,awt-event,sql,net,applet,util

package语句 基本语法：package <顶包名>[.<子包名>]*; 例子：package shipping.reports; 规定包的声明在源文件的开头部分 每个源文件只有一个包的声明 若没有package语句，则此类“属于”默认包（是一个无名包） 包名可以分几级，且用点分隔

import语句 基本语法：import <包名>[.<子包名>].<类名>; 领先于所有的类定义 或 abc.def.A a=new abc.def.A(); 领先于所有的类定义 为编译器指明了寻找类的途径 注意：使用“*”的import语句不影响性能

设 置 使用一个包中的类时,必须指明包含这个类的包,只有正确设置环境变量classpath,解释器才能找到指定的类. 设 置 使用一个包中的类时,必须指明包含这个类的包,只有正确设置环境变量classpath,解释器才能找到指定的类. setclasspath= d:\javacls; c:\jdk1.3\lib

类与对象 类的定义: 类可以将数据和函数封装在一起，其中数据 表示类的属性，函数表示类的行为。定义类 就是要定义类的属性与行为（方法）。 面向对象的设计重点是类而不是对象

类的典型案例

class Person { int age; void shout() System.out.println("oh,my god!my age is "+age); }

类中成员的访问 其中定义了一个Person类，该类有一个属性age，一个方法shout。类的属性叫类的成员变量，类的方法也叫类的成员函数。 一个类中的方法可以直接访问同类中的任何成员（包括成员变量和成员函数），如shout方法可以直接访问同一个类中的成员变量age。

访问控制 如果一个方法中有与成员变量同名的局部变量，该方法中对这个变量名的访问是局部变量，而不再是成员变量。如： class Person { int age; void shout() int age=40;//一定要被赋值否则无法通过编译 System.out.println("oh,my god!mu age is "+age); } 再这里，shout方法的System.out.println("oh,my god!my age is "+age);语句所访问的age就不再是成员变量age，而是shout 方法中定义的局部变量age。

对象的产生与使用 要创建新的对象，需要使用new关键字和想要创建的对象的类名，如： Person p1=new Person(); 等号左边以类名person作为变量类型定义了一个变量p1,来指向等号右边通过new关键字创建的一个Person类的实例对象，变量P1就是对象的引用句柄，对象的引用句柄是stack(堆栈)中分配的一个变量，对象本身是再heap(堆)中分配的。 注意： new语句的类名后一定要跟一对圆括号（）。

变量的初始化之前是不能用的。当创建一个对象时， 会对其中各种类型的成员变量按下表自动进行初始化

对象的引用 创建新的对象之后，我们就可以用“对象名.成员变量”的格式，来访问对象的成员（包括属性和方法），下面的代码演示了Person类对象的产生 和使用方式。 class TestPerson { public static void main(String[] args) Person p1=new Person(); Person p2=new Person(); p1.age=-30; p1.shout(); p2.shout(); } 运行结果如下： oh,my god!my age is -30 oh,my god!my age is 0 本例创建了两个Person类的实例对象，每个对象都被单独的实例化，不会被所 有的对象共享，改变了p1的age属性，不会影响p2的属性。

生命周期 每个创建的对象都有自己的生命周期,对象只能在自己有效的生命周期内被使用,当没有引用变量指向某个对象时,这个对象就变成了垃圾,不能在被使用. { Person p1=new Person();//Person 对象被引用 ….. } 在执行完这个代码块后,引用这个对象的句柄p1已经无效,Person对象不能再被任何句柄所引用,变为垃圾

对象的比较 class Compare { public static void main(String[] args) String str1=new String("abc"); String str2=new String("abc"); String str3=str1; if(str1==str2) System.out.println("str1==str2"); else System.out.println("str!=str2"); if(str1==str3) System.out.println("str1==str3"); System.out.println("str1!=str3"); } 程序运行的结果时： str1!=str2 str1==str3

equals（）的用法 class Compare { public static void main(String[] args) String str1=new String("abc"); String str2=new String("abc"); String str3=str1; if(str1.equals(str2)) System.out.println("str1==str2"); else System.out.println("str!=str2"); if(str1.equals(str3)) System.out.println("str1==str3"); System.out.println("str1!=str3"); } 程序运行的结果是： str1==str2 str1==str3

匿名对象 将Person p1=new Person(); p1.shout(); 改为： new Person().shout(); 匿名对象的应用： 1.此对象只需要被调用一次 2.将匿名对象作为实参传递给另一个函数调用。

Public static void getSomeOne(Person p) { …… } getSomeOne (new Person() );

实现类的封装性 用private关键字来设置访问权限 如： class Person { private int age; public void shout() System.out.println(age); } class TestPerson public statci void main(Stringp[] args) new Person().age=-30; 编译时会有错误： E:\person.java:13:age has private access in Person new person().age=-30; ^ 1 Error

属性和方法的权限 本类 同包类 非同包子类 非同包非子类 public √ Protected (default) private

可以用getXXX()和setXXX()来实现类的封装 class Person { private int age; public void setAge(int i) if(i<0||i>130) reurn; age=i; } public class TestPerson public static void main(String[] args) Person p1=new Person(); p1.setAge(3); P1.setAge(-6); p1.setAge(200); System.out.println(p1.getAge());

通过将类的成员变量声明为私有的( private),再提供一个或多个公有的(public)方法实现对该成员变量的访问或修改 目的: 隐藏类的实现细节 让使用者只能通过事先制定好的方法来访问数据,可以方便地加入控制逻辑,限制对属性的不合理操作. 便于修改,增强代码的可维护性 可进行数据检查

构造函数 class Person { public Person() System.out.println("the constructor 1 is calling!"); } private int age=10; public void shout() System.out.println("age is"+age); class TestPerson public static void main(String[] args) Person p1=new Person(); p1.shout(); Person p2=new Person(); p2.shout(); 运行结果如下： the Constructor 1 is calling! age is 10

它具有与类相同的名称 它不含返回值 它不能在方法中用return 语句返回一个值 为类成员变量进行初始化工作,产生一个对象时,构造方法会被自动调用,完成初始化. Public void Person() 不是构造函数,不被自动调用

构造函数的重载 class Person { private int age=-1; private String name="uknown"; public Person() System.out.println("the constructor 1 is calling!"); } public Person(String n) name=n; System.out.println("name is "+name)； public void shout() System.out.println("listen to me!"); class TestPerson public static void main(String[] args) Person p1=new Person(); p1.shout(); System.our.println(); Person p2=new Person("tong"); p2.shout(); 运行结果如下： the Constructor 1 is calling! listen to me! name is tong

this 引用句柄 class A { String name; public A(String x) name =x; } public void func1() System.out.println("func1 of "+name +"is calling!"); public void func2() A a2=new A("a2"); this.func1();//使用this关键字调用func1方法 a2.func1(); class TestA public static void main(String[] args) A a1=new A("a1"); a1.func2(); 运行结果为： func1 of a1 is calling! func2 of a2 is calling!

函数的参数传递 基本数据类型的传递 class PassValue { public static void main(String[] args) int x=5; change(x); System.out.println(x); } public static void change(int x) x=3; 结果时什么？

引用数据类型 class PassRef { int x; public static void main(String[] args) PassRef obj=new PassRef(); obj.x=5; chang(obj); System.out.println(obj.x); } public static void change(PassRef obj) obj.x=3; 运行结果时什么？ ***

5 显然,change方法从开始到结束没有改变main方法中的X值,所以为5.基本类型的变量作为实参传递,并不能改变这个变量的值.

static关键字 首先只有通过NEW产生对象才能让系统分配内存空间,供外部调用,我们希望不论是否产生了对象或多少对象,在内存中只有一份. Static String country=“中国” 静态变量相当于其他语言的全局变量. 不需要产生类的对象,只用类名就可以引用 不能把任何方法中的变量声明为静态变量. 只要类存在,静态变量就存在.

static关键字 静态变量 class Chinese { static String country="China"; String name; int age; void SingOurCountry() System.out.println("oh,my dear "+country); } class TestChinese public static void main(String[] args) System.out.println("Chinese country is "+Chinese.country);//类名.成员名 Chinese ch1=new Chinese(); System.out.println("Chinese country is "+ch1.country);// 对象名.成员名

静态方法 class Chinese { static void sing() System.out.println("ar!"); } void SingOurCountry() System.out.println("oh,my dear "+country);//类中成员直接访问静态方法 class TestChinese public static void main(String[] args) Chinese.sing();//类名.成员名 Chinese ch1=new Chinese(); ch1.sing();// 对象名.成员名 ch1.singOurCountry();

在静态方法里只能直接调用其他的静态成员,不能直接访问类中的非静态成员,因为非静态需要创建实例. 静态方法不能以任何形式引用this.super关键字 main() 方法是静态的

静态代码块 一个类中可以使用不包含在任何方法体中的静态代码块,当类被载入时,静态代码块被执行一次,用来进行类属性的初始化.

静态代码块 class StaticCode { static String country; static country="Chinese"; System.out.println("static code is loading!"); } class TestStaticCode System.out.println("TestStaticCode is loading!"); public static void main(String[] args) System.out.println("begin executing main method"); new staticCode();//仅运行一次 new staticCode()l; 运行结果如下： TestStaticCode si loading begin executing main Method static Code is loading!

单太设计模式 设计模式是在大量的实践中总结的,我们要多练习和学习. 就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例,并且该类只提供一个取得对象实例的方法. 首先将类的构造方法的访问权限设为private 就不能在外部产生对象,只能调用该类的某个静态方法去访问静态变量.

Public class TestSingle { private static final TestSingle onlyone =new TestSingle(); public static Testsingle getTestsingle() return onlyOne; } private TestSingle(){} 我们在外面只能调用TestSingle.getTestSingle() 方法获得 TestSingle的对象

内部类 在一个类内部定义类,就是嵌套类,叫内部类或内置类. 嵌套类可以访问嵌套它的类的成员,但嵌套类的成员却不能被嵌套它的类直接访问. 嵌套类的使用范围仅限于这个类的内部,内部类可以声明为private protected 使程序变得更为紧凑,程序更为模块化. 当一个类中的程序代码要用到另外一个类的实例对象,而另外一个类中的程序代码要访问第一个类的成员,将另外一个类做成第一个类的内部类,程序代码就要容易编写.

内部类 内中定义内部类 class Outer { int outer_i=10; void test() Inner in=new Inner(); in.display(); } class Inner void display() System.out.println("display:outer_i= "＋outer_i); class InnerClassDemo public static void main(String[] args) Outer outer=new Outer(); outer.test(); 打印结果如下： display:outer_i=10

方法中定义内部类 class Outer { int outer_i=10; void test() for(int i=0;i<5;i++) class Inner void display() System.out.println("display:outer_i "+outer_i); } Inner inner=new Inner(); inner.display(); class InnerClassDemo public static void main(String[] args) Outer outer=new Outer(); outer.test(); 运行结果如下： display:outer_i=10

在方法中定义的内部类只能访问方法中的final类型的局部变量,因为用final定义的局部变量相当于是一个常量,他的生命周期超出方法运行的生命周期. 内部类也可以通过创建对象从外部类之外被调用,只要将内部类声明为public即可.