一、多态是什么

  多态在面向对象中的定义：指为不同数据类型的实体提供统一的接口。
  比如有动物（Animal）之类别（Class），而且由动物继承出类别鸡（Chicken）和类别狗（Dog），并对同一源自类别动物（父类）之一消息有不同的响应，如类别动物有“叫()”之动作，而类别鸡会“啼叫()”，类别狗则会“吠叫()”，则称之为多态。

二、多态的类型

  多态分为静态多态和动态多态。

• 静态多态：在编译期间实现多态，相同的方法传递不同的参数，实现不同的效果。

  C++代码实现：

// print()函数
void print(const char* str,int width);
void print(double i ,int width);
void print(const char* str);
// 使用print()函数时，编译器将根据所采取的用法使用有相应特征标的原型
print("abc",12);
print(2.2,55);
print("def");

• 动态多态：在运行期间实现多态，一个类的引用可以被赋值为不同的子类对象。

   实现动态多态的必要条件：

• 编程语言要支持继承
• 子类可以重写（override）父类中的方法
• 父类引用可以指向子类对象

  C#代码实现：

public class AnimalFactory{
	public static Animal createAnimal(string type){
		Animal animla=null;
		switch(type){
			case "cat":
				animal=new Cat();
				break;
			case "bird":
				animal=new Bird();
				break;
			case "dog":
				animal=new Dog(); 
				break;
		}
	}
}

三、多态解决什么问题

1. 应用程序不必为每一个子类编写功能调用，只需要对父类进行处理即可。大大提高程序的可复用性。
2. 子类的功能可以被父类的方法或引用变量所调用，就像Animal类，可以提高可扩充性和可维护性。

1.多态的含义

什么是多态，就是一个事物有多种形态，比如说是老师是老师，他也是人，也是丈夫或者妻子，或者光棍儿，这就阐述了多种形态。

2.实现多态的三个前提条件

2.1.继承/实现  2.2.方法重写  2.3.向上转型。

3.多态的作用（即为好处）

提高了了程序的扩展性（在举例种具体体现在一个对象（Person类）中调用usingCar方法，不需要对每一个子类Car对象进行创建对象，即就算子类多几种Car类型，只用在测试类中和再创建一个子类即可。）。

4.多态的缺点

虽然提高了程序的扩展性，但是不能使用子类的特有功能。就只能进行向下转型进行访问子类特有方法。

5.多态的访问特点

成员方法：编译看左边，执行看右边。（即为编译的时候先看父类中是否有这个成员方法，运行时运行的是子类中的方法）。

成员变量：编译看左边，执行看左边。（即为编译的时候先看父类中是否有这个成员变量，运行时运行的是父类中的成员变量。

下面是案例；

1.先创建一个抽象父类AbstractCar（因为抽象类中有抽象方法，会必须要求子类重写抽象方法）

public abstract class AbstractCar {
	/**
	 * 定义一个抽象方法
	 */
	public abstract void run(); //抽象方法，如果子类要继承，就要对抽象方法进行重写

}

2.创建2个子类（BMWCar和ChanganCar）去继承父类。

public class BMWCar extends AbstractCar{
	public String name = "宝马"; //这里创建一个成员变量是为了验证访问成员变量的特点
    // 无参构造方法
	public BMWCar() {
		// TODO Auto-generated constructor stub
	}
	
    //成员变量的getXxx/setXxx方法
	public String getName() {
		return name;
	}

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

	/**
	 * 要继承抽象类父类，就必须重写抽象类中父类的所有抽象方法
	 */
	public void run() {
		System.out.println("宝马车跑起来了。");
		
	}
    
    //子类独有的方法（普通方法）
	public void expensivePrice() {
		System.out.println("宝马车贵的一批");
		
	}
}

2.1子类ChanganCar类

public class ChanganCar extends AbstractCar{
	/**
	 * 要继承抽象类，就必须重写抽象类父类中的所有抽象方法
	 */
	@Override 
	public void run() {
		System.out.println("长安汽车跑起来了。");
		
	}
    // 子类特有方法（普通方法）
	public void character() {
		System.out.println("长安汽车性能一流，广告费结算一下。");		
	}
}

3.定义一个Person类对AbstractCar子类进行操作

下面代码中有个地方应该有很多看不明白，按照正常情况是按照我注释了的那种方式进行创建方法，但是这样会有一个问题，就是汽车品牌这么多，每一种品牌都需要单独的创建usingCar方法，这样会导致代码可读性差，而且代码冗余。所以利用多态的方式进行创建（将来如果有新的Car类只需要继承AbstractCar类，直接在测试类中创建对象就好了，就不需要再Person类中再次创建usingCar方法了。（不知道你们理解没？），反正子类要继承AbstractCar类，直接用多态进行接收就可以了，调用方法的时候还是会执行子类重写后的方法。

public class Person {
	/**
	 * 定义一个方法 来输出car.run方法
	 * 返回值类型：void
	 * 参数 AbstractCar car
	 */
	
	/*public void usingCar(BMWCar car) {
		//AbstractCar car = new BMWCar();实例化对象
		car.run();
		//成员方法.编译看左边（有没有run方法），执行看右边。
	}
	public void usingCar(ChanganCar car) {
		//AbstractCar car = new BMWCar();实例化对象
		car.run();
		//成员方法.编译看左边（有没有run方法），执行看右边。
	}*/
	
	// 如果使用多态的方式创建，就会简化创建子类对象代码
	public void usingCar(AbstractCar car) {
		//AbstractCar car = new BMWCar();实例化对象
		car.run();
		//成员方法.编译看左边（有没有run方法），执行看右边。
	}	
}

4.测试类

public class AbstractTest {
	public static void main(String[] args) {
		
		/**
		 * 创建一个person对象来调用自己的usingCar方法
		 * usingCar方法中的参数为AbstractCar（抽象汽车）类
		 */
		Person p = new Person();
		AbstractCar bmwCar = new BMWCar();//使用多态的方式创建对象（实例化对象）
		//上面多态的方式创建对象 是将new BMWCar()赋值给AbstractCar类用对象名bmwCar接收
		//System.out.println(bmwCar.name);// 
        //访问成员方法 编译执行都看左边 （父类中没有name这个成员变量，即使有的话，会执行父类中的成员变量）
		
		p.usingCar(bmwCar);
		
		/**
		 * 如果需要调用子类中的特有方法，应该怎么办？
		 * 这个时候就需要强制转换（向下转型）；
		 * 强制转换（向下转型）语法：
		 * 数据类型 变量 = （数据类型）值/变量；
		 * 在向下转型前，必须进行类型判断，需要判断当前父类变量中装的是哪一个子类类型对象。
		 * if(父类变量名 instanceof 子类类型1){
		 *强制转换格式：
		 *子类类型1 子类变量 = （子类类型1）父类变量;
		 *现在就可以调用子类的特有方法
		 * }else if(父类变量 instanceof 子类类型1){
		 * .....}
		 * 
		 */
		// 要想获取子类的成员方法和成员变量需要向下转型才能进行调用
        //方式一
		if (bmwCar instanceof BMWCar) {
			BMWCar bmw = (BMWCar)bmwCar;
			bmw.stop();
		}else if (bmwCar instanceof ChanganCar) {
			ChanganCar changan = (ChanganCar)bmwCar;
			changan.character();
		}

        //方式二
        // getClass（）方法返回字节码文件判断是否是VipZiuser1类型的对象
        if (bmwCar.getClass（） == BMWCar.class) {
			BMWCar bmw = (BMWCar)bmwCar;
			bmw.stop();
		}else if (bmwCar.getClass（） == ChanganCar.class) {
			ChanganCar changan = (ChanganCar)bmwCar;
			changan.character();
		}			
	}
}

可以细心的进行分析;