谈到面向对象的编程语言时不可避免的就会介绍继承，子类可以继承父类除private外的成员变量和方法，并且可以添加自己的成员变量与方法，以实现自己独特的功能。

但是如果在实际的开发中发现某个类的方法可以做出某些改进，但由于工程已经交付给用户使用，就不想增加不必要的麻烦！但以后再次创建该类的对象时就需要改进过来。

同时又不影响程序其他部分对该方法的调用。也就是说，如果再次创建该类的对象是不能做出改进的，应该由该类产生一个子类，并且子类将重写需要改进的方法，由于程

序中其他地方需要调用该方法，所以对象的类型如果被创建成子类的类型的话将不能被有效调用，这就需要用到向上转换了即创建一个子类对象但是将其类型转换为父类的

类型。这样做之后，程序的其他地方调用它时就能正确调用了，而且相应的方法也得到了改进。

由上可知：多态的存在有3个条件，1)要有继承 2)要有重写3)父类引用指向子类对象

个人理解：
打个比方有一个类A，在类B中得到引用，在类C中也得到引用

class A {
	public void go(){
		System.out.println("我要打篮球")
	}
}
class B {
	public  void UseA(A a){
		a.go()
	}
}
class C {
	public void UseA(A a){
		a.go()
	}
}

现在我想改一下A类中的go方法，但是根据七大设计原则，直接对A修改会违反开闭原则，所以我们最好写一个子类去继承A

class AChild extends A {
	@override
	public void go(){
		System.out.println("我要打乒乓球")
	}
} 

假如没有多态，那我们想用A的子类AChild，那就必须在B和C中把引用类型修改成AChild，也就是说要把B、C类里面的UseA类修改，那就违背了开闭原则。所以有了多态以后，我们只要创建一个需要修改的类的子类，以其父类作为引用类型，子类作为引用对象，就可以在修改想要修改的方法的同时又不影响其他类对该类的引用。

不知道我这样理解对不对，还请大佬们指出。

JAVA多态

战神三考：Why、What、How
1、为何用多态？
2、多态是什么？
3、多态怎么用？

1、为什么要用多态

	1)提高了代码的维护性 (通过继承和实现来保证)
	2)提高了代码的扩展性 (通过多态来保证)
	3)降低代码耦合度 

2、多态基本概念

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

	2.多态的理解：
	现实事物经常会体现出多种形态，比如老虎，是一种猫科动物，蛇是一种冷血动物，
	但老虎和蛇都是属于动物，也分别属于自己动物类别，当然猫科动物属类中还有很
	多种，即动物在这里表现出了多种形态。                                                                                                            

	Java作为面向对象的语言，同样可以描述一个事物的多种形态。
	如Snake类继承了Animal类，一个Snake的对象便既是Snake，又是Animal。

	3.多态体现为父类引用变量可以指向具体的子类对象。

	4.前提条件：必须有父子继承关系或者实现关系。

	注意：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

	5.多态的定义与使用格式

	定义格式：父类类型 变量名 = new 子类类型();

	6.理解:

	多态是同一个行为具有多个不同表现形式或形态的能力。

	多态就是同一个接口，使用不同的实例而执行不同操作。

3、多态怎么用

3.1、多态中的成员特点

// 上代码
public class Animal {
    public String name = "animal";

	@Override
    public void eat(){
        System.out.println("动物吃东西！");
    }
}

public class Tiger extends Animal {
    public String name = "tiger";

    @Override
    public void eat() {
        System.out.println("虎吃鸡！");
    }
    
    public void run() {
		System.out.println("虎奔跑！");
	}
}

public class Snake extends Animal {
    public String name = "snake";
    
    @Override
    public void eat() {
        System.out.println("蛇吞象！");
    }

	public void run() {
		System.out.println("蛇爬行！");
	}
}

	1.多态成员变量：编译检查的时候检查Animal类中是否有此变量定义
		Animal tiger = new Tiger(); 

		System.out.println("name = " + tiger.name); // name 是Animal中的值，编译期只能取到父中的值
	上述打印输出结果为： name = Animal

	2.使用多态调用成员方法：编译时检查左边类型，运行时实际调用右边对象

    	Animal snake = new Snake();

    	System.out.println(sanke.eat()); // snake 的门面类型是 Animal,
    	
    但实际类型是Snake, 所以运行时调用的是Snake中重写后的方法。打印输出结果为： 蛇吞象！

3.2、多态的转型和instanceof关键字

	多态的转型分为向上转型和向下转型两种
	向上转型：多态本身就是向上转型过的过程
    使用格式：父类类型 变量名=new 子类类型();

    适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。
	
	Amimal tiger = new Tiger();
	
	tiger.run(); // 这样写会报错，因为编译检查tiger是Animal类型，Animal中没有run方法。
	
	((Snake)tiger).run(); // 此时编译检查能通过，但是运行时会报错,因为tiger实际类型是Tiger类型，
	此时强制类型转换成Snake，编译时检测tiger是Animal类型，Snake也是Animal的子类，所以
	编译时无法发现老虎不能转化为蛇类型。

	if (tiger instanceof Tiger) {
		((Tiger) tiger).run() // 此时经过instanceof判断后才能进行强制类型转换，编译和运行时均能通过。
	}

	作用：用来判断某个对象是否属于某种数据类型。

3.3、多态案例

// 上代码
public class Keeper {
    public void feed(Animal animal){
        animal.eat();
    }
}

public class Test {
    public static void main(String[] args) {
        Keeper GodXiu = new Keeper();

        Animal snake = new Snake();

        Animal tiger = new Tiger();
        GodXiu.feed(snake);
        GodXiu.feed(tiger);
    }
}

上述案例中输出打印结果：
蛇吞象！
虎吃鸡！

4、个人思考总结

	目前在日常开发中经常使用多态的地方就是使用集合的时候：

		List list = new ArrayList();
        Map map = new HashMap();

	今天的个人理解和分享就到这了，后续有新的感悟会继续补充更新！

什么是多态？

概念：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。简单的说:就是用基类的引用指向子类的对象。

为什么要用多态呢？

原因：我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态除了代码的复用性外，还可以解决项目中紧偶合的问题,提高程序的可扩展性.。耦合度讲的是模块模块之间，代码代码之间的关联度，通过对系统的分析把他分解成一个一个子模块，子模块提供稳定的接口，达到降低系统耦合度的的目的，模块模块之间尽量使用模块接口访问，而不是随意引用其他模块的成员变量。

多态有什么好处？

有两个好处：

1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承 
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用，

多态在什么地方用？

可以用在方法的参数中和方法的返回类型中。

在方法中的参数，请看下面的例子：

public abstract class Driver
    {
        public void run();//让子类来运行
    }


class SBenz : Driver
    {
        public void run()
        {
            Console.WriteLine("Benz在以200迈的速度在run");
        }
    }




 class JD : Driver
    {
        public void run()
        {
            Console.WriteLine("JD is running...");
        }
    }


 class Person
    {
        private Driver driver;
        public Person()
        {

        }
        public Person(Driver driver)
        {
            this.driver = driver;
        }
        public void drive()
        {
            driver.run();
        }
        public void setDriver(Driver driver)
        {//运用参数多态,以后不管买什么车都可以
            this.driver = driver;
        }
   }




static void Main(string[] args)
        {
            Person p = new Person();
            JD jd = new JD();//刚开始没钱就买辆JD吧
            p.setDriver(jd);
            p.drive();
            SBenz benz = new SBenz();//有钱换车了
            p.setDriver(benz);
            p.drive();
        }

在方法的返回类型中，请看下面的例子：

上面的例子中,不管是JD还是Benz都是我们自己直接new出来的.我们可以设计一个工厂类,专门生成汽车

/**
*   我们将多态使用在方法的返回类型中
*   Driver可以是抽象类,也可以是接口,JD和Benz分别继承该类或实现该借口

*/

public class CarFactory
    {
        public Driver factory(String carName)
        {
            if (carName.Equals("JD"))
            {
                return new JD();
            }

            else if (carName.Equals("Benz"))
            {
                return new SBenz();
            }

            else
            {
                Console.WriteLine("对比起,不伺候");
                return null;
            }
        }
    }

这实际上就是设计模式中的简单工厂模式!

类型的参数.,传入参数的时候,可以传入任何一个类的对象，只要是对应的类的对象名称就可以了
这就是多态的应用!