第三章 继承.ppt

1、2020/7/9,1,在日常生活中，我们常用“是一种（is-a）”关系来组织与表达知识，从而将知识组织成一种有层次、可分类的结构。 面向对象程序设计方法将is-a关系引入到程序设计领域，用于描述类与类之间的关系，称之为继承。,3.7 类的继承,2020/7/9,2,bicycle,(super class),Mountain bikes,Racing bikes,Tandem bikes,sub class,3.7 类的继承,2020/7/9,3,类之间的继承关系是现实世界中遗传关系的直接模拟，它表示类之间的内在联系以及对属性和操作的共享，即子类可以沿用父类（被继承类）的某些特征。当然，子类也

2、可以具有自己独立的属性和操作。 继承性是面向对象程序设计语言的最主要的特点，是其他语言（如面向过程语言）所没有的。,3.7 类的继承,例如，飞行器、汽车和轮船可归于交通工具类，飞行器类可以继承交通工具类某些属性和操作。,2020/7/9,4,继承性是软件复用的一种形式。新类由已存在的类生成，通过保留它们的属性和行为，并且根据新类的要求对性能加以修改，添加新的属性和行为。 如果子类只从一个父类继承，则称为单继承；如果子类从一个以上父类继承，则称为多继承。注意 Java不支持多重继承，但它支持“接口”概念。接口使Java获得了多重继承的许多优点，摒弃了相应的缺点。,3.7 类的继承,2020/7/

3、9,5,类继承的规则： 直接子类继承那些被声明为public 或protected的直接父类成员（包括成员变量和成员方法，下同） 直接子类继承那些未被存取权限修饰符修饰的直接父类成员，只要该子类与该父类在同一个包中 如果直接子类声明了一个与直接父类中的成员同名的成员，则该子类继承自该父类中的该同名成员隐藏 直接子类不继承被修饰为private的直接父类的成员,3.7 类的继承,2020/7/9,6,3.7.1 子类的定义,通过在类的声明中加入extends子句来定义一个类的子类，其基本格式为： class 子类名 extends 父类名 新的成员变量 新的成员方法 其中，父类可以是自定义的类或

4、java类库中的类。,2020/7/9,7,3.7.1 子类的定义,例如：下面是定义的人和学生两个类： class Person int age; int height; void eat() void sleep() ,class Student int age; int height; int score; void eat() void sleep() void study() ,2020/7/9,8,学生属于人类，所以具有人类的属性，所以“学生”类便拥有“人”类的所有成员。也就是“学生”类继承“人”类。重新定义： class Person int age; int height; vo

5、id eat() void sleep() ,3.7.1 子类的定义,class Student extends Person int score; void study() ,只需要定义其新增加的属性即可,2020/7/9,9,其中处于继承关系中的“人”类称作“父类”（parent类）或超类（super类），而把学生类称为子类（ sub 类）或派生类。 如果在某个类的声明语句后没有使用extends关键字的话，实际上该类隐式的继承了java类库中的Java.lang.Object类。,3.7.1 子类的定义,2020/7/9,10,class Inher1_1 int a; void hi(

6、) System.out.println(“Hi); public class Inher1 extends Inher1_1 public static void main(String args) Inher1 ob=new Inher1(); ob.a=10; ob.hi(); ,2020/7/9,11,分析程序： class A int i=1; public void printI() System.out.println(i=+i); public class B extends A public static void main(String args) B b=new B();

7、 b.printI(); ,3.7.1 子类的定义,2020/7/9,12,定义一个位置坐标类，属性有x和y坐标，成员函数包括构造函数、获取x坐标的函数、获取y坐标的函数和移动到指定点函数。然后定义派生类点类，除了继承基类的成员外，又增加了新的数据成员颜色、获取颜色值的成员函数和显示数据成员值的函数。,class CLocation /位置坐标类 private int x; private int y; public CLocation(int x, int y) this.x = x; this.y = y; public void MoveTo(int newX, int newY) x

8、 = newX; y = newY; public int Getx() return x; public int Gety() return y; ,class CPoint extends CLocation /从CLocation中继承 private String Color; public CPoint(String c) Color = c; public void SetColor(String c) Color = c; public void Show() System.out.println(Getx()+”,”+Gety()+” ”+Color); class test

9、public static void main(String args) CPoint p = new CPoint(“red”); p.Show(); p.MoveTo(7, 8); p.Show(); p.SetColor(Green); p.Show(); ,2020/7/9,15,3.7.2 子类的构造方法,子类的对象中既包含从父类继承来的实例变量,也包含它新定义的实例变量，为了构造一个子类自己的对象，必须对所有这些变量进行正确的初始化。 子类的构造方法可以用来初始化新定义的实例变量，但需要委托父类的构造方法来正确初始化子类中从父类中继承下来的实例变量，因此，子类的构造方法必须显式或隐

10、式地调用父类的构造方法。,2020/7/9,16,3.7.2 子类的构造方法,注意：子类不继承父类的构造方法，因此子类如果想显式的使用父类的构造方法，必须在子类的构造方法的第一条语句中使用关键字super来完成此功能。 super的格式为： super（参数） 比如在前面CPoint类的基础上可以添加一个子类的构造函数。,2020/7/9,17,3.7.2 子类的构造方法,class CPoint extends CLocation /从CLocation中继承 private String Color; public CPoint(String c) Color = c; public CP

11、oint(int x, int y, String c) super(x, y); Color = c; public void SetColor(String c) Color = c; public void Show() System.out.println(Getx()+”,”+Gety()+” ”+Color); ,2020/7/9,18,3.7.2 子类的构造方法,子类的构造方法参数列表中包括了用来初始化子类中所有的实例变量（包括本类新定义的和从父类继承的）的参数。 其中第一行代码通过super()方法来显式的调用父类的构造方法。,2020/7/9,19,java中通过super来

12、实现对父类成员的访问，super用来引用当前对象的父类。Super 的使用有三种情况：1）访问父类被隐藏的成员变量，如：super.variable; 2）调用父类中被重写的方法，如：super.Method(paramlist);3）调用父类的构造函数，如：super(paramlist); 注：必须显式调用另一个构造函数，构造函数调用必须是构造函数中的第一个语句。,3.7.2 super,2020/7/9,20,注意: (1)创建子类对象时，子类的构造方法总是先调用父类的某个构造方法。 （2）如果子类的构造方法没有用super()方法显式调用父类的某个构造方法，则子类就调用父类的不带参数的

13、构造方法，即对父类的构造方法进行隐式调用。 （3）如果子类也没有显式定义自己的构造方法，那么编译器会为子类定义一个默认的构造方法，在生成子类对象时，仍然先调用父类的构造方法。,3.7.2 子类的构造方法,例：class Inher2_1 int a; Inher2_1() a=10; System.out.println(“调用父类构造函数); public class Inher2 extends Inher2_1 int b; Inher2() b=20; System.out.println(“调用子类构造函数); public static void main(String args)

14、 Inher2 ob=new Inher2(); System.out.println(ob.a+ +ob.b); ,调用父类构造函数 调用子类构造函数 10 20,例：class Inher3_1 int a; Inher3_1() a=0; Inher3_1(int a) this.a=a; public class Inher3 extends Inher3_1 int b; Inher3(int a, int b) super(a); this.b=b; public static void main(String args) Inher3 ob=new Inher3(10, 20);

15、 System.out.println(ob.a+ +ob.b); ,2020/7/9,23,3.7.2 构造方法调用顺序,【例】： class Art Art( ) /父类构造方法 System.out.println(“Art constructor”); class Drawing extends Art Drawing( ) /子类构造方法 System.out.println(“Drawing constructor”); public static void main(String args) Drawing x=new Drawing( ); ,【例】 class X prote

16、cted int xMask=0 x00ff; protected int fullMask; public X() System.out.println(fullMask); fullMask = xMask; ,class Example extends X protected int yMask = 0 xff00; public Example () fullMask = yMask; public static void main(String args) Example y = new Example(); System.out.println(y.fullMask); ,2020

17、/7/9,25,class A protected void print(String s) System.out.println(s); A()print(A(); public void f() print(A:f(); class B extends A B()print(B(); public void f() print(B:f(); public static void main(String arg) B b = new B(); b.f(); ,2020/7/9,26,3.7.3 方法的覆盖,如果子类中定义方法所用的名称、返回类型和参数表和父类中方法所使用的完全一样，但具体实现

18、不同，则称子类方法覆盖了父类中的方法，在子类对象上调用相应子类中定义的方法。 方法覆盖也叫方法重写。子类可以使用super方法调用被子类隐藏的成员变量和被子类覆盖的方法.,2020/7/9,27,3.7.3 方法覆盖的示例程序,【例】class point void print() System.out.println(This is the superclass!); class point3d extends point void print() System.out.println(This is the subclass!); public static void main(Strin

19、g args) point superp = new point(); superp.print(); point3d subp = new point3d(); subp.print(); ,class Inher5_1 int a=10; public class Inher5 extends Inher5_1 int a=20; void f() System.out.println(super.a); System.out.println(this.a); public static void main(String args) Inher5 ob=new Inher5(); ob.f

20、(); ,class Inher6_1 void hello() System.out.println(“Hi); public class Inher6 extends Inher6_1 void hello() super.hello(); System.out.println(“高兴); public static void main(String args) Inher6 ob=new Inher6(); ob.hello(); ,class Inher7_1 void hello() System.out.println(“Hi); public class Inher7 exten

21、ds Inher7_1 void hello(String a) System.out.println(a); public static void main(String args) Inher7 ob=new Inher7(); ob.hello(); ob.hello(“高兴); ,不是覆盖关系，是重载,【例】使用super指针调用被隐藏的父类方法 class point void print() System.out.println(This is the superclass!); class point3d extends point void print() super.prin

22、t(); System.out.println(This is the subclass!); public static void main(String args) point superp=new point(); superp.print(); point3d subp=new point3d(); subp.print(); ,2020/7/9,32,class Father void speak( ) / 超类定义的speak方法 System.out.println(I am Father！); class Son extends Father void speak( ) / 子

23、类重构的speak方法 System.out.println(I am Son！); ,3.7.3 方法覆盖的示例程序,2020/7/9,33,3.7.3 成员变量的隐藏,子类可以隐藏继承的成员变量，当在子类中定义和父类中同名的成员变量时，子类就隐藏了继承的成员变量，即子类对象以及子类自己声明定义的方法操作的是子类中新定义和父类中同名的成员变量。 可以使用super关键字来访问被隐藏的父类成员变量。,2020/7/9,34,class A int x； class B extends A int x; void m( ) super.x = 2; x = 100; System.out.pri

24、ntln(super.x+“n”+x); public static void main(String args) B b1 = new B(); b1.m(); ,3.7.3 成员变量的隐藏,2020/7/9,35,3.7.3 成员变量的隐藏,例： class A protected double y=22.36; class B extends A double y=0.0; void g() y=y+100; System.out.println(y); public static void main(String args ) B b=new B(); b.y=-100; b.g();

25、 A a=new B(); System.out.println(a.y); ,2020/7/9,36,上例中子类B的main()方法中创建了B类的对象b，b中实际上有两个成员变量,一个是从父类继承而来的,另一个是自身定义的,这两个成员变量名相同。 将一个父类引用指向一个子类对象时,通过父类引用来存取同名成员变量,则存取的是从父类继承而来的成员变量的值。但通过子类对象存取的是子类自身所定义的同名成员变量的值 。从这个角度而言，称子类隐藏了从父类继承的同名变量。,3.7.3 成员变量的隐藏,2020/7/9,37,3.7.4 子类对象和父类对象间的转换,假设B是A的子类，当用子类B创建一个对象，

26、并让一个A类的引用来实际指向这个子类对象时，比如： A a=new B(); 那么就称通过引用a所指向的对象是子类对象的上转型对象，即可以将一个对象作为它自己的类型使用，或者作为它的父类类型的一个对象使用。 一个对象的上转型对象的实体是子类负责创建的，但由于是通过父类型的引用来使用对象时，就只能使用其父类型中所定义的公有接口功能，而会失去原对象的一些属性和功能。,2020/7/9,38,3.7.4 子类对象和父类对象间的转换,class shape static public void draw(shape s) System.out.println(“draw shape”); class

27、line extends shape public static void main(String args ) line l=new line(); shape.draw(l); / 相当于shape.draw(shape)l); 从上例可以看出，对子类进行向上强制类型转换是允许的，且不需要强制类型转换符。,2020/7/9,39,将子类对象看待为父类对象来使用总是安全的，因为把一个较具体的类型转换为较为一般的类型，它可能会有一些父类没有的方法，但是它至少要有基类的方法。 而对于向下类型转换，编译器必须满足这样的条件，即类型转换至少是可能的，类型转换发生的类必须是当前引用类型的子类。 在类层

28、次中，层次越高其兼容性越广，或者说层次越低越具体。如果期望得到一个父类型对象而实际得到了一个子类型对象，那么就需要进行向上转换(upcasting)。这种转换将导致子类型对象被当作父类型的实例来对待，并且可以在编译时进行检查。与此相反，将父类型对象转换为子类型对象，我们将它称作向下转换（downcasting）。,3.7.4 子类对象和父类对象间的转换,2020/7/9,40,例如收银员在对顾客进行结账时，可以对收银员类添加一个方法表示该行为： class operator /成员变量 public void checkOut(customer s) /函数实现 ,3.7.4 子类对象和父类对

29、象间的转换,顾客类,2020/7/9,41,在调用operator类的checkOut方法时，可以将customer和VIPCustomer类对象的引用作为参数进行调用。在checkOut方法中，如果需判断参数s所实际引用的具体类型，可用instanceof运算符判断。 class operator /成员变量 public void checkOut(customer s) if(s instanceof VIPCustomer) VIPCustomer v = (VIPCustomer )s;/向下类型转换 ,3.7.4 子类对象和父类对象间的转换,class Customer void print() System.out.println(普通顾客); class VIPCustomer extends Customer void print() System.out.println(VIP顾客); pu