感谢大家的支持,你们的支持就是我的动力，如果对您有所帮助，请转发并收藏，谢谢！

Java的多态性

面向对象编程有三个特征，即封装、继承和多态。

封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。

继承是为了重用父类代码，同时为实现多态性作准备。那么什么是多态呢？

方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。

要理解多态性，首先要知道什么是“向上转型”、“向下转型”。

对象的多态性：父子类对象的转换

向上转型：子类对象变为父类对象，语法： 父类 父类对象 = 子类实例， 自动；

向下转型：父类对象变为子类对象，语法： 子类 子类对象 = （子类）父类实例，强制。

演示代码（对象向上转型）：

class A{

public void print(){

System.out.println("A,public void print(){}");

}

}

class B extends A{ //继承A类

public void print(){ //方法覆写

System.out.println("B,public void print(){}");

}

}

public class TestDemo{

public static void main(String args[]){

A a = new B(); //向上转型

a.print(); //调用被覆写过的方法

}

}

执行结果：

B,public void print(){}

本程序实现了一个对象的向上转型操作，虽然最后调用print（）方法的是A类对象，但是由于此时实例化的是子类对象“new B（）；”，而且print（）方法被子类覆写了，所以最终调用的就是被B类覆写过的print（）方法。

演示代码（对象向下转型）：

class A{

public void print(){

System.out.println("A,public void print(){}");

}

}

class B extends A{//继承A类

public void print(){//方法覆写

System.out.println("B,public void print(){}");

}

}

public class TestDemo{

public static void main(String args[]){

A a = new B();//向上转型

B b = (B)a;//向下转型

b.print();//调用被覆写过的方法

}

}

执行结果：

B,public void print(){}

本程序强制将父类对象变为了子类实例，由于本程序在开始实例化的依然是子类对象（new B（）；），所以最终调用的print（）方法依然是被子类覆写过的方法。

演示代码（观察错误代码）：

class A{

public void print(){

System.out.println("A,public void print(){}");

}

}

class B extends A{//继承A类

public void print(){//方法覆写

System.out.println("B,public void print(){}");

}

}

public class TestDemo{

public static void main(String args[]){

A a = new A();//没有转型

B b = (B)a;//向下转型错误：java.lang.ClassCastException: A cannot be cast to B

b.print();

}

}

执行结果：

Exception in thread "main" java.lang.ClassCastException: A cannot be cast to B

at TestDemo.main(TestDemo.java:14)

以上的程序在编译时没有发生任何的错误信息，但是在执行时出现了“ClassCastException”错误提示，表示的是类转换异常，即两个没有关系的类互相发生了对象的强制转换，所以可以得出结论：当对象发生向下转型关系前，一定要首先发生对象的向上转型关系。

结论：

1.定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。

2.父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；

3.父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；

4.对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。

演示代码（多态的使用）：

class Father{

public void wait1(){

wait2();

}

//这是父类中的wait2()方法，因为下面的子类中重写了该方法

//所以在父类类型的引用中调用时，这个方法将不再有效

//取而代之的是将调用子类中重写的wait2()方法

public void wait2(){

System.out.println("Father wait2");

}

}

class Child extends Father{

//wait1(String name)是对wait1()方法的一个重载

//由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用

//所以在下面的main方法中child.wait1("沐兮沐楚")是不对的

public void wait1(String name){

System.out.println("Child name:" + name);

}

//func2()重写了父类Father中的func2()方法

//如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法

public void wait2(){

System.out.println("Child wait2");

}

}

public class TestDemo{

public static void main(String[] args) {

Father child = new Child();

//child.wait1("沐兮沐楚"); //错误

child.wait2();

}

}

执行结果：

Child wait2

上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的wait1()方法，重写了父类的wait2()方法。重载后的wait1(String name)和wait1()不再是同一个方法，由于父类中没有wait1(String name)，那么，父类类型的引用child就不能调用wait1(String name)方法。而子类重写了wait2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的wait2()。

对于多态，可以总结它为：

一、使用父类类型的引用指向子类的对象；

二、该引用只能调用父类中定义的方法和变量；

三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。

感谢大家的支持,你们的支持就是我的动力，如果对您有所帮助，请转发并收藏，谢谢！