Java类和对象的高级特征

1、第4章 Java类和对象的高级特征14.1 接口14.1.1 定义接口24.1.2 实现接口24.2 内部类54.2.1 内部类特性54.2.2 静态内部类104.3 包114.3.1 Java的常用包介绍114.3.2 引用Java定义的包144.3.3 自定义包17【例4.1】 声明接口。2【例4.2】 实现接口的类。3【例4.3】 一个类实现多个接口。3【例4.4】 内部类的定义。5【例4.5】 嵌套的两个类之间的访问规则。5【例4.6】 内部类与外部类的成员同名问题。6【例4.7】 抽象内部类。8【例4.8】 内部接口。9【例4.9】 静态公用内部类。10【例4.10】 引用Java实

2、用包中的日期类。14【例4.11】 自定义包。17表4.1 一个班级的学生成绩表11图4.1 继承机制3图4.2 Java的包12第4章 Java类和对象的高级特征作为一种典型的面向对象语言，Java实现了大部分的面向对象机制。由于面向对象理论涉及范围很广泛，所以除了前一章介绍的内容外，本章讨论Java面向对象实现机制，包括接口、内部类和包。4.1 接口由于Java没有提供像C+一样的多重继承机制，即让一个类继承多个类，从而避免了C+中因多重继承而引起的难以预测的冲突。但在实际应用中可能用多重继承实现会更方便合理些，如正方形应该是继承了菱形和长方形的特征，这时Java提供了接口用于实现多重继承

3、。这样，既实现了多重继承的功能，同时又避免了C+中因多重继承而存在的隐患。Java不支持多重继承，即一个类只能有一个超类。单继承性使得Java简单，易于管理。为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。4.1.1 定义接口接口(interface)是没有实现的方法和变量的集合。接口的定义与类的定义相似，格式为：<修饰符> interface <接口名>方法1； 方法2；其中，<修饰符>可以是public，也可以缺省。缺省时，接口使用缺省访问控制，即接口只能被与它处在同一包中的成员访问；当声明为public时，接口能被任何类成员访问。&l

4、t;接口名>是接口的名字，可以是任何有效的标识符。例如：interface MyInterFace1void method1();声明了一个接口MyInterFace1。在接口中的方法method1只有定义没有实现，即接口中的方法都是抽象方法，所以实际上接口就是一种特殊的抽象类，这意味着在定义接口时不必管怎样实现接口。定义在接口中的变量全部隐含为final和static型。这意味着它们不能被实现接口方法的类改变，这些变量还必须设置初值。如果接口声明为public型，则接口中的方法和变量全部为public型。【例4.1】 声明接口。本例声明了接口Student_info表示学生情况，其中有

5、一个成员变量year和二个成员方法age、output。成员变量year隐含为final和static型，必须设置初值。源程序文件名必须与接口名相同。程序如下：interface Student_info /学生情况接口 int year = 2002; int age(); void output();4.1.2 实现接口一旦定义了一个接口，一个或更多的类就能实现这个接口。为了实现接口，类必须实现定义在接口中的方法，每个类能自由地决定方法具体实现的细节。Java提倡充分地利用多态性中的“一个接口，多个方法”的特性。接口的实现类似于继承，只是不用extends，而是用关键字implements

6、声明一个类将实现一个接口，类声明的格式是：<修饰符> class <类名> extends <超类名> implements <接口名1>，<接口名2>，其中，<修饰符>可以是public，也可以缺省。如果一个类实现一个接口，则必须实现接口中的所有方法，且方法必须声明为public。如果一个类实现多个接口，则用逗号分隔接口列表。【例4.2】 实现接口的类。本例声明的类Stu1实现接口Student_info，Stu1类中有自己的二个成员变量name和birth_year，实现接口方法age时使用了接口中的变量year的值。

7、程序如下：public class Stu1 implements Student_info /实现学生情况接口 String name; int birth_year; /类自己的成员变量 public Stu1(String n1,int y) name = n1; birth_year = y; public int age() /实现接口的方法 return year - birth_year; public void output() /实现接口的方法 System.out.println( +" "+ this.age()+"岁&qu

8、ot;); public static void main (String args) Stu1 s1 = new Stu1("李明",1980); s1.output(); 程序运行结果：李明 22岁由本例可见，一个类实现一个接口，必须给出接口中所有方法的实现。如果不能实现某方法，也必须写出一个空方法。Java允许多个类实现同一个接口，这些类之间可以是毫无联系的，每个类各有自己实现方法的细节。这一点与继承机制不同。同时一个类也能实现多个接口，这就解决了多重继承的问题。如图4.1所示。图4.3 继承机制【例4.3】 一个类实现多个接口。本例声明一个接口Student_sco

9、ure表示学生成绩，其中有二个成员方法total、erface Student_scoure /学生成绩接口 float total(); void output();本例声明的类Stu2实现两个接口Student_info和Student_scoure，此时必须写出两个接口中的所有方法。程序如下：public class Stu2 implements Student_info, Student_scoure /实现学生情况接口、学生成绩接口 String name; int birth_year; float math,english,computer; public

10、Stu2(String n1,int y,float a,float b,float c) name = n1; birth_year = y; math = a; english = b; computer = c; public int age() return year - birth_year; public float total() return math + english + computer; public void output() /实现接口的方法 System.out.print( +" "+ this.age()+"岁

11、"); System.out.println(math+" "+english+" "+computer+" "+total(); public static void main (String args) Stu2 s2 = new Stu2("李明",1980,90,80,70); s2.output(); 程序运行结果：李明 22岁 90.0 80.0 70.0 240.0本例的两个接口中都声明了同一方法output，那么其中的任一接口都能使用这一方法。在Java的实际应用中，需要使用Java提供的

12、接口。最典型的应用就是事件处理，例如Java定义了MouseListener和MouseMotionListener两个接口，里面定义了所有处理鼠标事件的方法，当一个类实现这两个接口后，就可以处理这些鼠标事件了。有关Java事件处理的机制将在第六章中详细说明。4.2 内部类一个类被嵌套定义于另一个类中，称为内部类(inner class)，也称为嵌套类。包含内部类的类称为外部类。与一般的类相同，内部类可以具有成员变量和成员方法。通过建立内部类的对象，可以存取其成员变量和调用其成员方法。【例4.4】 内部类的定义。本例声明的Group1类中包含有Student类，相对而言，Group1类称为外部

13、类，类Student称为内部类，内部类Student中也可以声明成员变量和成员方法。程序如下：public class Group1 int count; /外部类的成员变量 public class Student /声明内部类 String name; /内部类的成员变量 public void output() /内部类的成员方法 System.out.println( +" "); 4.2.1 内部类特性在外部类中声明了内部类之后，外部类与内部类之间构成嵌套结构，那么两者之间的访问规则是怎样的？外部类中怎样访问内部类，内部类中可以访问外部类的成员吗

14、？这些问题可由以下所述的内部类的特性来解决。内部类具有以下一些特性：1. 内部类的类名只能用在外部类或语句块之内。在外部引用它时必须给出完整的名称，且内部类的类名不能与外部类名相同。对于例4.4，外部类Group1声明内部类Student，在外部类Group1的方法中可以使用内部类名Student创建内部类的对象，而在外部类的main方法或其他类中，则必须使用完整的内部类标识Group1.Student，参见例4.5、例4.6。2. 内部类作为外部类的成员。Java将内部类作为外部类的一个成员，就如同成员变量和成员方法。因此访问内部类成员的规则是，在外部类中，通过一个内部类的对象可以引用内部类

15、中的成员。同时，Java提供一种机制，允许内部类引用它的外部类的成员，包括静态成员、实例成员及私有成员。【例4.5】 嵌套的两个类之间的访问规则。本例的类Group2中声明了成员变量count、内部类Student、实例方法output和main方法，在内部类Student中声明了构造方法和output方法，构造方法存取了外部类Group2的成员变量count。本例演示嵌套的两个类之间的访问规则，即在外部类Group2中，通过一个内部类Student的对象s1可以引用内部类中的成员；反之，在内部类Student中可以直接引用它的外部类的成员，如count。程序如下：public class G

16、roup2 private int count; /外部类的私有成员变量 public class Student /声明内部类 String name; public Student(String n1) name = n1; count+; /存取其外部类的成员变量 public void output() System.out.print( +" "); public void output() /外部类的实例成员方法 Student s1 = new Student("李明"); /建立内部类对象s1 s1.output();

17、/通过s1调用内部类的成员方法 System.out.println(" count = "+this.count); public static void main (String args) Group2 g2 = new Group2(); g2.output(); 程序运行结果：李明 count = 1本例的外部类Group2中有实例方法output()，内部类Student中也有实例方法output()，两者同名，有效。使用时，外部类Group2的对象调用Group2的output，如g2.output()，内部类Student的对象调用Student的outpu

18、t，如s1.output()。3. 外部类与内部类各有自己的成员。Java允许外部类与内部类各有自己的成员，而且不同类的成员可以同名。【例4.6】 内部类与外部类的成员同名问题。本例的类Group3中声明了成员变量count、name、内部类Student、实例方法aStu和main方法，在内部类Student中声明了成员变量count、name和output方法。在非静态的内部类中不能声明静态变量，所以Student中的count只能是实例变量。在内部类Student的output方法中，访问了三个不同含义的count：外部类的静态变量、内部类的静态变量以及方法的参数，这时必须在count前

19、加上不同的修饰符，编译系统才能区分。在外部类的main方法中，可以使用完整的内部类标识Group3.Student创建内部类的对象s1。程序如下：public class Group3 private static int count; /静态变量Group3.count统计班级数量 private String name; /实例变量G 表示班级名称 public class Student private int count; /实例变量Student.count表示学号 private String name; /实例变量S表示学生姓名 publ

20、ic void output(int count) count+; /存取方法的参数，局部变量 this.count+; /通过对象存取Student.count Group3.count+; /通过类名存取Group3.count System.out.println(count+" "+this.count+" "+Group3.count); public Student aStu() /返回内部类Student的一个对象 return new Student(); public static void main (String args) Gro

21、up3 g3 = new Group3(); g3.count=10; /Group3.count Group3.Student s1 = g3.aStu(); /在外部创建内部类的对象 /完整的内部类标识Group3.Student s1.output(5); 程序运行结果：6 1 11由本例可见，外部类与内部类的成员可以同名，通过不同类的对象访问不同的成员。本例欲在main方法中使用Group3.Student s1 = new Group3.Student();声明并创建内部类的对象s1，编译时出错。这是因为Student不是静态成员，其构造方法不是静态方法，所以不能在静态方法main中

22、使用非静态方法。此种方法将在例4.10中介绍。此时，只能首先使用Group3.Student s1声明内部类的对象s1，再通过调用外部类的方法g3.aStu()获得内部类的一个实例。同理，对于同名的name与count的操作方式类似。4. 内部类可以定义为抽象类型，但需要被其他的内部类继承或实现。【例4.7】 抽象内部类。本例的类Group4中声明二个内部类，一个是抽象内部类Student_abstract，另一个是内部类Student继承抽象内部类Student_abstract并实现抽象类中的output方法。在外部类Group4的构造方法中，创建了两个内部类的对象s1和s2。程序如下：p

23、ublic class Group4 public abstract class Student_abstract /抽象内部类 int count; String name; public abstract void output(); /抽象方法 public class Student extends Student_abstract /继承抽象内部类 public Student(String n1) name = n1; count+; /Student.count public void output() /实现抽象方法 System.out.println( +

24、" count="+this.count); public Group4() Student s1 = new Student("A"); s1.output(); Student s2 = new Student("B"); s2.output(); public static void main (String args) Group4 g4 = new Group4(); 程序运行结果：A count=1B count=1由运行结果可知，两个不同对象s1、s2的name值不同，但count均为1。而我们希望count表示学生的序

25、号，程序运行时能够自动编号。实现这项功能需要将count设计成静态变量，但规则是，非静态的内部类中不能声明静态变量。所以Student类从抽象内部类中继承的count仍是实例变量，对于Student对象s1，s1.count的初值均为0，执行count+之后，得到的s1.count均为1。5. 内部类可以是一个接口，这个接口必须由另一个内部类来实现。【例4.8】 内部接口。本例的类Group5中声明一个内部接口Student_info，一个内部类Student实现内部接口。在外部类Group5的构造方法中，根据参数中的数组元素个数，创建了若干个内部类的对象s1。程序如下：public clas

26、s Group5 public interface Student_info /内部接口 public void output(); public class Student implements Student_info /内部类实现内部接口 int count; String name; public Student(String n1) name = n1; count+; public void output() /实现接口方法 System.out.println( +" count="+this.count); public Group5(St

27、ring name1) Student s1; int i=0; while (i<name1.length) s1 = new Student(name1i); s1.output(); i+; public static void main (String args) Group5 g5; if (args.length>0) g5 = new Group5(args); 运行命令：d:myjava>java Group5 A B C后的程序结果为：A count=1B count=1C count=14.2.2 静态内部类定义为static型的内部类称为静态内部类。静态

28、内部类将自动转化为顶层类，即它没有超类，而且不能引用外部类成员或其它内部类中的成员。当一个内部类不需要引用外部类成员，只需隐藏在另一个类中时，或者需要在一个内部类中声明静态时，可以将该内部类声明为静态的。例如，设计一个大型应用程序时，程序员们自定义的类名可能会重复，产生冲突。如果将一些内部类声明为静态的公用内部类，则其他类能够通过完整的类标识(如Outer.Inner)来使用这些静态的公用内部类，从而减少类名重复的机会。【例4.9】 静态公用内部类。本例的类Group6中声明的一个内部类Student是静态、公用的，其中可以声明静态变量count。在构造方法中，实例变量numer得到静态变量c

29、ount的值，实现了自动编号功能。静态内部类Student中不能访问外部类成员。程序如下：public class Group6 public static class Student /定义静态公用内部类 static int count; String name; int number; public Student(String n1) /静态内部类的构造方法 name = n1; count+; number = count; public void output() System.out.println( +" number="+this.num

30、ber); public static void main (String args) Group6.Student s1 = new Group6.Student("A"); s1.output(); Group6.Student s2 = new Group6.Student("B"); s2.output(); 程序运行结果：A number=1B number=2思考题：按表4.1的格式统计一个班级的学生成绩。要求将其中一个学生的情况设计成一个内部类Student，并以一维数组形式实现这张表。表4.10 一个班级的学生成绩表Numbernamea

31、gescoure1234.3 包我们知道Windows对文件的组织方式是以文件夹为单位分别存放的，同一文件夹中的文件不能同名，不同文件夹中的文件可以同名。如果没有文件夹，将文件全部放在一起，则必须使用唯一的名字，否则会发生名字冲突，而且显得文件没有层次，杂乱无章。如果将相关文件按文件夹分门别类存放，则显得井井有条，便于查找，而且文件夹中还右。Java对类的组织方式与此同理。Java要求文件名与类名相同。我们将多个类放在一起时，要保证类名不能重复。当声明的类很多时，类名冲突的可能性增大，这时需要一种机制来管理类名，这就是包。包(package)是Java提供的一种区别类名字空间的机制，是类的组织

32、方式，包对应一个文件夹，包中还可以再有包，称为包等级。我们在源程序中可以声明类所在的包，就像保存文件时，要说明文件保存在哪个文件夹中一样。同一包中的类名不能重复，不同包中的类名可以相同。当源程序中没有声明类所在的包时，Java将类放在缺省包中，这意味着每个类必须使用唯一的名字，否则会发生名字冲突。就象在一个文件夹中的文件名不同相同一样。Java类库是以包的形式实现的，每个包里都含有多组相关的类，除类之外还包含接口、异常等。本节首先来看Java定义了哪些常用包，再介绍如何引用Java定义的包，最后说明如何定义自己的包。4.3.1 Java的常用包介绍Java提供了丰富的类库，分别放在不同的包中。

33、打开Java的帮助文档，进入Java 2 Platform API Specification，可以看到所有的包及其中的类和方法，如图4.2所示。图4.10 Java的包图4.2所示的是java.lang包中的Math类，其中定义许多方法实现数学函数的功能。Java的常用包有：java.lang语言包java.util实用包java.awt抽象窗口工具包java.io输入输出流java.appletApplet应用程序网络功能1. 语言包Java语言包java.lang所提供的类构成了Java语言的核心。语言包中的类是Java类库中最低级的类。语言包中最主要的类有：(1) Object类Obj

34、ect类是Java类的根，所有其他的类都是由Object类派生出来的，在Object类中定义的方法，在其他类中都可以使用。Object类中有复制对象方法clone，比较两个对象是否相等的equals方法，获得对象的类getClass方法等。(2) 数据类型包装类(The Data Type Wrapper)简单数据类型的类包装，有Integer、Float、Boolean等多个类。例如，int i;Integer j = new Integer(“123”)；/以字符串构造Integer类的一个对象ji = Value()；/intValue方法将j转化为int值在例3.11中，我们

35、使用该方法将以命令行参数输入的字符串，转化为int值。(3) 数学类Math数学类Math提供一组常量和数学函数。包括E和PI常数，求一个数绝对值的abs方法，计算三角函数的sin、cos方法，求最小值、最大值的min、max方法，求随机数的random方法等。数学类中所有的变量和方法都是静态(static)的，且数学类是最终类(final)，所以不能从数学类中派生其他的新类。(4) 字符串类与C/C不同，Java将字符串作为类来实现，而不强制使用字符数组。字符串有两个类：String和StringBuffer。String类中字符串对象的值和长度都没有变化。常用方法有：求子串substrin

36、g，替换replace等。StringBuffer类中字符串对象的值和长度都可以变化。(5) 系统和运行时类System、Runtime System类和Runtime类提供访问系统和运行时环境资源。System类提供一个独立于具体计算机系统资源的编程界面，包括标准输入System.in和标准输出System.out，分别表示键盘和显示器。例如System.out.print()方法用于显示输出。System类中的变量和方法都是最终的(final)和静态(static)的。Runtime类可直接访问运行时资源，例如，运行该类的freeMemory方法，返回系统自由内存空间的大小。(6) 类操作

37、类ClassJava提供两个用于类操作的类：Class和ClassLoader。Class为类提供运行时信息，如名字、类型以及父类。例如，System.exit(0)；/ Terminates the currently running Java Virtual Machine.再如，在第3章的例中，我们多次用下面的形式输出当前对象所在类的名称：System.out.print(this.getClass().getName()+" ");在Object类中的getClass方法返回当前对象所在的类，返回值是Class。在Class类中的getName方法返回一个类的名称，

38、返回值是String。由于所有类都是Object类的子类，根据继承的“即是”原则，所有类的对象即是Object类的对象。所以通过当前对象this调用Object类中的getClass方法，得到当前对象所在的类(Class)，再调用Class中的getName方法得到this的类名字符串。ClassLoader类提供把类装入运行时环境的方法。(7) 线程类ThreadJava是一个多线程环境，提供各种用于线程管理和操作的类。与程序一起使用的多线程类和接口有：Thread、ThreadDeath、ThreadGroup、Runnable。Thread类在程序中建立一个可执行的线程，ThreadDe

39、ath类在一个线程执行完成后进行清理工作，ThreadGroup类用来组织一组线程，接口Runnable是建立线程的交互工具。(8) 错误和异常处理类Throwable、Exception、Error运行时错误处理在任何一个程序设计环境中都很重要。Java提供用于运行时错误处理的类有：Throwable、Exception、Error。Throwable类处理低级错误，Exception类处理异常错误，Error类处理硬件错误。Exception类和Error类都是由Throwable派生的。(9) 过程类ProcessProcess类支持系统过程，当使用类Runtime执行系统命令时，就建立

40、了处理系统过程的Process类。2. 实用包Java实用包java.util提供了实现各种不同实用功能的类，包括日期类、数据结构类等。(1) 日期类包括Data、Calendar、GregorianCalendar类。Data类中有日期和时间值，提供获得和修改当前日期和时间的方法。Calendar和GregorianCalendar是日历类，声明了对日期值的许多操作。在JDK 1.1之后的版本中，Date类中的许多方法被Calendar类中的方法所替代，例如Date类中的getYear、setYear方法被Calendar类中的get、set取代。(2) 数据结构类包括链表类LinkedLi

41、st、向量类Vector、栈类Stack、散列表类Hashtable等。(3) 随机数类Random4.3.2 引用Java定义的包1. 导入包如果要使用Java包中的类，必须在源程序中用import语句导入。import语句的格式为：import <包名1>. <包名1>. <包名1>. <类名1>*；其中import是关键字，多个包名及类名之间用圆点分隔，“*”表示包中的所有类。如，import java.applet.Applet；/导入java.applet包中的Applet类import java.awt.*；/导入java.awt包中

42、的所有类java.lang包是系统自动隐含地导入的，用户无需用import语句引入，就可使用其中的类。2. Java包的路径要引用Java的包，仅在源程序中增加import语句是不够的，还必须告诉Windows系统，程序运行时到哪儿才能找到Java的包。这个功能由环境变量classpath来完成。由于Java使用文件系统来存储包和类，类名就是文件名，包名就是文件夹名。所以在Windows98系统的c:autoexec.bat中设置classspath的语句为：set classpath = .;d: jdk1.3.0_02lib其中d:jdk1.3.0_02是JDK1.3系统安装的路径。若在W

43、indows2000系统中，要在“我的电脑”“属性”“高级”“环境变量”中，新建“系统变量”classspath，语句为：classpath = .;d: jdk1.3.0_02lib【例4.10】 引用Java实用包中的日期类。本例声明了外部类People1，成员变量是name、birth分别记载一个人的姓名和出生日期，还有用出生日期计算人年龄的age方法。其中为日期声明了一个内部类Date1，成员有表示年月日的三个整型。本例引用Java的java.util包中Calendar、GregorianCalendar类，用来获得系统当前日期值。在外部类People1的age方法中，定义了一个Gr

44、egorianCalendar类的对象today，创建时today获得系统当前日期值，Calendar.YEAR是表示年份的常量，通过对象的get方法today.get(Calendar.YEAR)获得today的今年的年份，从而可计算出一个人今年的年龄。程序如下：import java.util.*; /引用java.util包public class People1 /外部类声明 private String name; private Date1 birth; public class Date1 /内部类声明 private int year,month,day; /成员变量，表示年、

45、月、日 public Date1(int y,int m,int d) /内部类的构造方法 year = y; month = m; day = d; public Date1() this(0,0,0); public Date1 getToday() /内部类的成员方法 GregorianCalendar c_today = new GregorianCalendar(); return new Date1(c_today.get(Calendar.YEAR), c_today.get(Calendar.MONTH)+1,c_today.get(Calendar.DATE); public

46、 int getYear() return year; public int getMonth() return month; public int getDay() return day; public String toString() return year+"-"+month+"-"+day; public People1(String n1,int y,int m,int d) /外部类的构造方法 name = n1; birth = new Date1(y,m,d); public People1() name = ""

47、birth = new Date1(); public int age() /外部类的成员方法，计算年龄 Date1 today = (new Date1().getToday(); /today获得当前日期值 return today.getYear() - birth.getYear(); /获得today的年份 public void output() System.out.println("name : "+name); System.out.println("birth: "+birth.toString(); System.out.print

48、ln("age : "+age(); public static void main(String args) People1.Date1 today = (new People1().new Date1().getToday(); System.out.println("today: " + today.toString(); People1 a = new People1("Wangli",1981,2,14); a.output(); 程序运行结果：today: 2002-10-25name : Wanglibirth: 1981-2-14age : 21在内部类Date1中声明了getToda