面向对象---多态

一、多态的基本概念

1、多态的概念

    多态是指在同一时刻体现出不同的状态，如水的状态有气态、液态和固态。

2、多态的前提

    1）必须要有继承关系

    2）必须要有方法重写

    3）父类引用必须指向子类对象（向上转型）

            eg. Animal a = new Cat（）；（Animal为父类，Cat为子类）

            通过父类对象的创建是通过子类在堆内存新建了了一个对象,由于子类又继承了父类,父类的初始化是通过子类新建对象进行的。

3、多态中成员访问的特点

    成员变量：编译看左，运行看左

    成员方法（非静态）：编译看左，运行看右（存在方法重写）

    构造方法：无论是父类还是子类，都是对对象的初始化

    成员方法（静态）：编译看左，运行看左（静态方法和类有关，不存在方法重写）

下面我们通过一个具体的代码来体会一下多态成员的访问特点：

class Fu{
	int num = 20 ;
	public void show() {
		System.out.println("show Fu....");
	}
	public Fu(){
		
	}
	
	public static void function() {
		System.out.println("function Fu...");
	}
}
//子类
class Zi extends Fu{
	int num = 30 ;
	
	public void show() {
		System.out.println("show Zi....");
	}
	
	public static void function() {
		System.out.println("function Zi...");
	}
	
	public void method() {
		System.out.println("------");
	}
}

//测试类
public class DuoTaiDemo {

	public static void main(String[] args) {
		//创建对象,通过子类创建对象
		Fu f = new Zi() ;
		
		System.out.println(f.num);
		f.show();
//		f.method() ;
		f.function();
	}
}

程序运行结果：

20

show Zi....

function Fu...

可以看出，通过多态Fu f = new Zi（）；调用成员变量num值时调用的是父类的num值（编译看左，运行看左），调用的show方法（非静态）是子类重写后的方法（编译看左，运行看右，因为存在方法重写），此时调用子类的method方法则会报错，因为父类中没有method方法，调用function方法（静态方法），输出的是父类的method方法（编译看左，运行看左，因为静态方法和类有关，不存在方法重写）

4、多态的优缺点

优点：提高代码的复用性（由继承保证）

缺点：提高代码的扩展性（由多态保证）

改进之前：

//动物类
class Animal{
	public void eat() {
		System.out.println("eat");
	}
	public void sleep() {
		System.out.println("sleep");
	}
}
//猫类
class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃鱼...");
	}
	public void sleep() {
		System.out.println("猫趴着睡觉...");
	}
}

//狗类
class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃骨头...");
	}
	public void sleep() {
		System.out.println("狗卧着睡觉...");
	}
}
//测试类
public class DuoTaiDemo2 {
	
	public static void main(String[] args) {
		
		Cat c = new Cat() ;
		c.eat();
		c.sleep();
		System.out.println("-------------");
		
		Cat c2 = new Cat() ;
		c2.eat();
		c2.sleep();
		System.out.println("-------------");
		
		Cat c3 = new Cat() ;
		c3.eat();
		c3.sleep();
		
		Dog d = new Dog() ;
		d.eat();
		d.sleep();
	}
}

可以看出，如果没有多态，我们的代码将会非常臃肿，而且要进行很多重复性的工作，因此对代码进行改进，将动物的eat（）和sleep（）方法封装进一个AnimalTool（）的工具，该工具既可以接收Cat类的对象也可以接受Dog类的对象，这样我们在调用eat和sleep方法时无论该对象是什么类型的数据都可以接收。

改进之后：

//动物类
class Animal{
	public void eat() {
		System.out.println("eat");
	}
	public void sleep() {
		System.out.println("sleep");
	}
}
//猫类
class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃鱼...");
	}
	public void sleep() {
		System.out.println("猫趴着睡觉...");
	}
}

//狗类
class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃骨头...");
	}
	public void sleep() {
		System.out.println("狗卧着睡觉...");
	}
}

//可以定义一个动物的工具类AnimalTool
class AnimalTool{
	
	private AnimalTool() {} 
	
	public static void useAnimal(Animal a) { 
		a.eat();
		a.sleep();
	}
}
//测试类
public class DuoTaiDemo2 {
	
	public static void main(String[] args) {
		
		Cat c = new Cat() ;
		Cat c2 = new Cat() ;
		Cat c3 = new Cat() ;
		Dog d = new Dog() ;

		AnimalTool.useAnimal(c);
		AnimalTool.useAnimal(c2);
		AnimalTool.useAnimal(c3);
		AnimalTool.useAnimal(d);
	}
}

    虽然多态的优点十分明显 ，但它也是有弊端的：通过父类的引用调用子类特有功能,不能调用....（如上面讲过的例子，在调用子类的method方法时会报错，因为父类中没有method方法），那么该怎么解决这个问题呢？

    上面我们讲过了向上转型：Animal a = new Cat（）；这里又引出了向下转型的概念：将父类的引用强制转换子类的引用，如：Animal a = new Cat（）（向上转型）；Cat b = （Cat）a；（向下转型），向下转型的前提是必须有父类的引用，将父类的引用强制转换子类的引用  ,但向下转型如果使用不当,会出现一个运行时期异常:ClassCastException。