多态是继封装、继承之后，面向对象的第三大特性。现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。 Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值，又可以给这个子类(实现类对象)的父类(接口)变量赋值。如Student类可以为Person类的子类。那么一个Student对象既可以赋值给一个Student类型的引用，也可以赋值给一个Person类型的引用。最终多态体现为父类引用变量可以指向子类对象。 多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。 文字再怎么讲，都不够生动，直接用代码来体现 老爸要喝酒，那今天喝什么酒呢，
public class Wine { public void drinkWine(){ System.out.println("===今天我要喝什么酒呢===="); Wine(); } public void Wine(){ System.out.println("===看看俺今天能喝啥子哟===="); }} public class JNC extends Wine { /** * @desc 子类重载父类方法 * 父类中不存在该方法，向上转型后，父类是不能引用该方法的 * @param a * @return void */ public void drinkWine(String a){ System.out.println("======今天我要喝剑南春===="); Wine(); } /** * 子类重写父类方法 * 指向子类的父类引用调用Wine时，必定是调用该方法 */ public void Wine(){ System.out.println("=====剑南春喝上啦，好开森====="); }} public class Test { public static void main(String[] args) { Wine a = new JNC(); a.drinkWine(); a.Wine(); Wine b = new Wine(); b.drinkWine(); b.Wine(); JNC c= new JNC(); c.drinkWine("qq"); }}
先来看看这一段，
Wine a = new JNC(); a.drinkWine(); a.Wine();
子类剑南春中的drinkWine带有参数，而父类中的drinkWine不带有参数，即父类不存在这个方法
运行的时候，调用的是父类的drinkWine，先输出了
===今天我要喝什么酒呢====
之后继续调用Wine方法，这个时候是去了子类中，指向子类的父类引用调用Wine时，必定是调用子类中的方法，于是输出了
=====剑南春喝上啦，好开森=====
上面的Wine和JNC中的方法，都没有带Static，如果加上Static呢，看一下代码和运行的结果
class Wine { public static void drinkWine() { System.out.println("===今天我要喝什么酒呢===="); Wine(); } public static void Wine() { System.out.println("===看看俺今天能喝啥子哟===="); }}class JNC extends Wine { public static void drinkWine(String a) { System.out.println("======今天我要喝剑南春===="); Wine(); } public static void Wine() { System.out.println("=====剑南春喝上啦，好开森====="); }}class Test { public static void main(String[] args) { Wine a = new JNC(); a.drinkWine(); a.Wine(); }} 可以看到，静态方法，即使向上转型，也只能调用自己的方法啦
上面比较的是子类和父类的方法，在非静态方法和静态方法，父类引用子类的方法，非静态方法下可以调用子类同名的构造函数方法，不能调用不一样的构造方法
静态方法中，子类向上转型后，父类引用都不能进行调用子类的方法
下面来给父类和子类一些变量，以及一些方法，方法都是非静态的
父类，定义了一些姓名，年龄，兴趣爱好等的变量
和一些say和hobby的方法
public class Father { private String fathername; private int fatherage; private String fahterhobby; public void say() { System.out.println("==我是你爸爸真伟大,养你这么大=="); myhobby(); } public void myhobby() { System.out.println("==我是你爸爸真伟大，只要你妈妈=="); } public Father() { super(); } public Father(String fathername, int fatherage, String fahterhobby) { this.fathername = fathername; this.fatherage = fatherage; this.fahterhobby = fahterhobby; }//省略getters and setters @Override public String toString() { return "Father{" + "fathername='" + fathername + '\'' + ", fatherage=" + fatherage + ", fahterhobby='" + fahterhobby + '\'' + '}'; } public String toString(String fathername, int fatherage, String fahterhobby) { return "Father{" + "fathername='" + fathername + '\'' + ", fatherage=" + fatherage + ", fahterhobby='" + fahterhobby + '\'' + '}'; }} 子类和父类差不多，其实不应该定义一样的变量，虽然名称改了一下
public class Son extends Father { public void say(){ System.out.println("==爸爸我要出去玩==="); } public void say(String s){ System.out.println("==爸爸我要出去玩===" +s); } public void myhobby(String aaa){ System.out.println("==爸爸给我买这个玩具： " + aaa); } private String sonname; private int sonage; private String sonhobby; public Son(String sonname, int sonage, String sonhobby) { this.sonname = sonname; this.sonage = sonage; this.sonhobby = sonhobby; } public Son(String fathername, int fatherage, String fahterhobby, String sonname, int sonage, String sonhobby) { super(fathername, fatherage, fahterhobby); this.sonname = sonname; this.sonage = sonage; this.sonhobby = sonhobby; } //省略getters and setters @Override public String toString(String sonname, int sonage, String sonhobby) { return "Son{" + "sonname='" + sonname + '\'' + ", sonage=" + sonage + ", sonhobby='" + sonhobby + '\'' + '}'; }} 测试：
主要测试如下：
子类中，对say()无参数的方法进行了改写，输出内容不一致了，且有自己新创建的say（String s）带有入参的方法
子类对myhobby也新增了，有了入参
子类中对toString方法也带有入参的
实例化子类对象，父类引用，即向上转型了，调用say(),这个方法子类中有； 调用myhobby(), 子类中没有myhobby(), 只有myhobby(String aaa) 然后还要调用toString()， 有参数和无参数的
public class test { public static void main(String[] args) { Father father = new Son("张三",35,"LOL","张四",5,"Learn"); System.out.println("实例化一个Son对象，用父亲接收"); father.say(); father.myhobby(); //代码报错 // father.myhobby("LOL惊奇娃娃"); System.out.println(father.toString()); System.out.println(father.toString("张三",35,"LOL")); System.out.println("\n"); Son son = new Son("张四",5,"Learn"); System.out.println("实例化一个Son对象，用Son接收"); son.say(); son.say("上海迪士尼"); son.myhobby(); son.myhobby("LOL惊奇娃娃"); System.out.println(son.toString("张四",5,"Learn")); }} 运行结果如下：
1. 父类引用调用say()， 由于子类中有这个方法，调用的是子类的这个方法；
调用myhobby();， 由于子类中没有这个方法，调用的是父类的这个方法；
调用子类中带有参数的方法，father.myhobby("LOL惊奇娃娃");代码直接报错了
调用toString()，分别是无参数和有参数，因为子类中只有三个有参数的，没有无参数的，就无参数返回的是父类的，有参数返回的是子类的
2. 子类引用指向子类对象，调用say()无参数的和有参数的，由于子类中都有，都是子类自己的方法进行返回
调用myobby()无参数的和有参数的，由于子类中没有无参数的，就去爸爸那儿找了找，返回了爸爸的爱好，子类中有带参数的，就返回了子类自己的
调用toString(3个参数略),就返回了自己的方法，如果调用不带参数的toString(),就是返回一个父亲中的方法了。。。
总结： 父类引用指向子类，调用返回的时候，看看自己家有没有啊，有啊，哦，不管了，先去儿子家找找，儿子有啊，儿子用你家的，儿子没有啊，回家用自己的方法吧
子类引用指向子类，调用返回的时候，先去自己(即儿子)方法中看看，我自己没有呀，去父亲方法中看看吧
上面看的继承中的父子关系是，爸爸有，儿子有，儿子有新的
下面继续看继承，论父子之间的关系之，爸爸没有，儿子有；
员工对象，只有一个mailCheck()方法，定义了一些变量
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); } @Override public String toString() { return "Employee{" + "name='" + name + '\'' + ", address='" + address + '\'' + ", number=" + number + '}'; } //省略getters and setters Salary对象继承了父类
public class Salary extends Employee{ private double yearsalary; // 全年工资 public double getSalary() { return yearsalary; } public void setSalary(double salary) { if(salary >= 0.0) this.yearsalary = salary; } public double computePay() { System.out.println("计算工资，付给：" + getName()); return yearsalary/12; } public Salary(String name, String address, int number, double yearsalary) { super(name, address, number); setSalary(yearsalary); } public void mailCheck() { System.out.println("Salary 类的 mailCheck 方法 "); System.out.println("邮寄支票给：" + getName()+ " ，工资为：" + yearsalary); }} 测试如下
public class Demo { public static void main(String [] args) { Salary s = new Salary("员工 A", "北京", 3, 360000.00); s.mailCheck(); double sa = s.computePay(); System.out.println(sa); System.out.println("\n"); Employee e = new Salary("员工 B", "上海", 2, 240000.00); e.mailCheck(); double salary = ((Salary) e).computePay(); System.out.println(salary); }} 
必要要强转 ((Salary) e).computePay(); 即必须向下转型，父亲引用转化为子类的，再去调用子类的方法
即回答：论父子之间的关系之，爸爸没有，儿子有；
本来是爸爸类型的引用，将爸爸类型的引用向下转型，然后调用
问题来啦，我是父亲，我有两个儿子或者多个儿子呢，闹啥啊， 爸爸没有这个方法，儿子们都有呢，咋办咧
public class Animal { void eat() { System.out.println("Animal"); }}public class Cat extends Animal { public void eat() { System.out.println("===我是猫咪我要吃鱼"); } public void work() { System.out.println("===我是猫咪我负责抓老鼠"); }}public class Dog extends Animal { public void eat() { System.out.println("====我是小狗我要吃骨头"); } public void work() { System.out.println("====我是小狗我负责看家"); }} public class Test { public static void main(String[] args) { show(new Cat()); // 以 Cat 对象调用 show 方法 System.out.println("\n"); show(new Dog()); // 以 Dog 对象调用 show 方法 System.out.println("\n"); Animal a = new Cat(); // 向上转型 a.eat(); // 调用的是 Cat 的 eat Cat c = (Cat)a; // 向下转型 c.work(); // 调用的是 Cat 的 work } public static void show(Animal animal) { animal.eat(); // 类型判断 if (animal instanceof Cat) { // 猫做的事情 Cat c = (Cat)animal; c.work(); } else if (animal instanceof Dog) { // 狗做的事情 Dog c = (Dog)animal; c.work(); } }} 
不如咱直接将动物类改成抽象类吧，
public abstract class Animal { abstract void eat() ;}public class Cat extends Animal { public void eat() { System.out.println("===我是猫咪我要吃鱼"); } public void work() { System.out.println("===我是猫咪我负责抓老鼠"); }}public class Dog extends Animal { public void eat() { System.out.println("====我是小狗我要吃骨头"); } public void work() { System.out.println("====我是小狗我负责看家"); }}
欢迎继续关注下一篇，在接口实现中的实现多态