java面向对象三大特征之一多态（多类调用）

你的名字 2023-09-28 17:51 21阅读 0赞

**目录**

前言必读：

一、概念

二、小说情景化理解：

三、堆栈化理解调用理解

四、代码例子

## **前言必读：** ##

> [读者手册（必读）\_云边的快乐猫的博客-CSDN博客][-CSDN]

1.多态是方法的多态，和属性没有关系

2.对象能执行哪些方法，主要看对象new的左边，和右边关系不大

## 一、概念 ##

1.**父类成员 变量 = new 父类成员**

可以使用：（父类成员变量，父类方法）

2.**子类成员 变量 = new 子类成员**

可以使用：（子类成员变量，子类方法，继承过来的父类成员变量，父类方法）

3.**父类成员 变量 = new 子类成员**

可以使用：（父类成员变量，父类方法，被子类重写后的方法）

## **二、小说情景化理解：** ##

（对象：以前大多是通过子类调用。现在对象我不满足了，想要调子类，调父类，还要父子混搭调。类：纯父类是只能调父类的里面的，纯子类是调子类里面**和**继承过来父类的也可以调，父子混合类就只能调父亲的，如果父亲方法被重写了，调用的也是重写后的）

**注释：出现相同的变量名：就近原则，使用本类的**

## 三、堆栈化理解调用理解 ##

> 栈 变量名 = new 堆

**解释：**对象调用执行就是通过main方法区入口，在栈（变量名）里面通过地址索引找到堆内存中具体的数值，获取到后再返回来给栈（变量名）内存用。

![9defe7f335dc4bd69b1d2a12d9ea9f1c.png][]

## 四、代码例子 ##

共计2个变量，4个成员方法，父子类分别有（一个成员变量，一个方法，一个重写后方法）

父类

package bao;
    public class Father {//父亲类
            String big_name = "我是爸爸";//父类成员变量
            public void big_bed(){//未重写的方法,父亲的床
                System.out.println("父亲的大床");
            }
            public void car(){//重写的方法，原始车
                System.out.println("原始车");
            }
    }

子类

package bao;
    public class Son extends Father{
        String xiao_name = "我是儿子";//子类成员变量
        public  void xiao_bed(){    //未重写的方法
            System.out.println("儿子的小床");
        }
        @Override
        public void car() {//重写的方法
            System.out.println("改装车");
            super.car();
        }
    }
    //重写快捷键,父类方法名car+回车键

测试对象

package bao;
    public class Test {
        public static void main(String[] args) {
            //两边纯父类证明
            Father f = new Father();
            System.out.println(f.big_name);//父类成员方法，我是爸爸
            f.big_bed();//父类成员方法，父亲的大床
            f.car();//父类成员方法,原始车
    
            //两边纯子类证明
            Son s = new Son();
            System.out.println(s.big_name);//继承：父类成员变量，我是爸爸
            System.out.println(s.xiao_name);//子类成员变量，我是儿子
            s.big_bed();//继承：父类成员方法：父亲的大床
            s.xiao_bed();//子类方法,儿子的小床
            s.car();//继承后重写父类车，父类成员方法，改装车，原始车   注释：重写后一般产生两个，重写前和重写后
    
            //两边混合，实例化看左边父类
            Father ff = new Son();
            System.out.println(ff.big_name);//父类成员变量，我是爸爸
            ff.big_bed();//父类成员方法，父亲的大床
            ff.car();//重写父类车，父类成员方法，改装车，原始车   注释：重写后一般产生两个，重写前和重写后
        }
    }
    //注释：出现两个一模一样的变量或者方法名字，优先使用本类的（左边）

运行结果

> 我是爸爸  
> 父亲的大床  
> 原始车  
> 我是爸爸  
> 我是儿子  
> 父亲的大床  
> 儿子的小床  
> 改装车  
> 原始车  
> 我是爸爸  
> 父亲的大床  
> 改装车  
> 原始车

直白解释：多态就是还是按照继承一样，无非就是多态喜欢调用很多不同的类来丰富自己。特别注意一点就是混合类语法，那个是通过了重写渗透改变了父类方法，让父类也只能使用被重写后的那个方法。多态里面要特别注意重写，不同类之间，出现相同的名称就是出现了重写，要检查重写后的方法有哪些，要特别注意就好。

[-CSDN]: https://blog.csdn.net/m0_52861000/article/details/128148568?spm=1001.2014.3001.5502
[9defe7f335dc4bd69b1d2a12d9ea9f1c.png]: https://img-blog.csdnimg.cn/9defe7f335dc4bd69b1d2a12d9ea9f1c.png