java面向对象的三大特性——多态

多态

　　所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

　　Java实现多态有三个必要条件：继承、重写、向上转型。

　　继承：在多态中必须存在有继承关系的子类和父类。

　　重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

　　向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。 只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

　　对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

　　子类覆盖父类的方法遵循的是“两同两小一大”原则。两同指的是方法名和形参列表相同。两小指的是子类方法的返回值类型要小于或等于父类被覆盖方法的返回值，子类方法声明抛出的异常应比父类方法抛出的异常要小或相等。一大指的是子类方法的访问权限应该比父类方法要大或相等。尤其要注意的是，覆盖方法和被覆盖方法都要是实例方法，不能一个是类方法，一个是实例方法，否则回报编译错误，类方法是静态绑定的，没有多态性。

　　备注：类方法（static）可以被子类继承，但是不能被子类重写（覆盖），方法相同时子类会将父类的该方法隐藏。

　　覆写原则   http://blog.csdn.net/zhangjk1993/article/details/24066085

多态的实现

　　1. 基于继承实现的多态

　　基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

　　2. 基于接口实现的多态

　　在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

class Animal{
    public void show(){
          System.out.println("Animal");
    }
}
//继承实现
class Lion extends Animal{
    public void show(){
          System.out.println("lion");
    }
}
//接口定义的方法默认是 public
//接口内也可以定义成员变量（多数情况不怎么用）
interface Ifly{
    //int num=12; 
    //默认是 public final static int num = 12
    void fly();
}
//接口实现
class Bird implements Ifly{

    @Override
    public void fly() {
        System.out.println("fly");
    }
}
public class Polymorphic {
    public static void main(String[] args) {
        Animal a = new Lion();
        a.show()//lion
        Ifly f = new Bird();
        f.fly();//fly
    }
}

多态的好处

　　1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。

　　2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

　　3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。

　　4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。

　　5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

观察代码

class Base{
    public String name="Base";
    public void info(){
        System.out.println("Base info --> "+this.name);
    }
    public void show(){
        System.out.println("Base show --> " +this.name);
    }
    public Base(){
        System.out.println("Base 构造方法 this =" + this);
        this.info();
        this.show();
        System.out.println("this.name --> "+this.name);
    }
}
class Derived extends Base{
    public String name="Derived";
　　//覆写的方法
    public void info(){
        System.out.println("Derived info --> "+this.name);
    }
    public Derived(){
        System.out.println("Derived 构造方法 this =" + this);
    }
}
public class Main{
    public static void main(String[] args) {
        new Derived();
    }
}
/*
 输出结果：
Base 构造方法 this =Derived@7fbe847c
Derived info --> null
Base show --> Base
this.name --> Base
Derived 构造方法 this =Derived@7fbe847c
 */

通过代码输出结果得出：

　　1、程序在创建一个类的对象时，先进行父类的对象创建（最大的父类Object），调用构造函数之前，内存已经分配完毕，调用构造器是进行属性初始化。

　　2、this 指向当前对象

　　3、java 类的属性没有多态性，而方法具有多态性，这是因为java程序中属性是静态绑定，方法是动态绑定

结论与代码结合分析

　　结论：当变量的编译时类型和运行时类型不同时，通过该变量访问它引用的对象的实例变量时，该实例变量的值由声明该变量的类型决定。但通过该变量调用它引用的对象的实例方法时，该方法行为将由它实际所引用的对象来决定。

"为了好解释，所以把属性及方法都 public ,对于其它的情况一般都是修饰符的作用产生的。"
class B{
    public String name="B"; 
    public String age="age";
    public void method(){
        System.out.println(this.name);
    }    
}
class Base extends B{    
    public String name="base";    
    public void show(){
        System.out.println(this.name);
    }    
}
class Derived extends Base{
    public String name = "derived";    
    @Override //重写父类的方法，编译器会验证是否符合规则
    public void show(){
        System.out.println(this.name);
    }    
    @Override
    public void method(){
        System.out.println(this.name);
    }
    public void derivedMethod(){
        System.out.println("derivedMethod");
    }   
}
public class TestExtend{  
    public static void main(String[] args) {     
        Base base = new Derived();   
        //base.derivedMethod();//此处报错，父类没有该方法        
        base.method();//输出 derived         
        base.show();//输出 derived         
        System.out.println(base.name);//输出 base       
        System.out.println(base.age);//输出 age  （B 的属性）  
    }
}

　　分析：

　　此时，编译时类型（Base）和运行时类型（Derived）。base 只可以调用 Base 类中的方法及属性和 Base 的父类 B 类 、祖宗 Object 类的方法及属性，而 base.derivedMethod() 方法只是存在 Base 的子类 Dervied 中，因此找不到而报错；对于 base.method() 方法虽然 Base 类中没有定义，但是 Base 类从它的父类 B 中继承了 method() 方法，又因为在 Base 的子类 Dervied 中对该方法进行了覆写，所以输出的结果是 " derived ” 。

      对于直接调用属性 base .name 由于子类与父类的相同属性不存在父类属性被覆写，所以 base 先从类 Base 中进行匹配，而 Base 类存在 name 属性因此直接输出 "base"；调用 base .age 因为 Base 类没有 age 属性，所以向父类进行查找在父类 B 中存在这个公共属性，输出 "age" 。

　　个人结论：

 　　1、子类继承超类所有的方法及属性，只是由于访问权限的作用而产生不同的情况。

　　2、子类与超类的属性相同时，不会造成覆写；而子类的方法名和参数类型与超类相同时，子类的方法就会对超类的该方法进行覆盖（一定要按照子类覆写父类方法原则）。—— java 的多态特性

　　3、超类的类型定义引用变量而实际的引用对象是子类，该引用变量根据引用类型进行调用引用类型的方法及属性，由于属性与方法对于继承的处理不同，相同方法可以被子类覆写，相同变量就不会，这就造成了 java 的多态特性。