JavaSE——面向对象（四）（多态）

1.多态

(1) 概述

同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。简单的说：就是父类的引用指向子类的对象。
举个例子：

Cat  cat =new  Cat();//猫可以是猫的类型
Animal a=new Cat();//同时猫也是动物的一种。也可以把猫称为动物

(2)多态前提

• 要有继承关系
• 要有方法重写,如果没有这个,多态也就没有意义
• 要有父类的引用指向子类对象

(3)多态中成员访问特点

成员变量

编译看左边,运行看左边

成员方法

编译看左边,运行看右边

构造方法

创建子类对象的时候,会访问父类的构造方法,对父类的数据进行初始化

静态方法

编译看左边,运行看左边

举例

package com.wetstmo.demo;
public class MyDemo7 {
    public static void main(String[] args) {
        Student1 stu=new Student2();
        System.out.println(stu.name);
        //采用多态形式访问成员变量，访问的时父类，编译看左边，运行看左边
        stu.Study();
        //访问成员方法，编译看左边，运行看右边
        //stu.Study1();
    }
}
class Student1{
    String name="小明";
    public void Study(){
        System.out.println("上学");
    }
}
class Student2 extends Student1{
    String name="小李";
    @Override
    public void Study() {
        System.out.println("上大学");
    }
    public void Study1(){
        System.out.println("好好上大学");
    }
}

(4)多态的好处

(1)提高了代码的维护性(继承保证)
(2)提高了代码的扩展性(多态保证)
举例说明多态的扩展性是如何体现的

package com.westmo.demo1;
public class Animal {
    String name;
    public void eat(){
        System.out.println("吃饭");
    }
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}
class Tiger extends Animal{
    @Override
    public void eat() {
        System.out.println("吃肉");
    }
}

package com.westmo.demo1;
public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        MyUtils.test(cat);
        Dog dog = new Dog();
        MyUtils.test(dog);
        Tiger tiger = new Tiger();
        MyUtils.test(tiger);
    }
}

//写了一个工具类
package com.westmo.demo1;

public class MyUtils {
    public static  void test(Animal animal){
        animal.eat();
    }
    //这样写,就大大提高了代码的扩展性,
/*
    public static void test(Dog dog){
        dog.eat();
    }
    public static void test(Cat cat){
        cat.eat();
    }
    public static void test(Tiger tiger){
        tiger.eat();
    }
    */
}

(5)多态的弊端以及多态中向上转型和向下转型

这个弊端很明显,无法访问子类特有的方法
解决办法:将父类的引用强行转为子类的引用(向下转型)

package com.westmo.demo1;
public class MyTest1 {
    public static void main(String[] args) {
        A a = new B();//向上转型
        a.show();
        //无法访问子类B中的特有方法show1
        // a.show1();
        B b=(B) a;//向下转型现在就可以访问子类中的特有方法
        b.show1();
    }
}
class A{
    public void show(){
        System.out.println("123");
    }
}
class B extends A{
    @Override
    public void show() {
        System.out.println("234");
    }
    public void show1(){
        System.out.println("JAVA");
    }
}

(6)多态内存图

将以一段代码为实例,演示以下多态在内存中的状态

package com.westmo.demo1;

public class MyTest1 {
    public static void main(String[] args) {
        A a = new B();//向上转型
        System.out.println(a.name);
        a.show();
        B b=(B) a;//向下转型
        System.out.println(b.name);
        b.show1();
    }
}
class A{
    int name=100;
    public void show(){
        System.out.println("123");
    }
}
class B extends A{
    int name=200;
    @Override
    public void show() {
        System.out.println("234");
    }
    public void show1(){
        System.out.println("JAVA");
    }
}