标签：eat void System 多态 概述 println public out

多态概述

• 同一个对象，在不同时刻表现出来的不同形态
  举例:猫
  我们可以说猫是猫:猫cat = new猫();
  我们也可以说猫是动物:动物animal = new猫();
  这里猫在不同的时刻表现出来了不同的形态，这就是多态

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象：Parent p = new Child();

多态中成员访问特点

成员变量: 编译看左边，执行看左边
成员方法: 编译看左边，执行看右边
静态方法：编译和运行都看等号左边

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

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

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

class Animal {
    public int age = 30;
    
    public void eat(){  //被重写
        System.out.println("动物吃东西");
    }
    
    public void show(){  //没被重写
        System.out.println("show");
    }
}

class Cat extends Animal{
    public int age = 5;
    public int weight = 34;

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

public class Demo {
    public static void main(String[] args) {
        //父类引用指向子类对象
        Animal c1 = new Cat();
        System.out.println(c1.age);
        //System.out.println(c1.weight);//编译报错

        c1.show(); //show
        c1.eat();//猫吃鱼
        //c1.playGame();//编译报错
    }
}

多态的好处和弊端

• 多态的好处: 提高了程序的扩展性
  具体体现:定方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
• 多态的弊端: 不能使用子类的特有功能

class Animal {
    public void eat(){
        System.out.println("动物吃食物");
    }
}

Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor(){
        System.out.println("狗看门");
    }
}

class AnimalOperator {
    //省去
    /*public void useAnimal(Cat cat){
        cat.eat();
    }
    public void useAnimal(Dog dog){
        dog.eat();
    }*/
    //只需定义一个方法
    public  void useAnimal(Animal a){
        a.eat();
        //a.lookDoor();//编译报错 不能调用子类特有的方法
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOperator operator = new AnimalOperator();

        Cat cat = new Cat();
        operator.useAnimal(cat);//猫吃鱼

        Dog dog = new Dog();
        operator.useAnimal(dog);//狗吃骨头
    }
}

多态中的转型

解决了多态的弊端

• 向上转型

  从子到父
  父类引用指向子类对象

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

 class Animal {
    public void eat(){
        System.out.println("动物吃食物");
    }
}

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 cat = new Cat(); //向上转型
        cat.eat(); //猫吃鱼
        //cat.playGame(); //编译报错

        Cat c = (Cat) cat; //向下转型
        c.eat(); //猫吃鱼
        c.playGame(); //小猫捉迷藏
    }
}

标签：eat,void,System,多态,概述,println,public,out
来源： https://www.cnblogs.com/gzhbmnc/p/15265971.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。