java提升篇（三）-----理解java的三大特性之多态
面向对象编程有三大特性：封装、继承、多态。html
封装隐藏了类的内部实现机制，能够在不影响使用的状况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。java
继承是为了重用父类代码。两个类若存在IS-A的关系就可使用继承。同时继承也为实现多态作了铺垫。继承存在以下缺陷：编程
一、父类变，子类就必须变。数组
二、继承破坏了封装，对于父类而言，它的实现细节对与子类来讲都是透明的。函数
三、继承是一种强耦合关系。this
那么什么是多态呢？多态的实现机制又是什么？请看我一一为你揭开：spa
所谓多态就是指程序中定义的引用变量所指向的具体类型和经过该引用变量发出的方法调用在编程时并不肯定，而是在程序运行期间才肯定，即一个引用变量倒底会指向哪一个类的实例对象，该引用变量发出的方法调用究竟是哪一个类中实现的方法，必须在由程序运行期间才能决定。由于在程序运行时才肯定具体的类，这样，不用修改源程序代码，就可让引用变量绑定到各类不一样的类实现上，从而致使该引用调用的具体方法随之改变，即不修改程序代码就能够改变程序运行时所绑定的具体代码，让程序能够选择多个运行状态，这就是多态性。.net
好比你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看咱们是不可能知道这是些什么酒，只有喝了以后才可以猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里咱们能够描述成以下：code
酒 a = 剑南春htm
酒 b = 五粮液
酒 c = 酒鬼酒
…
这里所表现的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类，咱们只是经过酒这一个父类就可以引用不一样的子类，这就是多态——咱们只有在运行的时候才会知道引用变量所指向的具体实例对象。
诚然，要理解多态咱们就必需要明白什么是“向上转型”。在继承中咱们简单介绍了向上转型，这里就在啰嗦下：在上面的喝酒例子中，酒（Win）是父类，剑南春（JNC）、五粮液（WLY）、酒鬼酒（JGJ）是子类。咱们定义以下代码：
JNC a = new JNC();
对于这个代码咱们很是容易理解无非就是实例化了一个剑南春的对象嘛！可是这样呢？
Wine a = new JNC();
在这里咱们这样理解，这里定义了一个Wine 类型的a，它指向JNC对象实例。因为JNC是继承与Wine，因此JNC能够自动向上转型为Wine，因此a是能够指向JNC实例对象的。这样作存在一个很是大的好处，在继承中咱们知道子类是父类的扩展，它能够提供比父类更增强大的功能，若是咱们定义了一个指向子类的父类引用类型，那么它除了可以引用父类的共性外，还可使用子类强大的功能。
可是向上转型存在一些缺憾，那就是它一定会致使一些方法和属性的丢失，而致使咱们不可以获取它们。因此父类类型的引用能够调用父类中定义的全部属性和方法，对于只存在与子类中的方法和属性它就可望不可即了---1。
public class Wine {
public void fun1(){
System.out.println("Wine 的Fun.....");
fun2();
}
public void fun2(){
System.out.println("Wine 的Fun2...");
}
}
public class JNC extends Wine{
/**
* @desc 子类重写父类方法
* 父类中不存在该方法，向上转型后，父类是不能引用该方法的
* @param a
* @return void
*/
public void fun1(String a){
System.out.println("JNC 的 Fun1...");
fun2();
}
/**
* 子类重写父类方法
* 指向子类的父类引用调用fun2时，一定是调用该方法
*/
public void fun2(){
System.out.println("JNC 的Fun2...");
}
}
public class Test {
public static void main(String[] args) {
Wine a = new JNC();
a.fun1();
}
}
-------------------------------------------------
Output:
Wine 的Fun.....
JNC 的Fun2...
从程序的运行结果中咱们发现，a.fun1()首先是运行父类Wine中的fun1().而后再运行子类JNC中的fun2()。
分析：在这个程序中子类JNC重载了父类Wine的方法fun1()，重写fun2()，并且重载后的fun1(String a)与 fun1()不是同一个方法，因为父类中没有该方法，向上转型后会丢失该方法，因此执行JNC的Wine类型引用是不能引用fun1(String a)方法。而子类JNC重写了fun2() ，那么指向JNC的Wine引用会调用JNC中fun2()方法。
因此对于多态咱们能够总结以下：
指向子类的父类引用因为向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，一定是使用子类中定义的这些方法（动态链接、动态调用）。
对于面向对象而已，多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不一样来区分不一样的函数，经过编辑以后会变成两个不一样的函数，在运行时谈不上多态。而运行时多态是动态的，它是经过动态绑定来实现的，也就是咱们所说的多态性。
多态的实现
2.1实现条件
在刚刚开始就提到了继承在为多态的实现作了准备。子类Child继承父类Father，咱们能够编写一个指向子类的父类类型引用，该引用既能够处理父类Father对象，也能够处理子类Child对象，当相同的消息发送给子类或者父类对象时，该对象就会根据本身所属的引用而执行不一样的行为，这就是多态。即多态性就是相同的消息使得不一样的类作出不一样的响应。
Java实现多态有三个必要条件：继承、重写、向上转型。
继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行从新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中须要将子类的引用赋给父类对象，只有这样该引用才可以具有技能调用父类的方法和子类的方法。
只有知足了上述三个条件，咱们才可以在同一个继承结构中使用统一的逻辑实现代码处理不一样的对象，从而达到执行不一样的行为。
对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，可是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。
2.2实现形式
在Java中有两种形式能够实现多态。继承和接口。
2.2.一、基于继承实现的多态
基于继承的实现机制主要表如今父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写能够表现出不一样的行为。
public class Wine {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Wine(){
}
public String drink(){
return "喝的是 " + getName();
}
/**
* 重写toString()
*/
public String toString(){
return null;
}
}
public class JNC extends Wine{
public JNC(){
setName("JNC");
}
/**
* 重写父类方法，实现多态
*/
public String drink(){
return "喝的是 " + getName();
}
/**
* 重写toString()
*/
public String toString(){
return "Wine : " + getName();
}
}
public class JGJ extends Wine{
public JGJ(){
setName("JGJ");
}
/**
* 重写父类方法，实现多态
*/
public String drink(){
return "喝的是 " + getName();
}
/**
* 重写toString()
*/
public String toString(){
return "Wine : " + getName();
}
}
public class Test {
public static void main(String[] args) {
//定义父类数组
Wine[] wines = new Wine[2];
//定义两个子类
JNC jnc = new JNC();
JGJ jgj = new JGJ();
//父类引用子类对象
wines[0] = jnc;
wines[1] = jgj;
for(int i = 0 ; i < 2 ; i++){
System.out.println(wines[i].toString() + "--" + wines[i].drink());
}
System.out.println("-------------------------------");
}
}
OUTPUT:
Wine : JNC--喝的是 JNC
Wine : JGJ--喝的是 JGJ
-------------------------------
在上面的代码中JNC、JGJ继承Wine，而且重写了drink()、toString()方法，程序运行结果是调用子类中方法，输出JNC、JGJ的名称，这就是多态的表现。不一样的对象能够执行相同的行为，可是他们都须要经过本身的实现方式来执行，这就要得益于向上转型了。
咱们都知道全部的类都继承自超类Object，toString()方法也是Object中方法，当咱们这样写时：
Object o = new JGJ(); System.out.println(o.toString());
输出的结果是Wine : JGJ。
Object、Wine、JGJ三者继承链关系是：JGJ—>Wine—>Object。因此咱们能够这样说：当子类重写父类的方法被调用时，只有对象继承链中的最末端的方法才会被调用。可是注意若是这样写：
Object o = new Wine(); System.out.println(o.toString());
输出的结果应该是Null，由于JGJ并不存在于该对象继承链中。
因此基于继承实现的多态能够总结以下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的全部子类，子类对象的不一样，对方法的实现也就不一样，执行相同动做产生的行为也就不一样。
若是父类是抽象类，那么子类必需要实现父类中全部的抽象方法，这样该父类全部的子类必定存在统一的对外接口，但其内部的具体实现能够各异。这样咱们就可使用顶层类提供的统一接口来处理该层次的方法。
2.2.二、基于接口实现的多态
继承是经过重写父类的同一方法的几个不一样子类来体现的，那么就可就是经过实现接口并覆盖接口中同一方法的几不一样的类体现的。
在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。
继承都是单继承，只能为一组相关的类提供一致的服务接口。可是接口能够是多继承多实现，它可以利用一组相关或者不相关的接口进行组合与扩充，可以对外提供一致的服务接口。因此它相对于继承来讲有更好的灵活性。
3、经典实例。
经过上面的讲述，能够说是对多态有了必定的了解。如今趁热打铁，看一个实例。该实例是有关多态的经典例子，摘自：http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx。
public class A {
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return ("A and A");
}
}
public class B extends A{
public String show(B obj){
return ("B and B");
}
public String show(A obj){
return ("B and A");
}
}
public class C extends B{
}
public class D extends B{
}
public class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("1--" + a1.show(b));
System.out.println("2--" + a1.show(c));
System.out.println("3--" + a1.show(d));
System.out.println("4--" + a2.show(b));
System.out.println("5--" + a2.show(c));
System.out.println("6--" + a2.show(d));
System.out.println("7--" + b.show(b));
System.out.println("8--" + b.show(c));
System.out.println("9--" + b.show(d));
}
}
运行结果：
1--A and A 2--A and A 3--A and D 4--B and A 5--B and A 6--A and D 7--B and B 8--B and B 9--A and D
在这里看结果一、二、3还好理解，从4开始就开始糊涂了，对于4来讲为何输出不是“B and B”呢？
首先咱们先看一句话：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，可是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这句话对多态进行了一个归纳。其实在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
分析：
从上面的程序中咱们能够看出A、B、C、D存在以下关系。
首先咱们分析5，a2.show(c)，a2是A类型的引用变量，因此this就表明了A，a2.show(c),它在A类中找发现没有找到，因而到A的超类中找(super)，因为A没有超类（Object除外），因此跳到第三级，也就是this.show((super)O)，C的超类有B、A，因此(super)O为B、A，this一样是A，这里在A中找到了show(A obj)，同时因为a2是B类的一个引用且B类重写了show(A obj)，所以最终会调用子类B类的show(A obj)方法，结果也就是B and A。
按照一样的方法我也能够确认其余的答案。
方法已经找到了可是咱们这里仍是存在一点疑问，咱们仍是来看这句话：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，可是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这咱们用一个例子来讲明这句话所表明的含义：a2.show(b)；
这里a2是引用变量，为A类型，它引用的是B对象，所以按照上面那句话的意思是说有B来决定调用谁的方法,因此a2.show(b)应该要调用B中的show(B obj)，产生的结果应该是“B and B”，可是为何会与前面的运行结果产生差别呢？这里咱们忽略了后面那句话“可是这儿被调用的方法必须是在超类中定义过的”，那么show(B obj)在A类中存在吗？根本就不存在！因此这句话在这里不适用？那么难道是这句话错误了？非也！其实这句话还隐含这这句话：它仍然要按照继承链中调用方法的优先级来确认。因此它才会在A类中找到show(A obj)，同时因为B重写了该方法因此才会调用B类中的方法，不然就会调用A类中的方法。
因此多态机制遵循的原则归纳为：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，可是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，可是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
参考资料：http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx。
百度文库：http://wenku.baidu.com/view/73f66f92daef5ef7ba0d3c03.html
在这里面向对象的三大特性已经介绍完成，下一步继续是java基础部分—巩固基础，提升技术，不惧困难，攀登高峰！！！！！！
更多：
java提升篇-----理解java的三大特性之继承
- 1. java提升篇（三）-----理解java的三大特性之多态
- 2. java提升篇(四)-----理解java的三大特性之多态
- 3. java提升篇(二)-----理解java的三大特性之继承
- 4. java提高篇（二）-----理解java的三大特性之继承
- 5. java提高篇（二）—–理解java的三大特性之继承
- 6. Java面试题，Java三大特性之一——多态的理解
- 7. java -----理解java的三大特性之多态
- 8. java的三大特性之----多态
- 9. Java三大特性之多态
- 10. 理解Java的三大特性之多态
- 更多相关文章...
- • C# 多态性 - C#教程
- • SQLite - Java - SQLite教程
- • JDK13 GA发布：5大特性解读
- • Java Agent入门实战（三）-JVM Attach原理与使用
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Window下Ribbit MQ安装
- 2. Linux下Redis安装及集群搭建
- 3. shiny搭建网站填坑战略
- 4. Mysql8.0.22安装与配置详细教程
- 5. Hadoop安装及配置
- 6. Python爬虫初学笔记
- 7. 部署LVS-Keepalived高可用集群
- 8. keepalived+mysql高可用集群
- 9. jenkins 公钥配置
- 10. HA实用详解