目录

        概述

        成员访问特点

        优缺点

        多态中的转型

概述

同一个对象，在不同时刻表现出来的不同形态。
例：猫
猫是猫：猫 cat = new 猫();
猫是动物：动物 animal = new 猫();
此处，猫在不同时刻表现出来了不同形态，这就是多态。

多态的前提和体现：
①有继承/实现关系
②有方法重写
③有父类引用指向子类

/*
动物类（父类）
 */
public class Animal {
    public void eat(){
        System.out.println("动物吃什么");
    }
}

/*
猫类（子类）
 */
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

/*
测试类
 */
public class AnimalDemo {
    public static void main(String[] args){
        //父类引用指向子类对象
        Animal a = new Cat();
    }
}

成员访问特点

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

/*
动物类（父类）
 */
public class Animal {
    public int age = 20;

    public void eat() {
        System.out.println("动物吃什么");
    }
}

/*
猫类（子类）
 */
public class Cat extends Animal {
    public int age = 2;
    public int weight = 10;

    @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();

        System.out.println(a.age);
        //System.out.println(a.weight);
        System.out.println("------");
        a.eat();
        //a.playGame();
    }
}

优缺点

优点：提高了程序的扩展性
定义方法的时候，使用父类型作为参数，将来使用时，使用具体的子类型参与操作。
缺点：不能使用子类的特有功能。

/*
动物类（父类）
 */
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 lookDog() {
        System.out.println("狗看门");
    }
}

/*
动物操作类
 */
public class AnimalOperator {

    public void useAnimal(Animal a) {
        a.eat();
        // a.lookDog();//不能使用子类的特有功能
    }
    /*
    public void useAnimal(Cat c) {
        c.eat();
    }
    public void useAnimal(Dog d) {
        d.eat();
    }
     */
}

/*
测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOperator ao = new AnimalOperator();
        Cat c = new Cat();
        ao.useAnimal(c);

        Dog d = new Dog();
        ao.useAnimal(d);
    }
}

多态中的转型

• 向上转型
  从子类到父类，父类引用指向子类对象

• 向下转型
  从父类到子类，父引用转为子类对象

/*
动物类（父类）
 */
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();
        System.out.println("------");

        //向下转型
        Cat c = (Cat) a;
        c.eat();
        c.playGame();
    }
}

往期推荐

01

实现一个小型的学生信息管理系统

02

ArrayList集合

03

Java——修饰符

在看点一下