多态

继承、封装、多态、抽象是面向对象编程的四大基本特征。封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提条件下，改变类的内部结构，同时保护了数据。继承是为了重用父类代码，同时为多态做准备。那么，什么是多态呢？

所谓多态，英文单词为polymorphism，这个英文单词是由单词poly(意思是很多或多个)和morph(意思是形状或形式)组成的复合词。多态一词最早出现在生物学，是指生物学的一个基本原则：一个生物或物种可以有多种不同的形式或阶段。面向对象编程吸收了这一原则，在OOP中，多态是指一个对象有多种形式的能力。一个类的子类可以定义它们唯一的行为，同时共享父类的某些相同特征。

多态可以说是面向对象编程的精髓所在。因此，理解多态的含义，对理解面向对象编程有特别重要的意义。

Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同。C++允许多继承，这确实给它带来了非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦。为了规避风险，Java只允许单继承，子类与父类间有IS-A的关系。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制。所以，Java引入了多态性的概念，以弥补这点的不足。此外，我们在本节后面要学到的抽象类和接口也是解决单继承规定限制的重要手段。

在Java中，多态有两种理解方式：第一种是对象的不同的方法可以用相同的一个方法名，也就是重载的概念。 另一种是同一对象根据不同的消息执行相应的行为，也可以这样认为发送消息给某一个对象，让对象自行选择哪种相应的行为。根据这种两种方式，所以多态可以分为静态多态和动态多态。

静态多态指的是程序在编译时，系统就能决定调用哪个方法，所以也称为编译时多态。在Java中，静态多态实现的方式就是方法重载，其调用规则是依据对象在定义时的类型相应地调用对应类中的重载方法。

动态多态指在运行中系统才能动态确定方法所指的对象，所以也称为运行时多态。动态多态的实现方式是重写父类中的同名成员方法，其调用规则是依据对象在实例化时而非定义时的类型，相应地调用对应类中的同名成员方法。也就是说，动态多态主要通过动态绑定和重写的机制来实现。

多态技术基础

在Java中，使用动态绑定和重写机制来实现多态，我们首先需要掌握如下三个基础技术概念：

向上转型技术：一个父类的引用变量可以指向不同的子类对象，或者说一个子对象可以被当作一个父类类型。

instanceof关键字：instanceof关键字用于判断运行时对象的真正类型。

可以规避掉“强制向下转型过程中”可能会出现的转型风险。

动态绑定技术：运行时根据父类引用变量所指对象的实际类型执行相应的子类方法，从而实现多态性。

1)向上转型和向下转型

在基础数据类型中，我们已经看到了表达式中数值数据类型byte、short、int、long、float和double的相互转换规则，即：当从低精度数据类型向高精度数据类型转换时实行自动转换，这种类型转换技术称为向上转型；当从高精度数据类型向低精度数据类型转换时，需要使用强制类型转换符，这种类型转换技术称为向下转型。

对于引用数据类型，这种转换技术依然适用。在父类和子类的继承层次关系中，沿着子类向父类向上转型是自动转换，而从父类向子类必须使用强制类型转换才能实现向下转型。

例如：Employee e = new Salary("王二", "胜利大道24号", 47, 250000.00);

这里Salary是Employee的子类

那么，我们为什么要用一个父类类型的引用去指向一个子类的对象呢？为什么不直接用一个子类类型的引用呢？这样做到底有什么意义呢？

这是因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特。定义一个父类类型的引用指向一个子类的对象，既可以使用子类强大的功能，又可以抽取父类的共性，从而可以使代码更容易编写，更容易维护。

既然父类类型的引用没有改变什么，那么为什么不总是用它呢？如果我们使用Employee类型的引用来指向一个Salary对象，对象不会丢失数据，但是用父类类型的引用则不能直接访问Salary类的成员变量和方法的。

如果要用父类类型的引用访问子类的成员变量和方法，我们就必须将Employee类型的引用强制转换为Salary类型的引用。

如：Salary salary =(Salary)e;

注：引用数据类型向下强制转换是有风险的，不一定能够转型成功，如果要转型成功，必须同时满足以下两个要求：

必须是父类引用指向一个子类的实现

强制转换类型必须跟这个子类实现具体的类型一致，不能是父类其他子类的类型

使用instanceof关键字判断对象的真正类型

Java语言的多态机制导致了引用变量的声明类型和实际引用对象的类型可能不一致。为更准确鉴别一个对象的真正类型，Java语言引入了instanceof运算符。

使用instanceof的语句如下：

引用 instanceof 类名

如果引用是指定的类类型，那么instanceof运算符返回true，否则返回false。

动态绑定技术

我们首先要理解Java中的动态绑定机制。

在面向对象程序开发中，我们将一个方法调用与该方法所在的类关联起来，称为"绑定"。绑定分静态绑定和动态绑定，或者称为前期绑定和后期绑定。

所谓静态绑定，是指在程序执行前方法已经被绑定，此时由编译器或其它连接程序实现。针对Java简单的可以理解为程序编译期的绑定；这里特别说明一点，Java中的方法只有final、static、private和构造器是前期绑定。

所谓动态绑定，是指在运行时根据具体对象的类型进行绑定。Java中所有的普通方法，都采用动态绑定技术。通过动态绑定，JVM必须沿着继承层次树向下找，判断一个方法是否被重写。如果方法被重写了，在运行时就执行子类中的方法，而不是编译时调用的父类方法。

多态的主要应用

1)多态参数

所谓多态参数，就是当方法的某个形式参数是一个引用的时候，与该引用兼容的任何对象都可以传递给方法，从而允许方法接受不同数据类型的形式参数。

例如，如下的方法有一个Employee类型的形式参数：

public void payEmployee(Employee e)

如果要调用payEmployee()方法，我们需要用一个Employee对象作为实际参数。如果Salary和Hourly继承自Employee类，那么Salary或Hourly对象也可以作为实际参数传给payEmployee()方法。因为通过多态，Salary或Hourly对象也是一个Employee对象。

现在，通过将Employee类型的引用作为形式参数，使payEmployee()成为了一个更通用的方法。现在，它可以接受Employee、Hourly、Salary对象作为实际参数。如果出现了一个继承自Employee类的新类，那么这个新类也可以传递给payEmplyee()。

2)异构集合

多态最常见的应用是创建一个不是同一类型，但是有共同父类的数据集合。不同对象的集合称为异构集合。

例如所有的类都继承object，如果写一个数组为object类型数组，那么就可以装任何的类型对象。

多态总结

从以上示例，我们可以看出：父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；同时，父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态绑定。也就是说：在多态机制中，是由被引用对象的类型，而不是引用变量的类型，决定了调用谁的成员方法。但是，这个被调用的方法必须是在父类中定义过的，也就是说被子类重写的方法 。

因此，对于多态，我们可以总结它为：

使用父类类型的引用指向子类的对象。

该引用只能调用父类中定义的方法，不能调用子类中独有的方法。

如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法。

在多态中，子类可以调用父类中的所有方法。

在Java中，所有普通方法默认都是动态绑定，要避免动态绑定默认行为的唯一方法是将方法声明为final。声明为final的方法不能被重写，所以JVM不需要沿着继承层次树向下寻找，并试图判断子类是否重写该方法。基于此原因，final方法可以提升性能，因为避免了动态绑定的开销。

抽象

我们在编写类时，通常会在类中定义一些方法，用来描述该类所具有的行为。在类的方法体中，我们编写代码实现该类所要执行的行为。在继承关系中，子类继承父类后，子类也就具有父类所具备的行为。如果子类继承了父类的行为，但是与父类的行为实现方式不同，就需要通过方法重写来覆盖父类的行为。

如果我们不需要类的实例时，就可以将类设计成为一个抽象类。所谓抽象类，是不能被实例化的类。在抽象类中，类的所有其它功能都存在，成员变量、方法、构造器都可以用同样的方式访问。我们只是不能创建抽象类的实例。

抽象类

在Java中，使用关键字abstract可以声明一个抽象类，该关键字可以出现在类声明时class关键字前的任何地方。

我们注意到类除了声明为abstract外，其它的没有改变。现在，我们不能实例化一个抽象的对象。但是对于它的子类没有任何影响。

抽象方法

在父类中有的行为我们不需要去具体实现，因为我们永远不会调用它，但是它又是子类必须有的，我们只需要在子类中去对方法进行重写，进行具体的实现。这种情况下，我们就可以用抽象方法了。如果我们想一个类包含一个特定的方法，该方法的实际实现由子类决定，那么我们就可以在父类中将该方法声明为抽象方法。抽象方法只有方法签名，没有方法体。

代码清单展示了声明为抽象的computePay()方法。注意，该方法没有定义部分，并且方法签名后跟一个分号，没有大括号。

/*代码清单  Employee.java

这里，computePay()方法被声明为抽象方法，在类中没有实现

*/

public abstract class Employee{

private String name;

private String address;

private int number;

public abstract double computePay();

//类定义的剩余部分

}

将一个方法声明为抽象方法有两个结果：

类也必须声明为抽象类。如果一个类包含了抽象方法，那么该类也必须是抽象的。

任何子类必须重写抽象方法，除非子类本身也是抽象的。

从设计的角度看，将一个抽象方法放在父类中，可以强制任何子类实现一个特别的行为。继承抽象方法的子类必须重写该方法。如果子类不重写抽象方法，那么子类必须是抽象类，子类的子类必须重写该方法。最终，必须有一个后代类实现抽象方法，否则，我们就有一个不能实例化的抽象类层次。

那么，为什么要使用方法抽象呢？这是因为强制其它类实现某个行为有好处。

使用抽象类类和抽象方法的好处

用抽象类及接口最重要的用处还是在于，使代码实现很方便的扩展，最简单的就是在new对象时，将生成对象定义为接口，在以后需要替换时就很方便。

抽象类及接口，并不只是为了抽象，为了接口面抽象，而接口。在你需要用到一系列可继承自抽象类的子类，或是需要实现共同接口的多个实现类时，才需要考虑。

其实抽象类的一个好处是类不能被实例化，最大的好处就是通过方法的覆盖来实现多态的属性。也就是运行期绑定。

用抽象的型别统一类型，来进行操作，有利于以后的扩展，移植，复用！！