所谓多态，顾名思义，就是多种形式多种状态。多态可以说是面向对象编程的精髓所在。因此理解多态的含义对理解面向对象编程有特别重要的意义。Java之所以引入多态的概念，原因之一是它在类的继承问题上与C++不同，C++允许多继承，这确实给它带来了非常强大的功能，但是多继承必然会引起程序错综复杂，难于阅读理解。为了规避这种风险，java采取了单继承的方法，虽然这样使继承关系简单明了，但是同时也限制了其功能的实现。为了弥补这点不足，java引入了多态性的概念。
多态有两种理解方式，第一种是对像的不同方法可以用相同的一个方法名，即重载。另一种是同一对象根据不同的消息执行相应的行为，也就是，发送一个消息给某一个对象，让对象自行选择哪种行为。由此可以将多态分为静态多态和动态多态
静态多态指的是程序在编译时，系统就能决定调用哪个方法，所以也成为编译时多态。在java中实现静态多态的实现方式是方法重载。
动态多态指在运行中系统才能动态确定方法所指的对象，所以也称为运行时多态。动态多态的实现方式是重写父类中的同名成员方法。动态多态主要是通过动态绑定和重写的机制来实现的。
//定义一个shape类
public class Shape {
public void draw(){
System.out.println("画一个图形");
}
}
//定义一个多边形子类，继承Shape类
public class Rectangle extends Shape{
private int width;
private int height;
//with访问修改方法
public int getWidth() {
return width;
}
public void setWidth(int width) {
if(width>=1&&width<=15){
this.width = width;
}
}
//height访问修改方法
public int getHeight() {
return height;
}
public void setHeight(int height) {
if(height>=1&&height<=15){
this.height = height;
}
}
//重写父类draw方法
public void draw(){
System.out.println("*******
* *
*******");
}
}
//定义一个多边形子类，继承Shape类
public class Rectangle extends Shape{
private int width;
private int height;
//with访问修改方法
public int getWidth() {
return width;
}
public void setWidth(int width) {
if(width>=1&&width<=15){
this.width = width;
}
}
//height访问修改方法
public int getHeight() {
return height;
}
public void setHeight(int height) {
if(height>=1&&height<=15){
this.height = height;
}
}
//重写父类draw方法
public void draw(){
System.out.println("*******
* *
*******");
}
}
//定义一个Aritst类，将Shape类型的变量传给此类
public class Artist{
public void drawShape(Shape shape){
shape.draw();
}
}
//写一个main方法
public class ArtistDemo {
public static void main(String[] args){
//建个Shape类对象
Shape shape=new Shape();
//建个Rectangle类对象
Rectangle rectangle=new Rectangle();
//建个RightTriangle对象
RightTriangle rt=new RightTriangle();
//建个Artist对象
Artist artist=new Artist();
artist.drawShape(shape);
artist.drawShape(rectangle);
artist.drawShape(rt);
}
}
上面程序输出的结果是：
画一个图形
*******
* *
*******
*
***
*****
*******
由此可见动态多态在运行中系统才能动态确定方法所指的对象，传递不同的对象，只要在子类中有重写该方法就会执行子类的方法，没有重写时才会调用父类的方法。
此外java类还有抽象这个特点，抽象用关键字abstract修饰。经过abstract修饰过的类称为抽象类，抽象类只可以用来继承，不可以用来产生对象。进过abstract修饰的方法称为抽象方法，一个类一旦有了抽象方法，那么这个类也要变成抽象类。在继承了一个有抽象方法的抽象类时，这个子类必须重写重新类中的抽象方法。这样就要求合理设计类与类之间的继承关系并且规范了子类。
//定义一个静态类
public abstract class Mammal {
public void breathe(){
System.out.println("Mammal is breathing");
}
//定义一个静态方法
public abstract void nurse();
}
//定义一个鲸类，继承Mammal类
public class Whale extends Mammal{
public void breathe(){
System.out.println("Whale is breathing");
super.breathe();
}
//重写nurse静态方法
public void nurse(){
System.out.println("Whale is nursing");
}
}
//定义一个Cat类
public class Cat extends Mammal{
public void breathe(){
System.out.println("Cat");
}
//这里没有重写nurse静态方法，编译就要报错
public void nurse(int t){
System.out.println("cat nurse");
}
}
public class TestMain {
//定义一个main方法
public static void main(String[] args){
Mammal w=new Whale();
w.breathe();
w.nurse();
Mammal m=w;
m.breathe();
m.nurse();
System.out.println(m instanceof Whale);
System.out.println(w instanceof Mammal);
System.out.println(m instanceof Cat);
}
}