Java面向对象之多态

简介: Java面向对象之多态

1.多态

1.1多态的概述

什么是多态

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

举例:

  • 我们可以说猫是猫:猫 cat = new 猫();
  • 我们也可以说猫是动物:动物 animal = new 猫();

这里猫在不同的时刻表现出来了不同的形态,这就是多态

多态的前提

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

1.2多态中的成员访问特点

2020121019302877.png

成员访问特点:

  • 成员变量

编译看父类,运行看父类 (引用成员变量要看父类是否有,运行结果也是父类结果,因为还是父类是声明类)

  • 成员方法

编译看父类,运行看子类(编译时看父类是否有构造方法,运行时如果子类重写构造方法运行结果为构造方法)

代码演示:

动物类

public class Animal {
    public int age = 40;
    public void eat() {
        System.out.println("动物吃东西");
    }
}

猫类:

public class Cat extends Animal {
    public int age = 20;
    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);
        a.eat();
// a.playGame();
    }
}

1.3多态的好处和弊端

好处

  • 提高程序的扩展性。定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作

弊端

  • 不能使用子类的特有成员

1.4多态中的转型

向上转型

  • 父类引用指向子类对象就是向上转型

向下转型

  • 格式:子类型 对象名 = (子类型)父类引用;

代码演示

动物类

测试类

public class AnimalDemo {
    public static void main(String[] args) {
//多态
//向上转型
        Animal a = new Cat();
        a.eat();
// a.playGame();
//向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

2. 总结

 多态指的是同一个方法调用,由于对象不同可能会有不同的行为。现实生活中,同一个方法,具体实现会完全不同。 比如:同样是调用人的“休息”方法,张三是睡觉,李四是旅游,007是敲代码,数

学教授是做数学题; 同样是调用人“吃饭”的方法,中国人用筷子吃饭,英国人用刀叉吃饭,印度人用手吃饭。

多态的要点:

  1. 多态是方法的多态,不是属性的多态(多态与属性无关)。
  2. 多态的存在要有3个必要条件:继承,方法重写,父类引用指向子类对象。
  1. 父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了。

多态和类型转换测试

/**
 * 测试多态
 * @author 赵广陆
 *
 */
public class TestPolym {
  public static void main(String[] args) {
    Animal   a = new Animal();
    animalCry(a); 
    Animal  d = new Dog();      //自动向上转型
    animalCry(d);
    Animal   c = new Cat();
    animalCry(new Cat());
    Dog  d2 = (Dog) d;      //强制向下转型
    d2.seeDoor();
//    Dog   d3 = (Dog) c;
//    d3.seeDoor();
  }
  static  void  animalCry(Animal  a){
    a.shout();
  }
  /*static  void  animalCry(Dog  a){
    a.shout();
  }
  static  void  animalCry(Cat  a){
    a.shout();
  }*/
}
  class  Animal {
    public    void shout() {
        System.out.println("叫了一声!");
    }
}
class Dog extends Animal {
    public void shout() {
        System.out.println("旺旺旺!");
    }
    public  void   seeDoor(){
      System.out.println("看门!!!");   
    }
}
class Cat extends Animal {
    public void shout() {
        System.out.println("喵喵喵喵!");
    }
}

运行效果:

注:给大家展示了多态最为多见的一种用法,即父类引用做方法的形参,实参可以是任意的子类对象,可以通过不同的子类对象实现不同的行为方式。

   由此,我们可以看出多态的主要优势是提高了代码的可扩展性,符合开闭原则。但是多态也有弊端,就是无法调用子类特有的功能,比如,我不能使用父类的引用变量调用Dog类特有的seeDoor()方法。

目录
相关文章
|
2天前
|
Java 机器人 程序员
深入理解Java中的类与对象:封装、继承与多态
深入理解Java中的类与对象:封装、继承与多态
|
1天前
|
Java
Java编程思想(面向对象)第四版PDF分享
探索《Java编程思想》第四版,理解Java不仅是特性集合,更是解决问题的强大工具。本书深入设计层面,构建编程思维模型,助你逐步精通Java。[阅读更多](https://zhangfeidezhu.com/?p=355) ![Java编程思想](https://ucc.alicdn.com/pic/developer-ecology/nrw3f3oqlpmag_c8ff959a921545f1bbabcefd37f029cf.png)
18 1
Java编程思想(面向对象)第四版PDF分享
|
4天前
|
安全 Java
深度解读Java的继承和多态的特性
深度解读Java的继承和多态的特性
|
6天前
|
Java 编译器
Java多态(如果想知道Java中有关多多态的知识点,那么只看这一篇就足够了!)
Java多态(如果想知道Java中有关多多态的知识点,那么只看这一篇就足够了!)
|
9天前
|
Java 数据安全/隐私保护
Java基础之类封装、继承、多态
Java基础之类封装、继承、多态
12 4
|
6天前
|
存储 Java C语言
Java面向对象课程设计--类管理系统
Java面向对象课程设计--类管理系统
14 1
|
6天前
|
Java
Java面向对象特征(二)----- 继承
Java面向对象特征(二)----- 继承
Java面向对象特征(二)----- 继承
|
9天前
|
Java 数据安全/隐私保护
Java基础之类封装、继承、多态
Java基础之类封装、继承、多态
10 2
|
10天前
|
Java 数据安全/隐私保护 开发者
Java是一种完全支持面向对象编程的语言,其面向对象特性包括封装、继承、多态和抽象等
【6月更文挑战第18天】**面向对象编程(OOP)通过对象封装状态和行为,实现问题域的抽象。Java全面支持OOP,核心特性包括**: - **封装**:保护数据安全,隐藏内部细节。 - **继承**:子类继承父类属性和行为,促进代码重用。 - **多态**:一个接口多种实现,增强灵活性和扩展性。 - **抽象**:通过接口和抽象类抽离共性,简化复杂性。 **Java的OOP便于理解和解决复杂系统问题。**
21 3
|
9天前
|
安全 Java 数据安全/隐私保护
Java基础之类封装、继承、多态
Java基础的封装、继承和多态是OOP的核心。封装通过访问控制(如private)隐藏类的内部细节,提供公共接口供外部交互。例如,`Person`类封装`name`和`age`,通过`getName()`和`setAge()`方法访问。继承允许子类(如`Dog`)继承父类(如`Animal`)的属性和方法,并可扩展或覆盖。多态使得父类引用可指向子类对象,调用方法时根据实际对象类型执行,如不同动物的`makeSound()`。接口实现多态提供了一种定义行为而不必关心实现的方式。向上转型(子类→父类)安全且默认,而向下转型(父类→子类)需类型检查以避免异常。
10 1