JavaSE基础五（多态）

1.多态

1.1 多态概述

同一个对象，在不同时刻表现出来的不同形态

举例：狗

我们可以说狗是狗： 狗 dog = new 狗();

我们也可以说狗是动物： 动物 dog = new 动物();

这里狗在不同时刻表现出来的不同形态，这就是多态

多态的前提和体现

• 有继承/实现关系
• 有方法重写
• 有父类引用指向子类的对象

public class Animal {
	public void eat(){
	}
}
--------------------
    public class Dog extends Animal {//这边继承
	@Override//方法重写
	public void eat() {
		System.out.println("狗追人");
	}
}
-----------------------
    public class AnimalDemo {
	public static void main(String[] args) {
		//父类引用指向子类的对象
		Animal a = new Dog();//以多态的形式创建了一个对象
	}
}

1.2 多态中成员访问特点

• 成员变量 ：编译看左边，执行看左边
• 成员方法：编译看左边，执行看右边

为什么成员方法和成员变量的访问不一样呢?

• 因为成员方法有重写，而成员变量没有

 public class Animal {
	public int age = 40;//成员变量

	public void eat(){//成员方法
		System.out.println("动物吃东西！");
	}
}
---------------------
public class Dog extends Animal {
	public int age = 20;
	public String name = "大黄";
	@Override
	public void eat() {//重写了父类中的方法
		System.out.println("狗啃骨头！");
	}
	public void playGame(){
		System.out.println("逮狗腿");
	}
}
------------------------
public class AnimalDemo {
	public static void main(String[] args) {
		//父类引用指向子类的对象
		Animal a = new Dog();//以多态的形式创建了对象
		System.out.println(a.age);
		//System.out.println(a.name);报错编译看左边Animal中没有name成员变量
		//执行结果  是 40  说明编译看左边，执行看左边
		a.eat();
		//a.playGame();报错，因为方法编译看左边
		//运行结果是  狗啃骨头
	}
}

1.3 多态的好处和弊端

• 多态的好处：提高了程序的拓展性

  ​ 具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

• 多态的弊端：不能使用子类特有的功能

------父类
public class Animal {
	public void eat(){
		System.out.println("动物吃东西！");
	}
}
----------
public class Cat extends Animal {
	//重写父类的方法
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
--------------------
public class Dog extends Animal {
	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}
	//子类特有的方法
	public void lookDoor(){
		System.out.println("狗看门");
	}
}
--------------------------
/*
		动物操作类
 */
public class AnimalOperator {
	public void useAnimal(Animal a){
	a.eat();
	//a.lookDoor();  报错，不能访问具体的子类特有的功能
	}
}
-----------------
public class AnimalDemo {
	public static void main(String[] args) {
		//创建动物操纵类的对象，调用方法
		AnimalOperator ao = new AnimalOperator();
		Cat cat = new Cat();
		ao.useAnimal(cat);
		
		Dog dog = new Dog();
		ao.useAnimal(dog);
	}
}    

1.4多态中的转型

• 向上转型

    从子到父
  

  ​ 父类引用指向子类对象

• 向下转型

  ​ 从父到子

  ​ 父类引用转为子类对象

------父类动物类
public class Animal {
	public void eat(){
		System.out.println("这是一个动物类");
	}
}
-----------子类猫 继承父
public class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	//子类特有方法
	public void playGame(){
		System.out.println("猫玩捉迷藏");
	}
}
-----------测试类
/*
	向上转型：
			从子到父
			父类引用指向子类对象
	向下转向：
			从父到子
			父类引用转为子类对象
 */    
public class AnimalDemo {
	public static void main(String[] args) {
		//多态
		Animal a = new Cat();//向上转型
		a.eat();
		//a.playGame();
		/*//	创建Cat对象
		Cat cat = new Cat();
		cat.eat();
		cat.playGame();*/
		//向下转型
		Cat c = (Cat)a;//这里a是父类引用，强转(Cat)为子类对象Cat c
		c.eat();
		c.playGame();
	}
}