类与对象(二十)---多态polymorphic

已于 2022-10-06 19:05:48 修改
阅读量671 收藏 2
点赞数
分类专栏： JAVASE All 文章标签： java jvm 开发语言
于 2022-10-06 19:04:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WINorYU/article/details/127155379
版权

多态是什么

多态首先是建立在继承的基础上的，先有继承才能有多态。多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式。多态成立的另一个条件是在创建子类时候必须使用父类new子类的方式。
通俗的讲：多态是融合了重写和重载特点的结合体，多态有重载的形参列表不同的特点也有重写的继承类可访问的特点。

  • 案例引出多态：
    编写一个程序，Master类(主人类)中有一个feed喂食的方法，可以完成主人对宠物的喂食。
    那么可以 根据题目抽象出两个父类 Food类（食物类）和Animal类(动物类)再写出他们各自的子类
    Food类（食物类）：Fish类鱼 Bone类骨头
    Animal类（动物类）：Cat类猫 Dog类狗
    根据之前学到的知识点，可以采用继承+重载的方式实现
//食物类
public class Food {
   private String name;
   public Food(String name) {
       this.name = name;
   }
   public String getName() {
       return name;
   }
}
//鱼类
public class Fish extends Food{
   public Fish(String name) {
       super(name);
   }
}
//骨头类
public class Bone extends Food{
   public Bone(String name) {
       super(name);
   }
}
//动物类
public class Animal {
   private String name;
   public Animal(String name) {
       this.name = name;
   }
   public String getName() {
       return name;
   }
}
//狗类
public class Dog extends Animal{
   public Dog(String name) {
       super(name);
   }
}
//猫类
public class Cat extends Animal{
   public Cat(String name) {
       super(name);
   }
}
//主人类
public class Master {
   private String name;
   public Master(String name) {
       this.name = name;
   }
   public void feed(Cat cat,Fish fish){
       System.out.println("主人"+name+"正在喂他的"+cat.getName()+"吃"+fish.getName());
   }
   public void feed(Dog dog,Bone bone){
       System.out.println("主人"+name+"正在喂他的"+dog.getName()+"吃"+bone.getName());
   }
}
//测试类
public class Test07 {
   public static void main(String[] args) {
       Master tom = new Master("汤姆");
       Dog dog = new Dog("旺财");
       Bone bone = new Bone("大骨头");
       Cat cat = new Cat("小咪");
       Fish fish = new Fish("小黄鱼");
       tom.feed(dog,bone);
       tom.feed(cat,fish);
   }
}

编译输出
在这里插入图片描述

这样的话就后面再想喂其他的动物吃东西，又得重载feed方法。复用性太高因此就需要多态，来减少代码的复用性。

方法的多态

在前面的学习中，重载和重写方法，就是让不同条件下调用不同的方法，这就是多态的一种体现方式.
例如

//A类
public class A {
    public int sum(int a,int b){
        return a+b;
    }
    public int sum(int a,int b,int c){
        return a+b+c;
    }
}
//测试类
public class Test07 {
    public static void main(String[] args) {
        A a1 = new A();
        a1.sum(44,55);
        a1.sum(55,66,44);
    }
}

这里就是根据不同的形参列表找到不同的sum方法，也是一种多态的体现。同理重写方法也是一种多态的体现

对象的多态

  • 一个对象的编译类型和运行类型可以不一致

编译类型就是编译成class文件时的类型，运行类型就是实际运行的类型

  • 编译类型在定义对象时，就确定了，不可以改变
  • 运行类型是可以变化的
  • 编译类型看=号的左边，运行类型看=号的右边

例如：现在有三个类 Animal类和Dog类和Cat类，其中Animal类是他们的父类。

//动物类
public class Animal {
    public void cry(){
        System.out.println("某种动物的叫声");
    }
}
//狗类
public class Dog extends Animal{
    public void cry(){
        System.out.println("小狗叫...");
    }
}
//猫类
public class Cat extends Animal{
    public void cry(){
        System.out.println("小猫叫...");
    }
}

可以看到子类重写了父类的cry方法。
假设在测试类中实例化Animal类 Animal animal = new Animal(); 然后调用animal的方法 animal.cry();
输出的是：某种动物的叫声
那么上面说了对象的多态体现中有一点： 运行类型是可以变化的

那么我们根据这个特点，想输出狗类的cry方法，就不用再实例化一个Dog类的对象了，只需更改animal的运行时对象即可 也就是 父类的引用指向子类的对象
Animal animal = new Dog(); 然后再次调用cry方法 animal.cry();
输出的是
小狗叫…
在这里插入图片描述
这里是就是再继承的基础上，借用重写的特点，体现了对象的一个多态
内存图演示：
在这里插入图片描述

多态入门

从上面了解到，多态的基本特点和思想。那么同理也可以利用多态的特点：父类的引用可以指向子类的对象
来解决一开始的主人 喂宠物 的问题，先开始的方法代码复用性比较高，如果要新增一个动物，就要在主人类中重载一个Feed方法，那么由于学习了多态-父类的引用可以指向子类的对象-这个特点，我们可以在父类的Feed方法中形参直接使用动物和食物的父类，然后实际传入的是他们的子类，这样使用多态的特点，减少代码的复用性.

//食物类
public class Food {
   private String name;
   public Food(String name) {
       this.name = name;
   }
   public String getName() {
       return name;
   }
}
//鱼类
public class Fish extends Food{
   public Fish(String name) {
       super(name);
   }
}
//骨头类
public class Bone extends Food{
   public Bone(String name) {
       super(name);
   }
}
//动物类
public class Animal {
   private String name;
   public Animal(String name) {
       this.name = name;
   }
   public String getName() {
       return name;
   }
}
//狗类
public class Dog extends Animal{
   public Dog(String name) {
       super(name);
   }
}
//猫类
public class Cat extends Animal{
   public Cat(String name) {
       super(name);
   }
}
//主人类
public class Master {
   private String name;
   public Master(String name) {
       this.name = name;
   }
   //这里形参直接使用父类，届时传入他们的子类对象。
   public void feed(Animal animal,Food food){
       System.out.println("主人"+name+"正在喂他的"+animal.getName()+"吃"+food.getName());
   }

}
//测试类
public class Test07 {
   public static void main(String[] args) {
       Master tom = new Master("汤姆");
       Dog dog = new Dog("旺财");
       Bone bone = new Bone("大骨头");
       Cat cat = new Cat("小咪");
       Fish fish = new Fish("小黄鱼");
       tom.feed(dog,bone);
       tom.feed(cat,fish);
   }
}

这样即实现了功能，也为后续的代码拓展性增加了。例如再增加一个猪类，吃米饭

//动物  猪类
public class Pig extends Animal{
   public Pig(String name) {
       super(name);
   }
}
//食物类 米饭
public class Rice extends Food{
   public Rice(String name){
       super(name);
   }
}
//测试类
public class Test07 {
   public static void main(String[] args) {
       Master tom = new Master("汤姆");
       Dog dog = new Dog("旺财");
       Bone bone = new Bone("大骨头");
       Cat cat = new Cat("小咪");
       Fish fish = new Fish("小黄鱼");
       Pig pig = new Pig("小猪");
       Rice rice = new Rice("米饭");
       tom.feed(dog,bone);
       tom.feed(cat,fish);
       tom.feed(pig,rice);
   }
}

输出结果
在这里插入图片描述

多态-向上转型

向上转型的本质就是 父类的引用指向子类的对象
语法：父类类型 引用名 = new 子类类型();
规则-

  1. 编译类型看左边，运行类型看右边
  2. 可以调用父类的所有成员（属性，方法），但需遵守访问修饰符规则
  3. 不能调用子类中的特有成员
  4. 最终运行内容看子类具体实现，即从子类中开始找成员，找到即返回，子类没有再去父类找。

规则解释：
其实后面三点的规则都是在解释第一点的规则

直接看第二点----可以调用父类的所有成员（属性，方法），但需遵守访问修饰符规则
现在有一个父类Animal类和一个子类Cat类

//父类
public class Animal {
    public void run(){
        System.out.println("跑");
    }
    public void sleep(){
        System.out.println("睡");
    }
    private void show(){
        System.out.println("你好");
    }
}
//子类
public class Cat extends Animal{
    //子类的特有方法 抓老鼠
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}
//测试类
public class Test08 {
    public static void main(String[] args) {
        Animal animal = new Cat();
        
    }
}

可以看到在测试类中是父类 Animal 的引用指向了子类Cat，根据规则可以调用父类所有的成员
在这里插入图片描述
可以看到跑和睡方法都可以调用，但是私有化的show方法不能直接调用，得父类提供一个公开的调用方法。

再看第三点----不能调用子类中的特有成员

因为在编译阶段，看的是左边编译类型，也就是父类Animal，而子类的特有方法父类是没有的，自然就无法调用了
在这里插入图片描述
第四点----最终运行内容看子类具体实现，即从子类中开始找成员，找到即返回，子类没有再去父类找。
最终运行就是编译完成后，运行的内容。这时看的就是右边运行类型也就是子类，那么对于成员和方法也就是和this的规则一样，先从子类开始找，子类没有再去父类。
例如 在Cat类中重写一下父类的run方法，然后在测试类中调用

public class Cat extends Animal{
    //子类的特有方法 抓老鼠
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
    //重写父类的run方法
    public void run(){
        System.out.println("子类的run方法");
    }
}
//测试类
public class Test08 {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.run();
        animal.sleep();
    }
}

输出结果
在这里插入图片描述
从子类开始找run方法，发现子类有那么就执行子类的，然后在子类找sleep方法，发现没有，再去父类找，找到了执行父类的sleep方法
在这里插入图片描述

多态-向下转型

因为在向上转型中，编译阶段只能调用父类的成员，无法调用子类的特有成员，所以在向上转型的基础上发展了向下转型
语法：子类类型 引用名 = (子类类型) 父类引用名；
规则-

  1. 只能强转父类的引用，不能强转父类的对象
  2. 要求父类的引用必须指向的是当前向下转型目标类型的对象
  3. 当向下转型后，可以调用子类类型中所有的成员

规则解释
第一点----只能强转父类的引用，不能强转父类的对象
当一个人生下来时，他就是一个人，他会改名字，但是他还是一个人类，不能变成狗 变成鸟。
同理向下转型不能改变在堆中的对象，只能改变在栈中的引用（也就是改变编译类型）
第二点----要求父类的引用必须指向的是当前向下转型目标类型的对象
还是使用上面那个案例

//父类
public class Animal {
    public void run(){
        System.out.println("跑");
    }
    public void sleep(){
        System.out.println("睡");
    }
    private void show(){
        System.out.println("你好");
    }
}
//子类
public class Cat extends Animal{
    //子类的特有方法 抓老鼠
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}
//测试类
public class Test08 {
    public static void main(String[] args) {
        Animal animal = new Cat();
        //向上转型之后再向下转型
        Cat cat = (Cat)animal;
    }
}

当向下转型后内存中：
在这里插入图片描述
因为向下转型是为了可以使用子类的方法，当父类的引用指向另一个对象时，就不符合逻辑了，也失去了原本的意义。其中父类的引用指向的是Cat对象，要让Dog类指向Cat类。这不就是说狗是猫？，原本是“动物”是“猫”，这是向上转型，然后“猫”是“动物”，向下转型，这都是符合逻辑的，但是猫是狗就不符合逻辑了。运行会报错
第三点----当向下转型后，可以调用子类类型中所有的成员
也就是向下转型的目的，当向上转型时，无法使用父类的引用，调用子类的特有成员，所以向下转型就是改变父类的引用变成子类的引用。

	    Animal animal = new Cat();
        //向上转型之后再向下转型
        Cat cat = (Cat)animal;

这样编译类型就是子类类型了

//测试类
public class Test08 {
    public static void main(String[] args) {
        Animal animal = new Cat();
        //向上转型之后再向下转型
        Cat cat = (Cat)animal;
       cat.catchMouse();
    }
}

输出结果
在这里插入图片描述
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/04785ec3430356fa2afe94e7cb58d4f6.png

多态-属性问题和instanceOf关键字

属性没有重写一说，属性的值看编译类型

//A类父类
class A{
public int num = 10;
}
//B类子类
class B extends A{
public int num = 20;
}
//测试类
A a = new B();//向上转型
System.out.println(a.num);

属性不会和方法一样，从运行类型开始找起，而是直接看编译类型，所以会输出=10，当然如果编译类型没有找到，也会去编译类型的父类找。

instanceOf关键字

instanceOf是一个比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型
举例：

public class Test08 {
    public static void main(String[] args) {
        Object obj = new Object();
        System.out.println(obj instanceof Object);//obj的运行类型就是Object--true
        Cat cat = new Cat();
        System.out.println(cat instanceof Animal);//cat的运行类型就是Animal的子类--true
        
    }
}

多态练习

说出下面语句哪些是对是错 为什么

		double d =13.4;//对
        long i = (long)d;//对
        System.out.println(i);//对
        int a = 5;//对
        boolean b = (boolean) a;//错，int类型不能转为布尔类型
        Object obj = "heelo";//对 向上转型
        String str = (String)obj;//对 向下转型
        System.out.println(str);//对 输出heelo
        Object obj2 = new Integer(5);//对向上转型
        String str2 = (String)obj2;//错 父类的引用必须指向的是当前向下转型目标类型的对象也就是必须指向Integer
        Integer in1 = (Integer) obj2;//对向下转型

看看下面测试类中会输出什么

public class Base {
    int count = 10;
    public void display(){
        System.out.println(this.count);
    }
}
class Sub extends Base{
    int count = 20;
    public void display(){
        System.out.println(this.count);
    }
}
class Test09{
    public static void main(String[] args) {
        Sub s = new Sub();
        System.out.println(s.count);//属性直接看编译类型，所以输出20
        s.display();//方法从运行类型开始找，所以是20
        Base b = s;//向上转型
        System.out.println(b == s);//这里是比较运行类型，两个引用的运行类型都是Sub所以是true
        System.out.println(b.count);//属性直接看编译类型，所以输出10
        b.display();//方法从运行类型开始找，所以是20
    }
}
WINorYU
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
类与对象--多态
weixin_63481038的博客
12-16 296
c++ 类与对象 多态
类和对象-多态
chunchun2021的博客
09-08 279
c++
类与对象——多态
JeffreyLiannnn的博客
11-03 165
类与对象——多态基本概念 基本概念 多态分为两类 静态多态：函数重载和运算符重载属于静态多态，复用函数名 动态多态：派生类和虚函数实现运行时多态 静态多态和动态多态的区别 静态多态的函数地址早绑定——编译阶段确定函数地址 动态多态的函数地址晚绑定——运行阶段确定函数地址 ...
类和对象 --多态
杨跟的博客
10-18 386
1.基本概念 多态是C++面向对象的三大特征之一 多态分为两类： 静态多态：函数重载与运算重载，复用函数名。 动态多态：派生类和虚函数实现运行时的多态 静态多态与动态多态的区别 静态多态的函数地址早绑定---编译阶段确定函数的地址 动态多态的函数地址晚绑定---运行阶段确定函数地址 2.动态多态满足条件 继承关系 子类要重写父类中的虚函数 重写与重载是不一样的：重写 ...
类与对象（4）多态
Kazichs的博客
04-17 386
public class Text{ public static void main(String[] args){ } } class Person{ String name; int age; public void loveFood(){ } } class Child extends class Person{ public void lo
django-polymorphic-tree：对模型的多态MPTT树支持
02-05
**django-polymorphic-tree** 是一个用于Django框架的扩展库，它提供了对多态模型的MPTT（Modified Preorder Tree Traversal）树结构的支持。MPTT是一种高效的数据库模型设计模式，常用于处理层级关系的数据，如分类...
django-polymorphic：通过自动向下转换改进了Django模型继承
02-05
6. **Django FormSets**：`django-polymorphic`可能支持与Django的FormSets结合使用，允许一次性处理一组相关但类型不同的表单，这对于多态模型的表单提交和验证非常有用。 7. **Django Admin集成**：`django-...
polymorphic_embed：Ecto中的多态嵌入
02-05
Elixir是一个函数式编程语言，而Phoenix是基于Elixir构建的Web开发框架，Ecto则是Phoenix和Elixir应用中广泛使用的ORM（对象关系映射）库，它提供了一种与数据库交互的方式。 在Ecto中，我们通常使用`has_many`和`...
spring-jackson-polymorphic
06-06
java -jar target/deserialize-polymorphic-0.0.1-SNAPSHOT.jar 测试序列化 此应用程序提供很少的休息端点。 要获取整个动物园调用： curl -s http://localhost:8080/zoo 正如您在响应中看到的，每个动物对象都...
polymorphic-single-page
03-26
标题“polymorphic-single-page”指的是一个特定的Rails应用程序，它着重于在单个页面上实现多态关联的处理，利用Simple_form库进行表单提交和数据展示，并且通过AJAX进行动态更新。这个项目旨在优化ActiveRecord的...
Java多态3 - 多态的向下转型
m0_53753920的博客
05-20 1378
多态的向下转型： 1. 语法：子类类型 引用名 = （子类类型） 父类引用。 2. 只能强转父类的引用，不能强转父类的对象。 3. 要求父类的引用必须指向的是当前目标类型的对象。 4. 向下转型后，可以调用子类类型中的所有成员。 1. 动物类 public class Animal { String name = "动物"; int age = 10; public void sleep(){ System.out.println("睡觉"); .
Java Note (4) Polymorphic
Hinton. Zhang 的专栏
03-07 603
多态实现了“是什么”与“怎样做”两个模块的分离，代码的组织以及可读性均能获得改善。此外，还能创建“易于扩展”的程序。无论在项目的创建过程中，还是在需要加入新特性的时候，它们都可以方便地扩展。 多态旨在消除类型之间的耦合关系。我们知道，通过继承可将一个对象当作它自己的类型或者它自己的基础类型对待。这种能力是十分重要的，因为多个类型（只要从相同的基础类型中衍生出来）可被当作同一种类型对待。因而只需一
Java基础——多态（polymorphic）
AHOPEL的博客
12-06 233
1.定义：多态是同一个行为具有多个不同表现形式或形态的能力，同样的方法在不同的对象上产生不同的效果。 2.多态的三个必要条件： 2.1.继承 2.2.重写 2.3.父类引用指向子类对象（向上转型）。 eg: ...
Java多态相关练习
Dokey_L的博客
07-24 683
一、选择 1.下列代码的运行结果为：C A. 我是动物 B. 编译错误 C. 我是动物 我是老虎 我是哈士奇 D. 我是动物 我是老虎 我是哈士奇 2.创建一个父类Animal，一个子类Cat，Animal three = new Cat();是 A A. 向上转型 B. 自动转型 C. 向下转型 D. 隐式转型 3.下列代码怎么修改可以使其成功运行：A A. 删除掉标注3位置的one.fly( ) B. 标注1的Animal one=new Bird()修改为Animal one=
多态（polymorphic）
最新发布
weixin_67807492的博客
11-13 1万+
多态是Java三大基本特征中最抽象也是最重要的特征。多态是建立在封装和继承衍生之上的。
向上转型和向下转型（强转） 总结
m0_48660145的博客
04-07 725
向上转型： 本质：父类引用指向了子类的对象 语法：父类类型 引用名 = new 子类类型（）； 特点：编译类型看左边，运行类型看右边 可以调用父类中的所有成员（需访问权限） 不能调用子类特有的成员； 最终运行效果看子类的具体实现！ 方法的调用： public class OuterClass{ public static void main(String args[]) { A a = new B(); //父类引用指向子类对象
类和对象之间的关系?封装继承多态?
yeliner的博客
03-04 4279
在面向对象的编程思想中把对象的属性和行为分别称为对象的属性和方法，是构成对象的两个主要因素；在编程中，对象的属性被存储在一些变量里；对象的行为则通过定义方法来实现。三大基本特征：封装，继承，多态。 对象：用来描述客观事物的一个实体，由一组属性和方法构成 类：具有相同属性和行为的一类物质集合 类：对象的抽象 对象：类的实例化 创建并使用对象： 类名 对象名=new 类名（）； Scho...
Java基础（6）面向对象编程（中级）
qq_51326017的博客
07-22 221
（韩顺平Java基础）包、修饰符、Java的三大特性、Object、debug、Java零钱通项目
Java 向上转型和向下转型
吾之奉先的博客
04-19 517
多态的向上转型： （1）本质：父类的引用指向了子类对象 （2）语法： 父类类型 引用名 = new 子类类型()； （3）特点(规则)：编译类型看左边，运行类型看右边。 可以调用父类中的所有成员(遵守访问权限)(实际运行时需要遵守访问权限，大概，存疑) 不能调用子类特有成员(原因：在编译阶段，能调用哪些成员，是由编译类型来决定的) 最终运行效果由子类具体实现决定(调用方法时，按照...
Objective-C 笔试宝典：100道选择题与解析
多态继承（Polymorphic inheritance） 答案: C. 公开继承（Public inheritance） 13. 关于Objective-C中的分类（Category），以下哪个描述是正确的？ A. 分类只能添加实例方法，不能添加属性。 B. 分类可以添加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值