近期在重新复习Java相关的基础知识，其中大学课程中对Java多态的理解是抽象的，不是Java那个抽象，结合Java菜鸟课程的内容，说下Java多态的理解：

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：



多态性是对象多种表现形式的体现。

现实中，比如我们按下 F1 键这个动作：

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
	
如果当前在 Word 下弹出的就是 Word 帮助；
	
在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。

多态的优点

1. 消除类型之间的耦合关系
	
2. 可替换性
	
3. 可扩充性
	
4. 接口性
	
5. 灵活性
	
6. 简化性
多态存在的三个必要条件

继承
	
重写
	
父类引用指向子类对象：Parent p = new Child();


class Shape {
    void draw() {}
}
 
class Circle extends Shape {
    void draw() {
        System.out.println("Circle.draw()");
    }
}
 
class Square extends Shape {
    void draw() {
        System.out.println("Square.draw()");
    }
}
 
class Triangle extends Shape {
    void draw() {
        System.out.println("Triangle.draw()");
    }
}

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

以下是一个多态实例的演示，详细说明请看注释：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

执行以上程序，输出结果为：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

虚函数

虚函数的存在是为了多态。

Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

重写

我们将介绍在 Java 中，当设计类时，被重写的方法的行为怎样影响多态性。

我们已经讨论了方法的重写，也就是子类能够重写父类的方法。

当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。

要想调用父类中被重写的方法，则必须使用关键字 super。

/* 文件名 : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number) {
      System.out.println("Employee 构造函数");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public void mailCheck() {
      System.out.println("邮寄支票给： " + this.name
       + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
   public String getName() {
      return name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String newAddress) {
      address = newAddress;
   }
   public int getNumber() {
     return number;
   }
}

假设下面的类继承Employee类：

/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; // 全年工资
   public Salary(String name, String address, int number, double salary) {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck() {
       System.out.println("Salary 类的 mailCheck 方法 ");
       System.out.println("邮寄支票给：" + getName()
       + " ，工资为：" + salary);
   }
   public double getSalary() {
       return salary;
   }
   public void setSalary(double newSalary) {
       if(newSalary >= 0.0) {
          salary = newSalary;
       }
   }
   public double computePay() {
      System.out.println("计算工资，付给：" + getName());
      return salary/52;
   }
}

现在我们仔细阅读下面的代码，尝试给出它的输出结果：

/* 文件名 : VirtualDemo.java */
public class VirtualDemo {
   public static void main(String [] args) {
      Salary s = new Salary("员工 A", "北京", 3, 3600.00);
      Employee e = new Salary("员工 B", "上海", 2, 2400.00);
      System.out.println("使用 Salary 的引用调用 mailCheck -- ");
      s.mailCheck();
      System.out.println("\n使用 Employee 的引用调用 mailCheck--");
      e.mailCheck();
    }
}

以上实例编译运行结果如下：

Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck -- 
Salary 类的 mailCheck 方法 
邮寄支票给：员工 A ，工资为：3600.0

使用 Employee 的引用调用 mailCheck--
Salary 类的 mailCheck 方法 
邮寄支票给：员工 B ，工资为：2400.0

例子解析


	
实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。
	
	

	
当调用 s.mailCheck() 时，编译器在编译时会在 Salary 类中找到 mailCheck()，执行过程 JVM 就调用 Salary 类的 mailCheck()。
	
	

	
e 是 Employee 的引用，但引用 e 最终运行的是 Salary 类的 mailCheck() 方法。
	
	

	
在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。
	
以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。

Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。

多态的实现方式

方式一：重写：

这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。

 

方式二：接口


	
1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
	
	

	
2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。
	
方式三：抽象类和抽象方法

因为编译时候无法确定目标执行的方法，所以叫做运行时多态
方法区里面就是填充的就是所有实例的方法，jvm调用目标方法的时候就是在方法区里面调用，是通过invoke指令来调用的。


java多态

如果放在生活中多态就是比如做一件事情，不同人有不同的实现方式。
但是在java这里指的多态，它设定了限制，必须是多个子类继承同一个父类实现方法的重写。
同时创建的对象的时候new出来的子类同时指定父类引用。（这样就造成了生成的对象只能调用和父类共有的方法，不能调用子类特有的方法）。

多态是同一个行为具有多个不同表现形式或形态的能力。
**Animal am = new Cat();**语句在堆内存中开辟了子类(Cat)的对象，并把栈内存中的父类(Animal)的引用指向了这个Cat对象。
执行强转语句Cat ct = (Cat)am;之后，ct(栈里面声明的Cat类型的变量)就指向最开始在堆内存中创建的那个Cat类型的对象了。
多态存在的三个必要条件

继承
重写
父类引用指向子类对象

Parent p = new Child();

成员变量

编译看左边(父类),运行看左边(父类)

成员方法

编译看左边(父类)，运行看右边(子类)。动态绑定

静态方法

编译看左边(父类)，运行看左边(父类)。
(静态和类相关，算不上重写，所以，访问还是左边的)

只有非静态的成员方法,编译看左边,运行看右边

多态的弊端:多态后不能使用子类特有的属性和方法。
如果我们非要想用也是可以的
那我们就可以把这个父类引用指向了子类对象的家伙am再强制变回Cat类型。

package com.lky.h1;

class Animal {
    int num = 10;
    static int age = 20;
    public void eat() {
        System.out.println("动物吃饭");
    }

    public static void sleep() {
        System.out.println("动物在睡觉");
    }

    public void run(){
        System.out.println("动物在奔跑");
    }
}
class Cat extends Animal {
    int num = 80;
    static int age = 90;
    String name = "tomCat";
    public void eat() {
        System.out.println("猫吃饭");
    }
    public static void sleep() {
        System.out.println("猫在睡觉");
    }
    public void catchMouse() {
        System.out.println("猫在抓老鼠");
    }

}


public class Test3 {
    public static void main(String[] args) {
        Animal am = new Cat();
        am.eat();
        am.sleep();
        am.run();
        //am.catchMouse();这里先注释掉，等会会说明
        //System.out.println(am.name);//这里先注释，待会说明
        System.out.println(am.num);
        System.out.println(am.age);
    }
}


参考文章
对于向上转型，程序会自动完成，而对于向下转型时，必须明确的指明要转型的子类类型。
向上转型，new 了一个子类可以指向父类
向下转型，把指向父类的转成子类

我这里的向下转型指的是把向上转型返回的对象指向强转成子类，我可以没有说new了一个父类指向子类，现实中不行，java也是不行的。

package com.lky.h1;

class Father{
    private String name="我是你爸爸";
    private String age="45";
    public void eat(){
        System.out.println("爸爸喜欢吃鱼");
    }
    public void drink(){
        System.out.println("爸爸喜欢和茅台");
    }
    public static void symbol(){
        System.out.println("爸爸是三眼皮");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

public class Son extends Father {
    private String name="我是你儿子";
    private String age="18";
    public void eat(){
        System.out.println("儿子喜欢吃白菜");
    }
    public void drink(){
        System.out.println("儿子喜欢喝热的");
    }
    public static void symbol(){
        System.out.println("儿子是单眼皮");
    }
    public static void main(String[] args) {
        Father father = new Son();
        father.eat();
        father.symbol();
        System.out.println(father.getName());
    }


}



多态就是在非静态的成员方法上体现的。

Java中多态是其重要的特性之一，其可使得程序有良好的可扩展性
实现多态的三个要求

要有继承
要有重写
父类引用指向子类对象


class Person {
    public void eat(){
        System.out.println("人要吃饭");
    };
}

class Student extends Person {
    @Override
    public void eat(){
        System.out.println("学生要吃饭");
    };
}

class Teacher extends Person {
    @Override
    public void eat(){
        System.out.println("老师要吃饭");
    };
}

class HelloWrold {
    private Person person;
    void eat(Person person){
        person.eat();
    }
    public static void main(String[] args) {
        HelloWrold helloWrold = new HelloWrold();
        Teacher teacher = new Teacher();
        Student student = new Student();
        helloWrold.eat(teacher);
        helloWrold.eat(student);
    }
}


运行结果：

	

什么是多态
面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)。
实现多态的技术称为：动态绑定(dynamic binding)，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
多态的作用：消除类型之间的耦合关系。
现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。
多态存在的三个必要条件 1、要有继承；2、要有重写；3、父类引用指向子类对象。
上菜
public class A {    public String show(D obj) {              //方法一        return ("A and D");    }    public String show(A obj) {              //方法二        return ("A and A");    }    static class B extends A {        public String show(B obj) {              //方法三            return ("B and B");        }        public String show(A obj) {              //方法四            return ("B and A");        }    }    static class C extends B {    }    static class D extends B {    }    public static void main(String[] args) {        A a2 = new B();        A a1 = new A();        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));        // 创建了B对象 类型是A ，调用超类函数，子类重写了 调用子类的        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));                System.out.println("10--" + d.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
10--A and D
让我们分析一下，理清其中各个类的继承关系
那我们开始分析输出A a1 = new A();这是普通的创建对象，故a1拥有调用方法一和方法二的能力。那么究竟调用哪个方法呢，这里面涉及方法的重载。其实，在编译的时候，编译器已经进行了前期绑定，即把show()；方法与类中的方法主体2进行绑定。就是说，在编译时，系统就已经知道应该调用哪个方法，即使你有方法的重载。
故 a1.show(b)会与方法二绑定；a1.show(c)会与方法二绑定；a1.show(d)会与方法一绑定。且都在编译时完成绑定。
但A a2 = new B();就涉及了多态 了，B实现了向上转型。创建了一个父类引用，指向子类对象。这样的做法很常见，因为这样不仅增加了灵活性(父类引用可以随时指向任意子类对象)，也提高了扩展性。但要知道的是，向上转型的缺点，就是不能调用子类中有而父类没有的方法。
故A a2 = new B();中，方法四对方法二进行了重写，所以a2拥有调用方法一和方法四的能力，而方法三不能调用(由上一段可知)。所以，在编译时， a2.show(b)会与方法四绑定；a2.show(c)会与方法四绑定；a2.show(d)会与方法一绑定。
B b = new B();这是普通的创建子类对象，B继承于A，且方法四重写了方法二，所以b拥有调用方法一，方法三，方法四的能力。所以b.show(b)会与方法三绑定，b.show(c)会与方法三绑定，b.show(d)会与方法一绑定。
对于多态，可以总结它为：
一、使用父类类型的引用指向子类的对象；
二、该引用只能调用父类中定义的方法和变量；
三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；(动态连接、动态调用)
四、变量不能被重写(覆盖)，”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。
多态还可以用来做类型约束，编译器就可以确定对象类型，避免类型转换异常