多态是继封装、继承之后，面向对象的第三大特性。

现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。

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"));
    }
}

运行结果如下：

父类引用调用say()，由于子类中有这个方法，调用的是子类的这个方法；
调用myhobby();，由于子类中没有这个方法，调用的是父类的这个方法；
调用子类中带有参数的方法，father.myhobby(“LOL惊奇娃娃”);代码直接报错了
调用toString()，分别是无参数和有参数，因为子类中只有三个有参数的，没有无参数的，就无参数返回的是父类的，有参数返回的是子类的
子类引用指向子类对象，调用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("====我是小狗我负责看家");
	}
}

读者福利

分享免费学习资料

针对于Java程序员，我这边准备免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）

为什么某些人会一直比你优秀，是因为他本身就很优秀还一直在持续努力变得更优秀，而你是不是还在满足于现状内心在窃喜！希望读到这的您能点个小赞和关注下我，以后还会更新技术干货，谢谢您的支持！

资料领取方式：加入Java技术交流群963944895，点击加入群聊，私信管理员即可免费领取

如何成为一个有逼格的Java架构师

怎么提高代码质量？——来自阿里P8架构师的研发经验总结

阿里P8分享Java架构师的学习路线，第六点尤为重要

每个Java开发者应该知道的八个工具

想面试Java架构师？这些最基本的东西你都会了吗？

画个图来找你的核心竞争力，变中年危机为加油站

哪有什么中年危机，不过是把定目标当成了有计划

被裁员不是寒冬重点，重点是怎么破解职业瓶颈

详解Java三大特性——多态

测试：

读者福利

猜你喜欢