Java程序设计修改-ch04.doc

本资料由-大学生创业|创业|创业网/提供资料第4章 继承和多态继承是Java语言的一个重要特性。本章主要介绍关于继承的若干应用。通过继承，子类拥有父类的所有非私有成员。子类对继承自父类的类成员重新进行定义，就称为覆盖。方法的重载是一个类中对自身已有的同名方法的重新定义。每个重载方法的参数的类型和（或）数量必须是不同的。用abstract修饰符修饰的类称为抽象类，抽象类不能实例化为对象。如果一个类被final修饰符所修饰，说明这个类不可能有子类，这样的类就称为最终类。最终类不能被别的类继承，它的方法也不能被覆盖。接口用interface来声明。接口中的域变量都是常量，方法都是没有方法体的抽象方法，其方法的真正实现在“继承”这个接口的各个类中完成。一个类只能有一个父类，但是类可以同时实现若干个接口，从而实现了多重继承。本章要点l 继承和多态的概念、特点以及实现方法l 域的继承与隐藏l 方法的继承与覆盖l 接口的实现本章难点l 继承和多态的实现方法l 接口的实现学习目标l 理解继承、多态、接口的概念l 掌握继承、多态、接口在Java中的实现。4.1 继承和多态的概念4.1.1 继承的概念继承实际上是存在于面向对象程序中的两个类之间的一种关系。当一个类A能够获取另一个类B中所有非私有的数据和操作的定义作为自己的部分或全部成分时，就称这两个类之间具有继承关系。被继承的类B称为父类或超类，继承了父类或超类的数据和操作的类A称为子类或衍生类，一个父类可以同时拥有多个子类。使用继承具有以下的好处：降低了代码编写中的冗余度，更好地实现了代码复用的功能，从而提高了程序编写的效率，使得程序维护变得简单、方便。现以汽车为例，汽车分为很多种，比如公共汽车、警车、私家车等。如果要实现对汽车的管理，就需要为每一种汽车创建一个类，而每一个类中都会具有所有汽车共有的属性和方法，比如每个汽车类都会有颜色、车灯等属性，都会有加速、刹车等方法，这样势必带来代码的重复，维护起来也比较麻烦。如果我们将所有汽车共有的属性和方法都抽象出来，构建一个汽车类，让各种汽车都继承这个类，这样在汽车这个类中所拥有的属性就会衍生在它的子类中，各种汽车都会具有汽车类所拥有的属性和方法，我们就不用为每种汽车定义像颜色、车灯这样的属性，以及加速、刹车等相同的方法了。而且维护起来也比较容易了。这种结构如图4-1所示。汽车类颜色、车灯加速（）、刹车（）公共汽车警车私家车图4-1 汽车类的继承继承分为单重继承和多重继承两种类型，所谓单重继承，是指任何一个类都只有一个单一的父类；而多重继承是指一个类可以有一个以上的父类。采用单重继承的程序结构比较简单，是单纯的树状结构，掌握、控制起来相对容易；而支持多重继承的程序，其结构则是复杂的网状，设计、实现都比较复杂。Java语言仅支持类的单重继承。4.1.2 多态的概念多态是面向对象程序设计的又一个特殊特性。所谓多态，是指一个程序中同名的不同方法共存的情况。面向对象的程序中多态的情况有多种，可以通过子类对父类成员的覆盖实现多态，也可以利用在同一个类中同名方法的重载来实现多态。多态是指一个方法声明的多个不同表现形式。在同一个类中或者不同的类中，同一个方法的多个不同实现。比如同样是刹车这样一个功能，在不同的汽车中所要做的操作可能是不一样的，这样我们在程序中就要为刹车这个方法名创建几个不同的实现，也就是说，刹车这个方法名可能会有几个不同的方法体，这就是面向对象程序设计中多态的概念。 4.2 类的继承4.2.1继承的实现Java中的继承是通过extends关键字来实现的，在定义类时使用extends关键字指明新定义类的父类，就在两个类之间建立了继承关系。其语法是：类修饰符 class 子类名 extends 父类名从上面的语法格式，我们可以看出比一般类的声明多了“extends”关键字部分，通过该关键字来指明子类要继承的父类。如果，父类和子类不在同一个包中，则需要使用“import”语句来引入父类所在的包。【例4_1】继承的简单示例。class Fatherint f_a=0;void print()System.out.println (f_a=+f_a);class Son extends Fatherint s_a=10;class Exam4_1public static void main(String args) Son s =new Son(); s.print(); System.out.println (f_a=+s.f_a); System.out.println (s_a=+s.s_a); 在例子中可以看到，在子类的声明中使用“extends”关键字指明一个被继承的父类就可以实现类之间的继承关系。Son类中虽然并没有定义f_a变量和print()方法，但是仍然可以访问，这是因为它从父类中继承过来的原因。子类Son还定义了自己的变量s_a，这说明了子类可以拥有比父类更多的变量和方法，也就是说子类拥有更强大的功能。程序的执行结果如图4-2所示。图4-2 例4_1程序运行结果4.2.2 类成员的继承新定义的子类可以从父类那里自动继承所有非private的属性和方法作为自己的成员。同时根据需要再加入一些自己的属性或方法就产生了一个新的子类。可见父类的所有非私有成员实际是各子类都拥有集合的一部分，这样做的好处是减少程序维护的工作量。从父类继承来的成员，就成为了子类所有成员的一部分，子类可以使用它。【例4_2】继承的示例。class Fatherprivate int f_a=0;private void print()System.out.println (f_a=+f_a);class Son extends Fatherint s_a=10;class Exam4_2public static void main(String args) Son s =new Son();/ s.print();/ System.out.println (f_a=+s.f_a); System.out.println (s_a=+s.s_a); 仍然如4.1的例子，但此时我们把父类中的变量f_a和方法print()修改为了private的作用域，此时在子类中就不能访问这两个成员了，因为子类不能继承私有的父类成员，程序中注释掉的两条语句是错误的读者可自行检验。程序的运行结果如图43所示。图4-3 例4_2程序运行结果【例4_3】继承的示例。class Fatherprivate int f_a=0;void print()System.out.println (f_a=+f_a);class Son extends Fatherint s_a=10;class Exam4_3public static void main(String args) Son s =new Son(); s.print();/ System.out.println (f_a=+s.f_a); System.out.println (s_a=+s.s_a); 继续对4.1的例子作修改，把把父类中的变量f_a修改为了private的作用域，但方法print()仍然保持默认作用域，此时可以看到在子类中直接访问变量f_a会出现错误，但通过print()方法我们却可以访问到私有作用域的f_a变量，这又是因为什么呢？这是因为print（）方法被子类继承，print（）方法和变量f_a 都是父类的成员，它们之间进行访问是不存在问题的，利用公共的方法去访问私有的成员，这正是面向对象封装特点的好处，它使得在类外不能直接访问私有的属性，但可以利用方法作为接口对变量进行读取操作，增强了程序的健壮性。程序的运行结果如图4_4所示。图4- 4 例4_3程序运行结果4.2.3 替代原理有了继承特点，面向对象编程中就存在了一个替代原理，用一句话讲替代原理的内容是：子类对象总可以看作一个父类对象。也就是说，在所有使用父类对象的地方，都可以使用一个子类对象来代替父类对象，也有人把这种原理称为“is a”关系。比如在例4.1中，f_a变量和print()方法是父类的成员，应该用父类的对象去访问，但我们却使用了子类的对象去访问这两个成员，这可以认为是一种简单的替代，我们来看下面这个例子。【例4_4】替代原理示例。class Fatherprivate int f_a=0;void print(Father f)System.out.println (f_a=+f.f_a);class Son extends Fatherclass Exam4_4public static void main(String args)Father f=new Father();Son s =new Son();f.print(s);我们给print( )方法加上了参数，这个参数是一个父类的引用，但我们调用时，却给方法传递了一个子类的引用s，程序却依然可以正常运行，这就是替代原理。程序的运行结果如图4-5所示。图4-5 例4_4程序运行结果4.3 类成员的覆盖4.3.1 覆盖的用法在程序的设计过程中，我们通过继承可以快速地将父类中已实现的非私有类成员应用到自己定义的子类中。但是，不是所有继承下来的类成员都是我们需要的，这时候我们就可以通过使用覆盖的方式来解决这个问题。子类对继承自父类的类成员重新进行定义，就称为覆盖。要进行覆盖，就是在子类中对需要覆盖的类成员以父类中相同的格式，再重新声明定义一次，这样就可以对继承下来的类成员进行功能的重新实现，从而达到程序设计的要求。【例4_5】覆盖的示例。class Fatherint f_a=0;void print()System.out.println (f_a=+f_a);class Son extends Fatherint f_a=10;void print()System.out.println (f_a=+f_a);class Exam4_5public static void main(String args) Son s =new Son(); s.print(); System.out.println (f_a=+s.f_a); 我们在子类中重新定义了print（）方法和变量f_a，此时子类的print（）方法覆盖了父类的print（）方法，子类中的变量f_a隐藏了父类中的变量f_a，在子类中再去调用print（）方法或者访问变量f_a都是访问的子类中的成员，因此此时只输出的变量f_a都是子类中的变量f_a=10，而没有输出父类的变量f_a=0。程序运行结果如图4-6所示。图4-6 例4_5程序运行结果4.3.2 super参考如果要使用父类中被覆盖的方法或被隐藏的变量，此时可以使用super参考。相对this来说，super表示的是当前类的直接父类对象，是当前对象的直接父类对象的引用。所谓直接父类是相对于当前类的其他“祖先”类而言的。例如，假设类A派生出子类B，B类又派生出自己的子类C，则B是C的直接父类，而A是C的祖先类。super代表的就是直接父类。这就使得我们可以比较简便、直观地在子类中引用直接父类中的相应属性或方法。【例4_6】super参考的示例。class Fatherint f_a=0;void print()System.out.println (f_a=+f_a);class Son extends Fatherint f_a=10;void print()super.print();System.out.println (f_a=+super.f_a);class Exam4_6public static void main(String args) Son s =new Son(); s.print(); System.out.println (f_a=+s.f_a); 程序中我们对子类的print()方法作以修改，在方法内部我们首先使用了super关键字引用了父类的print（）方法，输出了父类的变量f_a，然后我们又通过super关键字直接引用了父类的变量f_a，最后才输出了子类中的变量f_a。程序运行的结果如图4-7所示。图4-7 例4_6程序运行结果4.4 方法重载4.4.1 方法的重载在Java 中，同一个类中多个同名方法之间构成重载关系，在完成同一功能时，可能遇到不同的具体情况，所以需要定义含不同的具体内容的方法，这些方法的具体实现代码可能不一样，但他们的名称相同，这些方法间构成重载。例如，一个类需要具有打印的功能，而打印是一个很广泛的概念，对应的具体情况和操作有多种，如实数打印、整数打印、字符打印、分行打印等。为了使打印功能完整，在这个类中就可以定义若干个名字都叫print（）的方法，每个方法用来完成一种不同于其他方法的具体打印操作，处理一种具体的打印情况，这些同名print（）方法的关系就是重载关系。public void print (int i)public void print (float f)public void print ()当一个重载方法被调用时，Java 用参数的类型、数量、参数的顺序来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型、数量或者参数的顺序至少有一个是不同的，但不能通过方法的返回值类型来定义重载的方法。【例4_7】方法重载的示例。class Exam4_7int i=5;String s=hello;void print()System.out.println(i=+i+ s=+s);void print(int i)System.out.println (i=+i);void print(String s)System.out.println (s=+s);void print(int i,String s)System.out.println(i=+i+ s=+s);void print(String s,int i)System.out.println(s=+s+ i=+i);/*int print(int i)return i;*/public static void main(String args) Exam4_7 e =new Exam4_7(); e.print(); e.print(10); e.print(java); e.print(10,java); e.print(java,10); 程序中一共定义了5个print（）方法，这5个print（）方法要么参数的个数不一样，要么参数的类型不一样，要么参数的顺序不一样，这5个方法间构成方法的重载。但是被注释掉的int print(int i)方法由于只是返回值类型与void print(int i)方法不一样，不具备构成重载的条件，不能够构成重载，因此编译时会出错，提示方法已经被定义，读者可自行测试。程序的运行结果如图48所示。图4-8 例4_7程序运行结果4.4.2 构造函数的重载构造函数间也可以构成重载。不同对象的创建很多时候就是通过构造函数的重载来实现的。并且在构造函数重载中我们还可以使用this关键字来指明重载的构造函数。【例4_8】构造函数的重载示例。class PersonString name;int age;Person()name=noname;age=1;Person(String name)this();=name;Person(int age)this();this.age=age;Person(String name,int age)=name;this.age=age;void print()System.out.println (我的名字是+name+,年龄是+age);class Exam4_8public static void main(String args) Person p1=new Person(); p1.print(); Person p2=new Person(小明); p2.print(); Person p3=new Person(10); p3.print(); Person p4=new Person(小芳,11); p4.print(); 程序中创建了四个构造函数，四个构造函数构成重载，通过不同的构造函数可以创建出不同的对象，并且使用了this关键字来调用了已经存在的构造函数，程序的运行结果如图4-9所示。图4-9 例4_8程序运行结果注意在使用this关键字来重载构造函数时，this必须是构造函数的第一个语句，且一个构造函数中只能出现一次。类似的可以在构造函数中使用super关键字来调用父类的构造函数。4.4.3 多态面向对象编程的第三大特征称为多态，是指一个方法声明的多个不同表现形式。一个方法可以用不同的方式来解释，多态通常被认为是一种方法在不同的类中可以有不同的实现，甚至在同一类中仍可能有不同的定义及实现。比如前面讲过的子类对父类方法的覆盖以及同一个类中方法的重载，这都是多态的表现形式。多态是指一个方法声明的多种实现状态。无论是方法重载还是方法覆盖，都要求其方法的声明要一致，不一样的是在具体实现方法时，方法体的内容不一样，方法在调用时，必须通过传入的参数的不同或者具体对象的不同，来确定究竟是调用方法的那一种实现形式。方法收到消息时，对象要予以响应，不同的对象收到同一消息可以产生完全不同的结果，一个名字有多个不同的实现，以实现不同的功能，一名多用，方便名称空间的简化和记忆，方便代码的抽象编程，这正是多态存在的意义。4.5抽象类和最终类 4.4.1 抽象类类是对对象的抽象，有时我们需要对类进行抽象，比如有些类具有共同的特性和功能，我们可以把这些共同的东西抽象出来组织成一个类，让其他类继承这个类，这样就可以简化代码的设计了。有些时候这些具有相同功能的类可能根本不相关，功能的具体实现也有很大差别，做普通类的继承不能达到我们的要求，此时就需要一种跟高级别的抽象，在Java中使用抽象类来实现这种抽象。举个例子而言，假设“鸟”是一个类，它代表了所有鸟的共同属性及其动作，任何一只具体的鸟儿都同时是由“鸟”经过特殊化形成的某个子类的对象，比如它可以派生出 “鸽子”、“燕子”、“麻雀”、“天鹅”等具体的鸟类。但是现实中并不会存在一只实实在在的鸟，它既不是鸽子，也不是燕子或麻雀，更不是天鹅，这只鸟仅仅是一只抽象的“鸟”，这就是抽象类的概念。有了“鸟”这个抽象类，在描述和处理某一种具体的鸟时，就只需要简单地描述出它与其他鸟类所不同的特殊之处，而不必再重复它与其它鸟类相同的特点。比如可以这样描述“燕子”这种鸟“燕子是一种长着剪刀似的尾巴，喜在屋檐下筑窝的鸟”。这种组织方式使得所有的概念层次分明，描述方便简单，符合人们的思维习惯。Java中定义抽象类是出于相同的考虑。由于抽象类是它的所有子类的公共属性的集合，所以使用抽象类的一大优点就是可以充分利用这些公共属性来提高开发和维护程序的效率。在Java中，凡是用abstract修饰符修饰的类称为抽象类。它和一般的类不同之处在于： 如果一个类中含有未实现的抽象方法，那么这个类就必须通过关键字abstract进行标记声明为抽象类。 抽象类中可以包含抽象方法，但不是一定要包含抽象方法。它也可以包含非抽象方法和域变量，就像一般类一样。 抽象类是没有具体对象的概念类，也就是说抽象类不能实例化为对象。 抽象类的子类必须为父类中的所有抽象方法提供实现，否则它们也是抽象类。定义一个抽象类的格式如下： abstract class ClassName . /类的主体部分抽象方法是指使用abstract关键字修饰，没有方法体的方法，其格式为：修饰符 abstract 返回值类型 方法名（参数列表）;注意抽象方法是没有方法体的，甚至连方法体的括号也没有。【例4_9】抽象类示例。abstract class birdabstract void fly();class swallow extends birdvoid fly()System.out.println(燕子在飞翔！);class eagle extends birdvoid fly()System.out.println(老鹰在滑翔！);class Exam4_9public static void main(String args)new swallow().fly();new eagle().fly();程序的运行结果如图 4-10所示。图4-10 例4_9程序运行结果4.4.2最终类如果一个类被final修饰符所修饰和限定，说明这个类不可能有子类，这样的类就称为最终类。最终类不能被别的类继承，它的方法也不能被覆盖。被定义为final的类通常是一些有固定作用、用来完成某种标准功能的类。例如最常用的System类就是final类。将一个类定义成final类，使得这个类不能再派生子类，这样其中的方法也就不能被覆盖，避免了这个类被外界修改，增强了程序的健壮性、稳定性。注意abstract和final修饰符不能同时修饰一个类，因为abstract类自身没有具体对象，需要派生出子类后再创建子类的对象；而final类不可能有子类，这两个修饰符恰好是矛盾的，所以abstract和final修饰符不能同时修饰一个类。4.6 接口4.6.1 接口的定义Java中的接口是对类的进一步抽象，是一种比抽象类更高一层次的抽象。有时一个类中被抽象的只剩下了抽象方法和一些常量，此时我们可以把这个类声明为一个接口。可以说接口是一个完全抽象类。接口中只能定义常量和抽象方法，并且他们默认都具有public的修饰符。所以，接口定义的仅仅是实现某一特定功能的一组对外的规范，而并没有真正的实现这个功能。这个功能的真正实现是在“继承”这个接口的各个类中完成的，要由这些类来具体定义接口中各抽象方法的方法体。Java中声明接口的语法如下： public interface 接口名extends父接口名列表 /接口体 /常量域声明 public static final 域类型 域名常量值; /抽象方法声明 public abstract native 返回值 方法名(参数列表)throw 异常列表; interface是接口声明的关键字，它引导着所定义的接口的名字，这个名字应该符合Java对标识符的规定。与类定义相仿，声明接口时也需要给出访问控制符，不同的是接口的访问控制符只有public一个。用public修饰的接口是公共接口，可以被所有的类和接口使用，而没有public修饰符的接口则只能被同一个包中的其他类和接口利用。与类相仿，接口也具有继承性。定义一个接口时可以通过extends关键字声明该新接口是某个已经存在的父接口的派生接口，它将继承父接口的所有属性和方法。与类的继承不同的是一个接口可以有一个以上父接口，它们之间用逗号分隔，形成父接口列表。新接口将继承所有父接口中的属性和方法。接口体由两个部分组成：一部分是对接口中域变量的声明，另一部分是对接口中方法的声明。接口中的所有域变量都必须是public static final，这是系统默认的规定，所以接口属性也可以没有任何修饰符，其效果完全相同。接口中的所有方法都必须是默认的public abstract，无论是否有修饰符显式地限定它。在接口中只能给出这些抽象方法的方法名、返回值类型和参数列表，而不能定义方法体。定义接口可归纳为如下几点： 在Java中接口是一种专门的类型。用interface关键字定义接口。 接口中只能定义抽象方法，不能有方法体，一定是public修饰的。 接口中可以定义变量，但实际上是static final修饰的常量。 接口中不能定义静态方法。从语法规定可以看出，定义接口与定义类非常相似。实际上完全可以把接口理解成为由常量和抽象方法组成的特殊类。一个类只能有一个父类，但是类可以同时实现若干个接口。这种情况下如果把接口理解成特殊的类，那么这个类利用接口实际上就获得了多个父类，即实现了多重继承。【例4_10】接口的示例。public interface Exam4_10public static final int x=10;int y=0;public void z();public abstract int getz();interface Sub_Interface extends Exam4_10public static final int a=0;int b=10;public void c();public abstract int getc();4.6.2 接口的实现接口的声明仅仅给出了抽象方法，相当于程序开发中的一组协议，而具体地实现接口所规定的功能，则需某个类为接口中的抽象方法定义实在的方法体，称为实现这个接口。如果一个类要实现一个接口，那么这个类就提供了实现定义在接口中的所有抽象方法的方法体。 一个类要实现一个接口其语法格式为：修饰符 class 类名 extends 父类名 implements 接口名列表/实现的接口中的方法体一个类要实现接口时，要注意以下几个问题： 在类的声明部分，用implements关键字声明该类将要实现哪些接口。 如果实现某接口的类不是abstract抽象类，则必须为所有抽象方法定义方法体，而且方法头部分应该与接口中的定义完全一致。 如果实现某接口的的类是abstract的抽象类，则它可以不实现该接口所有的方法。但该抽象类的子类必须实现所有的抽象方法，否则它仍然是抽象类。接口的抽象方法的访问限制符都已制定为public，所以类在实现方法时，必须显式地使用public修饰符，否则将出现缩小方法的访问控制范围的错误。【例4_11】接口实现示例。interface Animalvoid move();class Bird implements Animalpublic void move()System.out.println (鸟在飞翔!);class Beast implements Animalpublic void move()System.out.println (野兽在奔跑!);class Fish implements Animalpublic void move()System.out.println (鱼在游泳!);class Exam4_11public static void main(String args) new Bird().move(); new Beast().move(); new Fish().move(); 程序中我们对动物的运动作了抽象，抽象成了接口Animal，然后分别用Bird、Beast、Fish类实现了该接口，由于接口中只有一个抽象方法，因此在这些类里面也只实现了这一个抽象方法。程序的运行结果如图4-11所示。图4-11 例4_11程序运行结果4.7 案例继承和多态实例在本节中，我们将描述一棵树，并通过继承来描述一棵柳树，程序如下所示。 class Tree/树的树根 public void root() String sSite = 土壤中; String sFunction = 吸收养份; print(位置：+sSite); print(功能：+sFunction); /树的树干 public void bolo() String sSite = 地面; String sFunction = 传递养份; print(位置：+sSite); print(功能：+sFunction); /树的树枝 public void branch() String sSite = 树干上; String sFunction = 传递养份; print(位置：+sSite); print(功能：+sFunction); /树的叶子 public void leaf() String sSite = 树梢; String sFunction = 光合作用; String sColor = 绿色; print(位置：+sSite); print(功能：+sFunction); print(颜色：+sColor); /显示信息 public void print(Object oPara) System.out.println(oPara); /描述柳树class Osier extends Tree /重载树的树 public void leaf() super.leaf(); String sShape = 长形; super.print(形状：+sShape); /扩展树的花 public void flower() print(哈哈，柳树没有花！); public static void main(String args) Osier o = new Osier(); o.print(柳树树根：); o.root(); o.print(柳树树干：); o.bolo(); o.print(柳树树枝：); o.branch(); o.print(柳树树叶：); o.leaf(); o.print(柳树花：); o.flower(); 程序中我们对树作了抽象，对其抽象了四个方法，分别用来描述树的根、干、枝、叶，并做了print（）方法来进行显示。然后我们继承Tree类，做了柳树类Osier，并重写了父类中leaf（）方法，实现了方法的覆盖，并增加了flower（）方法，增强了子类的功能，程序的运行结果如图4-12所示。图4-12 程序执行结果小结Java中的继承通过extends关键字来实现，它的具体语法是：类修饰符 class 子类名 extends 父类名通过继承，子类拥有父类的所有非私有成员。子类对继承自父类的类成员重新进行定义，就称为覆盖，要进行覆盖，就是在子类中对需要覆盖的类成员以父类中相同的格式，再重新声明定义一次。在子类中引用直接父类中的相应属性或方法，可以使用super关键字。方法的重载是一个类中对自身已有的同名方法的重新定义。每个重载方法的参数的类型和（或）数量必须是不同的。构造函数也可以重载，在重载的构造函数内部，可以使用关键字this作为一个方法调用，从一个构造函数中调用另一个构造函数。用abstract修饰符修饰的类称为抽象类，抽象类不能实例化为对象。抽象类必须被继承，子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。如果一个类被final修饰符所修饰，说明这个类不可能有子类，这样的类就称为最终类。最终类不能被别的类继承，它的方法也不能被覆盖。接口用interface来声明。接口中的域变量都是常量，方法都是没有方法体的抽象方法，其方法的真正实现在“继承”这个接口