JAVA多态的学习

于 2022-11-16 20:44:23 发布
阅读量91 收藏 1
点赞数
分类专栏： JAVA学习笔记 文章标签： java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65366860/article/details/127892940
版权

多态

多态即 多种 状态

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的

方法的多态

 class Test {
     public static void main(String[] args) {
         //方法重载体现多态
         A a = new A();

         //这里我们传入不同的参数，就会调用不同sum方法，就体现多态
         System.out.println(a.sum(10, 20));
         System.out.println(a.sum(10, 20, 30));

         //方法重写体现多态
         B b = new B();
         a.say();
         b.say();




     }

 }
     class B { //父类
         public void say() {
             System.out.println("B say() 方法被调用...");
         }
     }
     class A extends B {//子类
         public int sum(int n1, int n2){//和下面sum 构成重载
             return n1 + n2;
         }
         public int sum(int n1, int n2, int n3){
             return n1 + n2 + n3;
         }


         public void say() {
             System.out.println("A say() 方法被调用...");
         }

     }

对象的多态（核心）

重要的话: (介绍) 多态在继承和封装的基础之上

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

    //Animal animal=new Dog(); //不一致
//animal的编译类型是Animal，运行类型是 Dog, new Dog()才是对象 animal是对象名字
//Animal animal=new Animal(); //一致

//animal =new Cat(); 
//Animal是编译类型，而Cat是运行类型

  2. 编译类型在定义对象时，就确定了，不能改变

    public class PolyObject {
    public static void main(String[] args) {
        //体验对象多态特点
        //animal 编译类型就是 Animal , 运行类型 Dog
        Animal animal = new Dog();//定义声明对象
        //因为运行时 , 执行到改行时，animal运行类型是Dog,所以cry就是Dog的cry
        animal.cry(); //小狗汪汪叫

        //animal 编译类型 Animal,运行类型就是 Cat
        animal = new Cat();
        animal.cry(); //小猫喵喵叫
    }
}

  3. 运行类型是可以改变的

  4. 编译类型看定义时=号的左边，运行类型看=号右边

主人喂养 动物食物例子（快速入门）

public class Master {//主人类
    private String name;
    public Master(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
   // public void feed(Dog dog, Bone bone) {
    //   System.out.println("主人 " + name + " 给 " + dog.getName() + " 吃 " + bone.getName());
   //  }


    //使用多态机制，可以统一的管理主人喂食的问题
    //animal 编译类型是Animal,可以指向(接收) Animal子类的对象
    //food 编译类型是Food ,可以指向(接收) Food子类的对象
    //多态
   public  void feed(Animal animal,Food food){
       System.out.println(name+"喂给"+animal.getName()+""+food.getName());
    }
}


public class Animal {//动物类
    private  String name;

    public   Animal(String name){
    this.name=name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class Dog extends Animal{//狗类

    public Dog(String name){
        super(name);
    }
}

public class Food { //食物类
    private String  name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    public  Food(String name){
      this.name=name;
    }
}
public class Bone extends Food {//骨头类
    public Bone(String name) {
        super(name);
    }
}

public class Test {//测试代码
    public static void main(String[] args) {
        Dog dog=new Dog("大黄");
        Master master=new Master("李华");
        Bone bone =new Bone("大骨头");
        //master.feed(dog,bone);

        
        
        Animal animal =new Dog("小白");
        Food food =new Bone("小骨头");
        master.feed(dog,bone);  //多态
    }
}

多态的注意事项和细节

多态的基础是两个对象（类）存在继承关系

1.向上转型

  1. 本质：父类的引用指向了子类的对象

  2. 语法： 父类类型 引用名=new 子类类型( );

    //Animal animal =new  Dog("小白");
//animal是引用名   Dog是子类类型

  3. 特点：

    (1)可以调用父类中的所有成员(需遵守访问权限)
    (2)但是不能调用子类的特有的成员

    //例子

public class Animal {
    String name = "动物";
    int age = 10;
    public void sleep(){
        System.out.println("睡");
    }
    public void run(){
        System.out.println("跑");
    }
    public void eat(){
        System.out.println("吃");
    }
    public void show(){
        System.out.println("hello,你好");
    }

}

public class Cat extends Animal {
    public void eat(){//方法重写
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){//Cat特有方法
        System.out.println("猫抓老鼠");
    }
}

public class Test {
    public static void main(String[] args) {
        //向上转型: 父类的引用指向了子类的对象
        //语法：父类类型引用名 = new 子类类型();
        Animal animal = new Cat();
        Object obj = new Cat();//可以吗? 可以 Object 也是 Cat的父类,间接父类也是父类
        //向上转型调用方法的规则如下:
        //(1)可以调用父类中的所有成员(需遵守访问权限)
        //(2)但是不能调用子类的特有的成员
        //animal.catchMouse();错误
        //(#)因为在编译阶段，能调用哪些成员,是由编译类型来决定的

        
        //(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法
        //，然后调用，规则我前面我们讲的方法调用规则一致。
        animal.eat();//猫吃鱼..
        animal.run();//跑
        animal.show();//hello,你好
        animal.sleep();//睡

    }
}

2.向下转型

  1. 语法：子类类型 引用名 = （子类类型） 父类引用；
  2. 只能强转父类的引用，不能强转父类的对象
  3. 要求父类的引用必须指向的是当前目标类型的对象
  4. 当向下转型后，可以调用子类类型中所有得成员
//(1)语法：子类类型 引用名 =（子类类型）父类引用;
//问一个问题? cat 的编译类型 Cat,运行类型是 Cat
Cat cat = (Cat) animal

​

3.注意事项

  1. 属性没有重写之说！属性的值要看编译类型（和书上写的方法的隐藏是一样的）

    

public class PolyDetail02 {
    public static void main(String[] args) {
        //属性没有重写之说！属性的值看编译类型
        Base base = new Sub();//向上转型
        System.out.println(base.count);// ？ 看编译类型 10
        Sub sub = new Sub();
        System.out.println(sub.count);//?  20
    }
}

class Base { //父类
    int count = 10;//属性
}
class Sub extends Base {//子类
    int count = 20;//属性
}

instanceof 关键字

package com.hspedu.poly_.detail_;

public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof  BB);// true
        System.out.println(bb instanceof  AA);// true

        //aa 编译类型 AA, 运行类型是BB
        //BB是AA子类
        AA aa = new BB();
        System.out.println(aa instanceof AA);
        System.out.println(aa instanceof BB);

        Object obj = new Object();
        System.out.println(obj instanceof AA);//false
        String str = "hello";
        //System.out.println(str instanceof AA);
        System.out.println(str instanceof Object);//true
    }
}

class AA {} //父类
class BB extends AA {}//子类
虎头鹊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多态讲解
danielinbiti的专栏
03-04 3359
JAVA多态 一、相关的类结构 class A ...{ public String show(D obj)...{ return ("A and D"); } public String show(A obj)...{ return ("A and A"
Java多态学习记录
cxy_19891109的博客
09-12 164
面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。 1.定义： 多态：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用） 2.实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类...
Java多态学习笔记
weixin_34283445的博客
03-04 140
面向对象三大特性：封装，继承和多态。其中，封装，继承都比较通俗易懂，唯有多态令我甚是头疼。经过仔细研究之后，终于搞懂了一点，特来做一个分享。独乐乐不如众乐乐。 何为多态？多态的本质是：一个程序中同名的不同方法。在面向对象的程序设计中，多态主要有以下三种方式来实现。 （1）、通过子类对父类方法的覆盖来实现多态。 （2）、通过一个类中...
java多态学习
shuoxi666的博客
03-21 209
多态： 多态指的是同一个方法调用时，由于对象不同可能会有不同的行为 多态的三个必要条件： 继承，方法重写，父类引用指向子类对象 多态的实现方式： 方式一：重写 方式二：接口 方式三：抽象类和抽象方法 多态的优点： 1. 消除类型之间的耦合关系 ...
Java多态 学习
gegejiawei的博客
07-23 397
思维导图 导学 本章节，我们将要学习面向对象三大特性之一的多态，所谓的多态，字面意义来看就是多种形态。它是面向对象程序设置的最核心的特征。从某种意义上来讲，封装和继承都是为了多态而准备的。 多态的概念 在现实生活中，动物都有吃东西，跑和跳等通用的行为能力，但是不同的动物针对行为的表现形式是不同的。比如猫，狗，兔子喜欢吃的东西各有不同，而叫声也是不一样的。 再比如键盘上的f1键，在eclipse的界面会唤出eclipse的帮助文档，在word的界面会唤出word的帮助文档，在Windows系统下回唤出Wi
java的多态扩展性
04-23
java教学视频，讲解了多态的扩展性、转型、成员特点、主板实例、object类等
Java多态的内存机制
12-22
学习java也快一年多了，看过很多方面的书，也喜欢在网络上学习的java资料。但是每当自己打开myeclipse时，总是那么的不自信…………，java基础部分的内容自己以及掌握，并能很好运用，加油吧，多实践，多总结，一定...
通过实例分析java多态
08-25
主要介绍了通过实例分析java多态,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
简单了解Java多态向上转型相关原理
08-25
主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多态(动力节点Java学院整理)
08-30
多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。接下来通过本文给大家介绍java多态相关知识，感兴趣的朋友一起学习吧
Java多态学习
HANJUN的专栏
11-12 600
在面向对象多态是
java学习——多态
yjh728的博客
06-04 211
final关键字 最终的意思,可以修饰类,方法,变量 修饰变量: 该变量只能被赋值一次,即用final修饰的变量为常量 修饰方法 该方法不能被重写 修饰类 该类不能被继承 多态 定义 多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该...
Java基础学习之多态
那些年我们一起学JAVA
05-11 184
Java中的多态1.JAVA的多态用一句话能直观的解释一下:  事物在运行过程中存在不同的状态。2.多态存在的三个前提1.类与类之间要有继承关系2.子类要重写父类的方法3.(核心)父类引用(指针)指向子类对象(子类的空间) 2.多态的优点1. 消除类型之间的耦合关系2. 可替换性3. 可扩充性4. 接口性5. 灵活性6. 简化性当使用多态方式调用方法时，首先检查父类中是否有该方法，如果...
Java学习之多态详解
Java学习博客
07-27 302
本文是对Java多态的详解
Java多态学习总结
liuweiballack的专栏
07-29 1259
一、多态产生的条件 存在继承关系； 存在方法重写； 要有父类引用指向子类对象。 示例代码：public class PolymorphismTest { public static void main(String[] args) { SuperClass clazz = new SubClass(); //满足父类引用指向子类对象条件 } }class Super
Java多态
Gremmie的博客
04-07 7571
java多态中关于重载重写、向上和向下转型的一些解析
Java多态详解
热门推荐
m0_67599274的博客
04-28 3万+
目录1. 基本介绍1.1 多态的概念1.2 对象的多态1.3 入门案例2. 具体细节2.1 向上转型2.2 向下转型2.3 instanceOf 比较操作符3. 实现技术：动态绑定4. 应用4.1 多态数组4.2 多态参数5. 多态的优点 1. 基本介绍 1.1 多态的概念 多态是继封装、继承之后，面向对象的第三大特性。 多态体现为父类引用变量可以指向具体的子类对象。 1.2 对象的多态 1.3 入门案例 2. 具体细节 2.1 向上转型 2.2 向下转型 2.3 instanceOf 比较操作符 3. 实
Java多态难点解析
lds_include
08-02 1573
Java多态学习 定义: 指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。 举例：一种事物的多种形态 人==动物==生物：人既是动物也是生物。 牡丹=植物=生物：牡丹既是植物也是生物。 多态的几大必要条件： 必须要有继承关系才行。 完成继承的同时要有对父类的重写（重写和重载的区别在我的“java面向对象、内存、封装、变...
学习java继承和多态之final关键字
最新发布
04-11
学习Java继承和多态之final关键字。 final是Java中的一个关键字，用于修饰类、方法和变量，表示“最终的、不可变的”。当用final修饰一个类时，说明该类不允许被继承；当用final修饰一个方法时，说明该方法不允许被...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值