多态的实现

多态

向上转型要比向下转型重要的多
向上转型
把子类对象赋给父类的引用

//向上转型:向上转型安全
		//把子类对象赋予父类的引用
		Animal animal = new Dog();
             Animal animal2 = dog;

向上转型以后，父类的引用可以调用的方法是由父类引用保存的对象决定，调用的方法就是子类从父类中继承的方法或子类重写的父类的方法

//创建一个狗类的对象 调用了无参数的构造函数
		Dog dog = new Dog();		
		System.out.println("dog引用掉方法");
		dog.eat();       //从父类中继承的方法
		dog.yaoren();    //子类自己扩展的方法
		dog.showInfo();  //子类重写父类的方法 
		//向上转型:向上转型安全
		//把子类对象赋予父类的引用
		Animal animal = new Dog();
		animal.eat();    //子类继承父类的方法
		animal.showInfo();  //子类重写父类的方法

同一个父类的引用变量，因为保存的对象不同，导致在调用同一个方法的时候结果也是不一样的

Animal animal2=null;
		animal2 = new Animal(); 
		animal2.eat();   //父类定义方法
		animal2.showInfo();   //父类中定义的方法
		animal2 = new Dog();
		animal2.eat();   //Dog子类继承父类的方法
		animal2.showInfo();  //Dog子类重写父类的方法
		animal2 = new Cat();
		animal2.eat();    //Cat子类继承父类的方法
		animal2.showInfo();   //Cat子类重写父类的方法
		System.out.println("程序结束");

向下转型(不安全，容易产生类型转换异常)
把父类引用 赋予子类引用

//把父类的引用强转子类的引用，向下转型不安全，取决于父类引用中保存的对象类型
		//正确能够向下转型     原因:animal 引用中 保存的就是 dog对象
		Animal animal = new Dog(); 
		Dog dog = (Dog)animal;
		System.out.println("dog:" + dog); 
		//向下转型过程中出异常， 原因: animal 引用中保存的是animal对象
		animal = new Animal();
		Dog dog1 = (Dog)animal;
		System.out.println("dog1:" + dog1);
		//向下转型过程中出现异常  原因:animal引用中保存的是cat对象
		animal = new Cat();
		Dog dog2 = (Dog)animal;
		System.out.println("dog2:" + dog2);

多态的实现
多态的概念:同一个父类引用，因为保存了不同的子类对象，在调用同样的方法的时候（子类重写后的方法）,获取了不同的结果 这个就是多态
多态的实现：
1：必须要有继承 2：子类必须要重写父类的方法
3：向上转型 4:使用父类引用调用子类重写的方法
1必须有父类

public class Animal { 
	private String name;  
	public void eat(){
		System.out.println("动物都会吃");
	} 
	public void showInfo(){
		System.out.println("动物名称:" + name  ); 
	} 
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}  
}

2：有多个子类

3 向上转型(不同子类对象赋予同一个父类引用)

4. 调用同样的方法(animal2.showInfo()) 获取了不同的结果