多态
1.多态
1.1 多态概述
同一个对象，在不同时刻表现出来的不同形态
举例：猫
我们可以说猫是猫：猫 cat=new 猫();
我们也可以说猫是动物：动物 animal=new 猫();
这里猫在不同的时刻表现出来了不同的形态，这就是多态
多态的前提和体现：
- 有继承/实现关系
- 有方法重写
- 有父类引用指向子类对象
package com.szy008;
public class Animal {
public void eat(){
System.out.println("动物吃东西");
}
}
package com.szy008;
public class Cat extends Animal{
@Override
public void eat() {
super.eat();
System.out.println("猫吃鱼");
}
}
package com.szy008;
public class AnimalDemo {
public static void main(String[] args) {
//有父类引用指向子类对象
Animal a=new Cat();//多态
a.eat();
}
}
1.2多态中成员变量访问特点
- 成员变量：编译看左边，执行看左边
- 成员方法：编译看左边，执行看右边
为什么成员变量和成员方法的访问不一样呢？
- 因为成员方法有重写，而成员变量没有
package com.szy009;
public class Animal {
public int age=40;
public void eat(){
System.out.println("动物吃东西");
}
}
package com.szy009;
public class Cat extends Animal{
public int age=20;
public int weight=10;
@Override
public void eat() {
super.eat();
System.out.println("猫吃鱼");
}
public void playGame(){
System.out.println("猫捉迷藏");
}
}
package com.szy009;
public class AnimalDemos {
public static void main(String[] args) {
//有父类引用指向子类对象
Animal a=new Cat();
System.out.println(a.age);//结果为40，执行结果看左边
//System.out.println(a.weight);//报错，因为访问成员变量时，编译看左边
a.eat();//输出的是重写后的方法，访问成员方法时，执行结果看右边
//a.playGame();报错，因为方法也编译时看左边
}
}
1.3多态的好处和弊端
-
多态的好处：提高了程序的扩展性
具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
-
多态的弊端：不能使用子类的特有功能
package com.szy010;
/*
动物类
*/
public class Animal2 {
public void eat(){
System.out.println("动物吃东西");
}
}
package com.szy010;
/*
猫类
*/
public class Cat2 extends Animal2{
@Override
public void eat() {
super.eat();
System.out.println("猫吃鱼");
}
}
package com.szy010;
/*
狗类
*/
public class Dog2 extends Animal2{
@Override
public void eat() {
System.out.println("狗啃骨头");
}
public void lookDoor(){
System.out.println("狗看门");
}
}
package com.szy010;
/* 猪类
*/
public class Pig2 extends Animal2{
@Override
public void eat() {
System.out.println("猪啃白菜");
}
}
package com.szy010;
/*
动物操作类
*/
public class AnimalOperator {
/*
public void useAnimal(Cat2 c){
c.eat();
}
public void useAnimal(Dog2 d){
d.eat();
}
public void useAnimal(Pig2 p){
p.eat();
}
*/
public void useAnimal(Animal2 a){
a.eat();
// a.lookDoor();//报错，多态不能访问具体的子类所特有的功能
}
}
package com.szy010;
/*测试类
*/
public class AnimalDemo2 {
public static void main(String[] args) {
//创建动物操作类的对象，调用方法
AnimalOperator ao=new AnimalOperator();
Cat2 c=new Cat2();
ao.useAnimal(c);
Dog2 d=new Dog2();
ao.useAnimal(d);
Pig2 p=new Pig2();
ao.useAnimal(p);
}
}
1.4多态中的转型
- 向上转型（从子到父，父类引用指向子类对象）
- 向下转型（从父到子，父类引用转为子类对象）
package com.szy011;
public class Animal3 {
public void eat(){
System.out.println("动物吃东西");
}
}
package com.szy011;
public class Cat3 extends Animal3{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void playGame(){
System.out.println("捉迷藏");
}
}
package com.szy011;
public class AnimalDemo3 {
public static void main(String[] args) {
//多态
Animal3 a=new Cat3();//向上转型
a.eat();
// a.playGame();报错
/*
//创建Cat3类的对象
Cat3 c=new Cat3();
c.eat();
c.playGame();
*/
//向下转型
Cat3 c=(Cat3)a;
c.eat();
c.playGame();
}
}
运行结果为：
1.5多态转型内存问题
package com.szy012;
public class Animal4 {
public void eat(){
System.out.println("动物吃东西");
}
}
package com.szy012;
public class Cat4 extends Animal4{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void play(){
System.out.println("小猫钓鱼");
}
}
package com.szy012;
public class Dog4 extends Animal4{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void study(){
System.out.println("小狗学习");
}
}
package com.szy012;
public class AnimalDemo4 {
public static void main(String[] args) {
//向上转型
Animal4 a=new Cat4();//内存中,a是一只猫
a.eat();
//向下转型
Cat4 c=(Cat4)a;//猫强制转成猫没有问题
c.eat();
c.play();
//向上转型
a=new Dog4();//内存中a是一只狗
a.eat();
//向下转型
//ClassCastException类型转换异常
Cat4 cc=(Cat4)a;//内存中a是一只狗，强制给它转成猫报错
cc.eat();
cc.play();
}
}
案例：猫和狗（多态版）
需求：请采用多态的思想实现猫和狗的案例，并在测试类中进行测试。
package com.szy013;
public class Animal5 {
private String name;
private int age;
public Animal5() {//无参构造方法
}
public Animal5(String name, int age) {//带参构造方法
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println("动物吃饭");
}
}
package com.szy013;
public class Cat5 extends Animal5{
public Cat5() {
}
public Cat5(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("小猫吃小鱼");
}
}
package com.szy013;
public class Dog5 extends Animal5{
public Dog5() {
}
public Dog5(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("小狗啃骨头");
}
}
package com.szy013;
public class AnimalDemo5 {
public static void main(String[] args) {
//创建猫类对象并测试
Animal5 a=new Cat5();
a.setName("加菲");
a.setAge(4);
System.out.println(a.getName()+a.getAge());
a.eat();
a=new Cat5("小花",2);
System.out.println(a.getName()+a.getAge());
a.eat();
Animal5 b=new Dog5();
b.setName("小哈");
b.setAge(5);
System.out.println(b.getName()+b.getAge());
b.eat();
b=new Dog5("二哈",8);
System.out.println(b.getName()+b.getAge());
b.eat();
}
}
