面向对象之继承与多态

面向对象程序设计语言有三大特性：封装、继承和多态性。继承是面向对象语言的重要特征之一，没有继承的语言只能被称作“使用对象的语言”。继承是非常简单而强大的设计思想，它提供了我们代码重用和程序组织的有力工具。

类是规则，用来制造对象的规则。我们不断地定义类，用定义的类制造一些对象。类定义了对象的属性和行为，就像图纸决定了房子要盖成什么样子。

一张图纸可以盖很多房子，它们都是相同的房子，但是坐落在不同的地方，会有不同的人住在里面。假如现在我们想盖一座新房子，和以前盖的房子很相似，但是稍微有点不同。任何一个建筑师都会拿以前盖的房子的图纸来，稍加修改，成为一张新图纸，然后盖这座新房子。所以一旦我们有了一张设计良好的图纸，我们就可以基于这张图纸设计出很多相似但不完全相同的房子的图纸来。

基于已有的设计创造新的设计，就是面向对象程序设计中的继承。在继承中，新的类不是凭空产生的，而是基于一个已经存在的类而定义出来的。通过继承，新的类自动获得了基础类中所有的成员，包括成员变量和方法，包括各种访问属性的成员，无论是public还是private。当然，在这之后，程序员还可以加入自己的新的成员，包括变量和方法。显然，通过继承来定义新的类，远比从头开始写一个新的类要简单快捷和方便。继承是支持代码重用的重要手段之一。

类这个词有分类的意思，具有相似特性的东西可以归为一类。比如所有的鸟都有一些共同的特性：有翅膀、下蛋等等。鸟的一个子类，比如鸡，具有鸟的所有的特性，同时又有它自己的特性，比如飞不太高等等；而另外一种鸟类，比如鸵鸟，同样也具有鸟类的全部特性，但是又有它自己的明显不同于鸡的特性。

如果我们用程序设计的语言来描述这个鸡和鸵鸟的关系问题，首先有一个类叫做“鸟”，它具有一些成员变量和方法，从而阐述了鸟所应该具有的特征和行为。然后一个“鸡”类可以从这个“鸟”类派生出来，它同样也具有“鸟”类所有的成员变量和方法，然后再加上自己特有的成员变量和方法。无论是从“鸟”那里继承来的变量和方法，还是它自己加上的，都是它的变量和方法。

继承

继承表达了一种is-a关系，就是说，子类的对象可以被看作是父类的对象。比如鸡是从鸟派生出来的，因此任何一只都可以被称作是一只鸟。但是反过来不行，有些鸟是鸡，但并不是所有的鸟都是鸡。如果你设计的继承关系，导致当你试图把一个子类的对象看作是父类的对象时显然很不合逻辑，比如你让鸡类从水果类得到继承，然后你试图说：这只本鸡是一种水果，所以这本鸡煲就像水果色拉。这显然不合逻辑，如果出现这样的问题，那就说明你的类的关系的设计是不正确的。Java的继承只允许单继承，即一个类只能有一个父类。

对理解继承来说，最重要的事情是，知道哪些东西被继承了，或者说，子类从父类那里得到了什么。答案是：所有的东西，所有的父类的成员，包括变量和方法，都成为了子类的成员，除了构造方法。构造方法是父类所独有的，因为它们的名字就是类的名字，所以父类的构造方法在子类中不存在。除此之外，子类继承得到了父类所有的成员。
但是因为访问修饰符的原因，不一定能直接使用。

public的成员直接成为子类的public的成员，protected的成员也直接成为子类的protected的成员。Java的protected的意思是包内和子类可访问，所以它比缺省的访问属性要宽一些。而对于父类的缺省的未定义访问属性的成员来说，他们是在父类所在的包内可见，如果子类不属于父类的包，那么在子类里面，这些缺省属性的成员和private的成员是一样的：不可见。父类的private的成员在子类里仍然是存在的，只是子类中不能直接访问。我们不可以在子类中重新定义继承得到的成员的访问属性。如果我们试图重新定义一个在父类中已经存在的成员变量，那么我们是在定义一个与父类的成员变量完全无关的变量，在子类中我们可以访问这个定义在子类中的变量，在父类的方法中访问父类的那个。尽管它们同名但是互不影响。

在构造一个子类的对象时，父类的构造方法也是会被调用的，而且父类的构造方法在子类的构造方法之前被调用。在程序运行过程中，子类对象的一部分空间存放的是父类对象。因为子类从父类得到继承，在子类对象初始化过程中可能会使用到父类的成员。所以父类的空间正是要先被初始化的，然后子类的空间才得到初始化。在这个过程中，如果父类的构造方法需要参数，如何传递参数就很重要了。

如果子类继承到了父类中private的东西，子类无法直接访问。
如果子类有和父类完全一样的成员变量，子类中会用自己的那一份。但一般子类不会再定义和父类中同名的变量。

多态变量和向上转型

当把一个对象赋值给一个变量时,对象的类型必须与变量的类型相匹配,如:

Car myCar = new Car(); 

是一个有效的赋值,因为Car类型的对象被赋值给声明为保存Car类型对象的变量。但是由于引入 了继承,这里的类型规则就得叙述得更完整些:

一个变量可以保存其所声明的类型或该类型的任何子类型。也就是说子类的对象可以被当作父类的对象来使用。

对象变量可以保存其声明的类型的对象,或该类型的任何子类型的对象。

Java中保存对象类型的变量是多态变量。“多态”这个术语(字面意思是许多形态)是指一个变量可以保存不同类型(即其声明的类型或任何子类型)的对象。
当把子类的对象赋值给父类的变量的时候就发生了“向上转型”。

Java和C++的一个区别就是：对象之间无法赋值。

即使是这里item中确实存放的是一个CD类型的对象，但把它赋值给一个CD类型的变量，编译器依然是会报错的，因为编译器不懂它里面是CD类型，编译器只知道item的引用变量类型是Item不是CD，所以它认为错了。
所以这里需要强制类型转换。

向上转型：

• 拿一个子类的对象当作父类的对象来使用
• 向上转型是默认的，不需要运算符
• 向上转型是安全的

多态

如果子类的方法覆盖了父类的方法，我们也说父类的那个方法在子类有了新的版本或者新的实现。覆盖的新版本具有与老版本相同的方法签名：相同的方法名称和参数表。因此，对于外界来说，子类并没有增加新的方法，仍然是在父类中定义过的那个方法。不同的是，这是一个新版本，所以通过子类的对象调用这个方法，执行的是子类自己的方法。

覆盖关系并不说明父类中的方法已经不存在了，而是当通过一个子类的对象调用这个方法时，子类中的方法取代了父类的方法，父类的这个方法被“覆盖”起来而看不见了。而当通过父类的对象调用这个方法时，实际上执行的仍然是父类中的这个方法。注意我们这里说的是对象而不是变量，因为一个类型为父类的变量有可能实际指向的是一个子类的对象。

当调用一个方法时，究竟应该调用哪个方法，这件事情叫做绑定。绑定表明了调用一个方法的时候，我们使用的是哪个方法。绑定有两种：一种是早绑定，又称静态绑定，这种绑定在编译的时候就确定了；另一种是晚绑定，即动态绑定。动态绑定在运行的时候根据变量当时实际所指的对象的类型动态决定调用的方法。Java缺省使用动态绑定。

函数调用的绑定：

• 当通过对象变量调用函数的时候，调用哪个函数这件事情叫做绑定
• 静态绑定：根据变量的声明类型来决定
• 动态绑定：根据变量的动态类型来决定
• 在成员函数中调用其它成员函数也是通过this这个对象变量来调用的

常见问题：

1. 父类的私有成员能被子类继承吗？
   官方文档的解释：“A subclass does not inherit the private members of its parent class. However, if the superclass has public or protected methods for accessing its private fields, these can also be used by the subclass.”。原文地址：Inheritance

从继承的概念来说，private和final不被继承。Java官方文档上是这么说的。从内存的角度来说，父类的一切都被继承(从父类构造方法被调用就知道了，因为new一个对象，就会调用构造方法，子类被new的时候就会调用父类的构造方法，所以从内存的角度来说，子类拥有一个完整的父类)。子类对象所引用的内存有父类变量的一份拷贝。
　　如图所示，父类为Ｐｅｒｓｏｎ类，子类为Ｓｔｕｄｅｎｔ类。首先明确子类不能继承父类的构造方法。这就是为什么子类的默认的构造方法会自动调用父类的默认的构造方法。
　　在子类的构造方法中通过super()方法调用父类的构造方法。也就是，在构造子类的同时，为子类构造出跟父类相同的域。如此就在子类的对象中，也拥有了父类声明的域了。

父类的私有变量能被子类继承，但在子类中无法直接访问父类的私有变量。只有借助公共的方法来访问父类的私有变量。

//显式说明使用父类地getSalary()
public double getSalary() {
double baseSalary = super.getSalary()* return baseSalary + bonus;
}
//而不是使用子类中同名的getSalary方法，这样会导致无限次地调用自己，直到内存溢出
public double getSalary() {
double baseSalary = getSalary()；// still won't work return baseSalary + bonus;
}

注意：
有些人认为 super 与 this 引用是类似的概念， 实际上，这样比较并不太恰当。这是 因为 super 不是一个对象的引用，不能将 super 赋给另一个对象变量，它只是一个指示编 译器调用超类方法的特殊关键字。
关于成员变量的继承,父类的任何成员变量都是会被子类继承下去的，这些继承下来的私有成员虽对子类来说不可见,但子类仍然可以用父类的函数操作他们.
这样的设计的意义就是我们可以用这个方法将我们的成员保护得更好,让子类的设计者也只能通过父类指定的方法修改父类的私有成员,这样将能把类保护得更好,这对一个完整的继承体系是尤为可贵的.

2. Java实例化的时候为什么一定要调用父类的构造方法，为什么父类的构造方法无法被继承？

   构造方法的定义 是与类的名称相同；如果子类能够继承父类的构造方法；那么在子类的构造方法中就有不同于子类名称的构造法；
   这与构造方法的定义不符；所以子类是不能继承父类的构造方法的；
   究其原因，想必是 Java 语言设计者，要求子类有责任保证它所继承的父类尽快进入到一个稳定、完整的状态中。试想，如果没有这个约束，那么子类的某个继承自父类的方法可能会使用到父类中的一些变量，而这些变量并没有进行初始化，从而产生一些难以预料的后果，因此构造子类的对象前，必须构造父类的对象，并将之隐含于子类对象之中，使用关键字super引用父类对象。
   也因此，当一个类的构造方法是 private 时，它是不可被 extends 的，因为子类构造方法难以调用到这个父类的构造方法。

3. 为什么不能用子类的构造器去初始化继承到的父类的成员呢？
   首先实例化就是给对象分配内存，构造方法就是分配内存的实现，那么，子类如何才能更方便的分配内存呢？很显然，就是调用父类构造方法来分配父类部分的内存，然后再调用自己的构造方法来分配子类扩展的内存。否则，如果子类完全从头开始自己分配内存，那么继承父类又有什么优点呢？因为子类的父类部分是完全和父类一样的，你觉得有必要再自己从头开始分配内存吗？既然父类的内存分配已经有现成的方法，为什么不直接调用来分配父类部分的内存呢？