多态的总结

多态：对象拥有多种形态

同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。

封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态除了代码的复用性外，还可以解决项目中紧偶合的问题,提高程序的可扩展性.。（松耦合）

---

多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。

---

1、引用的多态
父类的引用可以指向本类的对象
父类的引用可以指向子类的对象
2、方法的多态
创建本类对象时，调用的方法为本类方法
创建子类对象时，调用的方法为子类重写的方法或者继承的方法

Animal父类代码

public class Animal {
	public void eat() {
		System.out.println("动物需要吃东西");
	}
}

子类Dog代码，重写了父类方法，并有独有的方法watchDoor

public class Dog extends Animal {
	@Override
	//重写父类的eat方法
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void watchDoor() {
		System.out.println("狗可以看门");
	}
}

子类Cat，默认继承父类的方法

public class Cat extends Animal {

}

测试类

public class Test {

	public static void main(String[] args) {

		Animal animal1=new Animal();
		Animal animal2=new Dog();//向上类型自动转换
		Animal animal3=new Cat();
		//Dog dog=new Animal();
		animal1.eat();
		animal2.eat();
		//animal2.watchDoor();
		animal3.eat();
		
		Dog dog=new Dog();
		Animal animal4=dog;//自动将dog转换为Animal
		if(animal4 instanceof Dog) {
		Dog dog2=(Dog) animal4;//向上需要强制转换
		}else {
			System.out.println("无法强制转换为Dog");
		}
		if(animal4 instanceof Dog) {
			Cat cat=(Cat) animal4;//向上需要强制转换
			}else {
				System.out.println("无法强制转换为Cat");
			}
	}
}

结果：

总结：父类引用可以指向本类对象，也可指向子类对象。（方法的多态）
当子类没有重写父类的方法时，对象调用的是子类继承来的方法。父类无法调用子类独有的方法。

多态带来的好处

耦合性太强，不便于后期修改，换辆车需要更改全部代码

public class JD{
public void run(){
       System.out.println("JD在以120迈的速度在run");
}
}
我们还会抽象出一个类,来代表人.其中有个drive()方法,需要一个汽车类型作为参数,我们先传入一个JD类型的参数

// 这是我们的核心业务类
public class Person{
public void drive(JD jd){
       jd.run();
}

public static void main(String args[]){
   Person p =new Person();
   JD jd = new JD();
   p.drive(jd);
}
}

修改之后

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

public Benz extends Driver{
   public void run(){
System.out.println("Benz在以200迈的速度在run");
   }
}
public JD extends Driver{
   public void run(){
System.out.println("JD is running...");
   }
}

public 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;
}


public static void main(String args[]){
   Person p =new Person();
   JD jd = new JD();//刚开始没钱就买辆JD吧
   p.setDriver(jd);
   p.driver();
   Benz benz = new Benz{();//有钱换车了
   p.setDriver(benz);
   p.driver();
}
}

/**
*   我们将多态使用在方法的返回类型中
*   Car可以是抽象类,也可以是接口,JD和Benz分别继承该类或实现该借口
*/
public class CarFactory{
public Car factory(String carName){
   if(carName.equals("JD")){
      return new JD();
   }else if(carName.equals("Benz")){
      return new Benz();
   }else{
      System.out.println("对比起,不伺候");
      return null;
   }
}
}
这实际上就是设计模式中的简单工厂模式!