《Java实用教程第9讲继承和多态ppt课件》由会员分享，可在线阅读，更多相关《Java实用教程第9讲继承和多态ppt课件（36页珍藏版）》请在金锄头文库上搜索。
1、第9讲 承继和多态9.1组合组合9.2 承继承继9.3 final关键字关键字9.4 多态多态9.5 本讲小结本讲小结 Java经过两种方式来实现代码的复用，即组合和承继。组合是指创建新类时，新类中的成员是由现有类的对象组成，这种方式比较直观。而承继是指在现有类的根底上添加新的代码。这两种方式都不会破坏原有代码。9.1 组合组合在创建新类时，可以运用已有类的对象作为新类的成员，当然也可以创建根本数据类型的成员。下面的程序代码展现了组合技术：/ CompositionDemo.javaclass Wheelint count;Wheel(int count)this.count = count;
2、class Doorint count;Door(int count)this.count = count;class Enginedouble displacement;Engine(double displacement)this.displacement = displacement;9.1 组合组合class CarString name;Wheel wheel = new Wheel(4);Door carDoor =new Door(4);Engine carEngine = new Engine(3.0);Car(String name)this.name = name;publ
3、ic class CompositionDemo public static void main(String args) Car car = new Car(宝马X6);System.out.println(车名： + car.name);System.out.println(排量： + car.carEngine.displacement);System.out.println(门： + car.carDoor.count);System.out.println(轮子： + car.wheel.count); 上述代码中，类Car是由类String、类Wheel、类Door和类Engine
4、组合而成的。9.2 承继承继 承继是面向对象程序设计中不可短少的部分，Java是单根承继，不支持类似C+中的多承继。所以在Java中有一个“祖先类，名为Object，一切类都直接或间接的承继它，一切对象包括数组都实现这个类的方法。9.2.1 承继的语法承继的语法阐明“承继时，运用关键字extends，如： class Person class Student extends Person 上面程序中类Student承继于Person类，Person类称为父类或基类，Student类称为子类或派生类。而在定义Person类时，并没有为其指定父类，它默许的承继Object类，只不过“extends
5、 Object可以省略： wclass Person extends Object子类承继父类时，将得到父类中的一切成员，只是有的成员可以直接运用，有的成员只能间接运用。9.2.2 父类的初始化父类的初始化 当创建一个子类的对象时，该对象中包含了一个父类的对象。这个存在于子类对象中的父类对象同单独运用父类创建的对象一模一样。而且父类对象要先被初始化，这个初始化的动作是由构造方法来完成的。下面程序代码证明了这一点：/ PortableComputer.javaclass ElectricalEquipmentElectricalEquipment()System.out.println(Elec
6、tricalEquipment();class Computer extends ElectricalEquipment Computer()System.out.println(Computer();9.2.2 父类的初始化父类的初始化public class PortableComputer extends Computer PortableComputer()System.out.println(PortableComputer();public static void main(String args) PortableComputer myPc = new PortableCompu
7、ter();上面程序的输出结果为：ElectricalEquipment()Computer()PortableComputer() 从上面程序的运转结果可以看出，创建子类的对象时，父类的构造方法先被调用，用来初始化包含在子类对象中的父类对象。 ElectricalEquipment类和Computer类中只定义了无参构造方法，即创建子类对象中的父类对象时，运用的是父类的无参构造方法。那么能不能运用父类的有参构造方 法呢？答案是一定的.9.2.2 父类的初始化父类的初始化关于子类构造方法中调用父类的构造方法的规那么，现总结如下：1父类没有定义任何构造方法，或只定义了无参构造法，在创建子类对象时
8、，会先无条件的调用父类的无参构造方法来初始化一个父类对象。2父类只定义了有参构造方法，在创建子类的对象时，在子类构造方法中必需运用关键字super来替代父类的构造方法，而且super必需是子类构造方法的第一条语句。3父类既定义了无参构造方法，也定义了有参构造方法，在创建子类的对象时，可以运用super调用父类的有参构造方法，也可以不运用super，这时系统会自动调用父类的无参构造方法。9.2.3 再论方法重载再论方法重载 在一个类中可以定义多个同名的方法，这些方法经过参数的不同参数的个数不同或类型不同来区分，称为方法的重载。在父类中定义了某个方法，而在子类中也定义了名字一样的方法，但两个方法的
9、参数不同，这是也构成了重载。下面程序代码展现了这种情况：9.2.3 再论方法重载再论方法重载/ OverloadInExtend.javaclass School void show(int i)System.out.println(show( + i + );void show(int i,int j)System.out.println(show( + i + , + j + );class University extends School void show(char c)System.out.println(show( + c + );public class OverloadInE
10、xtend public static void main(String args) University u = new University();u.show(1);u.show(2,3);u.show(a); 在University类中有三个show方法：show(char c)、show(int i)和show(int j)，三个方 法构成重载方法，其中后两个show方法是从父类School中承继过来的。 9.2.4 变量的隐藏和方法的重写变量的隐藏和方法的重写 由于子类可承继父类中的方法，所以子类不需求重新编写一样的方法。但有时子类并不想原封不动地承继父类的方法，而是想作一定的修正，
11、这就需求采用方法的重写。方法重写又称方法覆盖。 假设子类中的方法与父类中的某一方法具有一样的方法名、前往类型和参数表，那么新方法将覆盖原有的方法。 子类中也可以定义与父类中名字一样的成员变量，由于名字一样，在子类中，从父类承继过来的这个变量被隐藏。下面的程序代码展现了方法的重写和变量的隐藏：9.2.4 变量的隐藏和方法的重写变量的隐藏和方法的重写 / Overriding.javaclass Tree double height = 10.2;void printHeight()System.out.println(Tree height: + height);void printName(S
12、tring name)System.out.println(Tree name: + name);class Pine extends Tree double height = 20.3;void printHeight()System.out.println(Pine tree height: + height);void printName(String name)System.out.println(Pine tree name: + name);public class Overriding public static void main(String args) Pine p = n
13、ew Pine();p.printName(MyTree);p.printHeight();9.2.5 super关键字关键字 在“父类的初始化一节中证明了：在创建子类的对象时，会先创建一个父类的对象。那么，怎样去援用里面的父类对象呢？答案是运用super，this指的是当前对象的援用，而super是当前对象里面的父类对象的援用。下面是super的用法：1在子类构造方法中调用父类构造方法。例如程序如Square.java；2在子类中访问被重写的父类方法；3在子类中访问被隐藏的父类成员变量。9.3 final关键字关键字 被关键字final修饰的东西是不能被修正的，final可以修饰变量、方法和
14、类。 9.3.1 final修饰的变量修饰的变量 声明final字段有助于优化器作出更好的优化决议，由于假设编译器知道字段的值不会更改，那么它能平安地在存放器中高速缓存该值。final字段还经过让编译器强迫该字段为只读来提供额外的平安级别。 final修饰的变量一旦被初始化便不可改动，这里不可改动的意思对根本类型来说是其值不可变，而对于复合数据类型来说其援用不可再变。 关键字final修饰的变量也可以定义为static的，称为静态常量，在内存中占据一段不能改动的存储区域，表示静态常量的名字全部用大写字母。 9.3.1 final修饰的变量修饰的变量 下面程序展现了final的用法：/ Fina
15、lData.javapublic class FinalData final int a = 1;static final int B = 2;final int c = 1,2,3,4,5;public static void main(String args) FinalData f = new FinalData();/*f.a = 10;/编译错误FinalData.B = 20;/编译错误f.c = new int10;/编译错误*/f.c0 = 10;for (int i = 0;i f.c.length;i+)System.out.print(f.ci + ); 9.3.2 空白
16、空白final 在Java中，假设在声明变量时不给其赋值，系统可以对其进展自动初始化，根本类型变量自动初始化为0，其他类型变量自动初始化为空。但是final类型的变量必需显示初始化，且初始化只能在两个地方进展：一是在定义处，二是在构造方法中。且不能同时即在定时时赋值，又在构造方法中赋值。 假设在声明final的变量时没有给其赋值，那么称为空白final，这个变量只需一次赋值时机，那就是在构造方法中。9.3.2 空白空白final下面程序展现了空白final的赋值：/ BlankFinal.javapublic class BlankFinal private final int a;/空白fi
17、nalvoid setA(int a)/this.a = a;/编译错误BlankFinal(int a)this.a = a;public static void main(String args) BlankFinal blankFinal = new BlankFinal(10);/blankFinal.a = 20;/编译错误System.out.println(blankFinal.a);9.3.3 final修饰的方法修饰的方法 假设一个类不允许其子类覆盖重写某个方法，那么可以把这个方法声明为final的方法。另外，类中一切的private方法都被隐含是final的。由于无法取用p
18、rivate方法，那么也无法对其重载。 下面程序代码测试了final方法：9.3.3 final修饰的方法修饰的方法/ FinalMethodDemo.javaclass FinalMethodfinal void show()System.out.println(show() in FinalMethod);private void pMethod1()System.out.println(pMethod1 in FinlaMethod);private final void pMethod2()System.out.println(pMethod1 in FinlaMethod);publ
19、ic class FinalMethodDemo extends FinalMethod /final void show()/编译错误，不能重写覆盖show()方法private void pMethod1()System.out.println(pMethod1 in FinalMethodDemo);private final void pMethod2()System.out.println(pMethod1 in FinalMethodDemo);public static void main(String args) FinalMethodDemo f1 = new FinalMe
20、thodDemo();f1.pMethod1();f1.pMethod2();System.out.println(-);FinalMethod f2 = f1;/f2.pMethod1();/f2.pMethod2();9.3.4 final修饰的参数修饰的参数 当函数参数为final类型时，他可以读取运用该参数，但是无法改动该参数的值。 另外，方法的参数被其内部类运用时，必需被声明为final的将在第十讲中讲解内部类的相关内容。 / FinalArgument.javapublic class FinalArgument void show(final String s)/s = s +
21、!;/编译错误System.out.println(s);public static void main(String args) FinalArgument f = new FinalArgument();f.show(hello);f.show(java); 9.3.5 final修饰的类修饰的类 final修饰的类不能被承继，因此final类的成员方法没有时机被覆盖，默许都是final的。在设计类时候，假设这个类不需求有子类，类的实现细节不允许改动，并且确信这个类以后不会再被扩展，那么就设计为final类 / FinalClassDemo.javafinal class FinalCla
22、ssvoid show() /默许被final修饰public class FinalClassDemo extends FinalClass / 编译错误public static void main(String args) 9.4 多态多态多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。多态可以消除类型间的耦合关系。要了解Java中的多态，必需了解向上转型和动态绑定。9.4.1 向上转型向上转型在Java中，子类可以承继父类的一切成员，这是承继的重要作用，但承继最重要的作用在于可以表现父类和子类之间的关系，这种关系就是：可以把子类对象当做父类对象来运用。 / Dr
23、awShape.javaclass Shape class Circle extends Shape public class DrawShape public static void main(String args) Shape s = new Shape();Shape c = new Circle();/向上转型9.4.1 向上转型向上转型 上面程序中，把子类Circle创建的对象赋值给了父类Shape类型的援用c，即父类的援用c指向的是子类对象。在Java中，这种景象被称之为向上转型。之所以是向上转型，是由于在承继关系中，父类在子类的上层Java是单根承继的，如图9.1所示： 图9.
24、1 类的承继关系图 在向上转型过程中，能够会发生方法的丧失，由于子类是父类的一个超集，能够比父类包含更多的方法。但这种转型总是平安的，由于子类承继了父类中一切的成员。9.4.1 向上转型向上转型对DrawShape.java进展修正：/ DrawShape.javaclass Shape void print()System.out.println(print();class Circle extends Shape void printR()System.out.println(printR();public class DrawShape public static void main(S
25、tring args) Shape s = new Shape();s.print();System.out.println(-);Circle c = new Circle();c.print();c.printR();System.out.println(-);Shape u = new Circle();/向上转型u.print();/u.printR();/方法丧失9.4.2 动态绑定动态绑定 假设子类重写了父类中的方法，子类对象向上转型后，运用父类援用调用这些重写的方法会产生什么结果呢？继续修正DrawShape.java：/ DrawShape.javaclass Shape vo
26、id print()System.out.println(Shape);class Circle extends Shape void print()System.out.println(Circle);public class DrawShape public static void main(String args) Shape s = new Shape();s.print();Circle c = new Circle();/向上转型c.print();9.4.2 动态绑定动态绑定 程序运转结果： Shape Circle 从上面程序的运转结果可以看出：父类援用c指向的是子类对象，但c
27、.print()调用的是子类中重写过的方法。产生这种结果的缘由是“动态绑定。 将一个方法调用同一个方法主体关联起来被称作绑定。假设在程序执行前进展绑定，叫做前期绑定C言语是前期绑定。在运转时根据对象的类型进展的绑定称为后期绑定，也称为动态绑定或运转时绑定。9.4.3 多态的益处多态的益处 正是由于Java对于非私有的实例方法采用的是动态绑定，保证了被向上转型的对象总可以产生正确的行为，从而在一定程度上消除了类型间的耦合关系。我们在设计代码时，只需思索父类对象即可，不用关怀子类对象，它适用于一切子类对象。下面程序代码展现了多态的益处：/DrawShape.javaclass Shape void
28、 print()System.out.println(Shape);class Circle extends Shape void print()System.out.println(Circle);class Rectangle extends Shape void print()System.out.println(Rectangle);9.4.3 多态的益处多态的益处class Square extends Shape void print()System.out.println(Square);public class DrawShape static void draw(Shape
29、s)s.print();public static void main(String args) Shape s = new Shape();draw(s);s = new Circle();/向上转型draw(s);s = new Rectangle();/向上转型draw(s);s = new Square();/向上转型draw(s); 在上面程序中，在设计draw方法时，让其接纳父类Shape类型的参数，由于向上转型，此方法可以接纳一切Shape的子类对象，由于动态绑定，s总能找到正确的print()方法。9.4.4 多态的缺陷多态的缺陷 在Java中多态只需非私有的实例方法才是多态的
30、，私有方法、静态方法、域都不是多态的。看下面的两个例子：/ FaultOne.javapublic class FaultOne /public void show()private void show() System.out.println(FauletOne); public static void main(String args) FaultOne fault = new PrivateFult();fault.show();class PrivateFult extends FaultOne public void show()System.out.println(PrivateF
31、ult);9.4.4 多态的缺陷多态的缺陷/ FaultTwo.javaclass SuperClass int a = 10;public static void show()System.out.println(SuperClass);class SubClass extends SuperClass int a=20;public static void show()System.out.println(SubClass);public class FaultTwo public static void main(String args) SuperClass s = new Super
32、Class();System.out.println(s.a = + s.a);s.show();System.out.println(-);SubClass s1 = new SubClass();System.out.println(s1.a = + s1.a);s1.show();System.out.println(-);SuperClass s2 = new SubClass();System.out.println(s2.a = + s2.a);s2.show(); 9.5 本讲小结本讲小结本讲首先讲述了实现代码复用的机制：组合和承继，然后讨论了关键字final的用法，最后讨论了J
33、ava中多态。讲后练习讲后练习1. 设计一个表示二维平面上点的类Point，包含有表示坐标位置的protected类型的成员变量x和y，获取和设置x和y值的public方法。 设计一个表示二维平面上圆的类Circle，它承继自类Point，还包含有表示圆半径的protected类型的成员变量r、获取和设置r值的public方法、计算圆面积的public方法。 设计一个表示圆柱体的类Cylinder，它承继自类Circle，还包含有表示圆柱体高的protected类型的成员变量h、获取和设置h值的public方法、计算圆柱体体积的public方法。 建立Cylinder对象，输出其轴心位置坐标、半径、面积、高及其体积的值。讲后练习讲后练习2、什么是向上转型和动态绑定？3、编写程序分别测试final修饰的变量、方法、参数和类具有什么特性。
