面向对象——多态

最新推荐文章于 2022-10-16 23:47:37 发布
最新推荐文章于 2022-10-16 23:47:37 发布
阅读量1k 收藏 3
点赞数
分类专栏： ▬▬▬▬▬【Java入门】 Java语言编程基础 文章标签： Java基础入门
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yerenyuan_pku/article/details/53675913
版权

多态

多态定义

多态：可以理解为事物存在的多种体现形态。
例如：

人：男人，女人
动物：猫，狗

猫这个对象对应的类型是猫类型：猫 x = new 猫();，同时猫也是动物中的一种，也可以把猫称为动物：动物 x = new 猫();。动物是猫和狗等具体事物中抽取出来的父类型。
本文从以下几个方面介绍多态：

  1. 多态的体现——父类的引用指向了自己的子类对象。即父类的引用也可以接收自己的子类对象
  2. 多态的前提——必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提：存在覆盖
  3. 多态的好处——多态的出现大大的提高了程序的扩展性
  4. 多态的弊端——提高了扩展性，但是只能使用父类的引用访问父类中的成员，不能预先使用子类，因为那时子类还没存在
  5. 多态的应用
  6. 多态的出现在代码中的特点（多态使用的注意事项）

以动物：猫，狗，猪为例说之。

abstract class Animal {
    public abstract void eat();
}
class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }

    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}
class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void kanJia() {
        System.out.println("看家");
    }
}
class Pig extends Animal {
    public void eat() {
        System.out.println("饲料");
    }
    public void gongDi() {
        System.out.println("拱地");
    }
}

那么以下代码：

Animal a = new Cat(); // 类型提升，向上转型
a.eat();

如果想要调用猫的特有方法时，如何操作？——强制将父类的引用转成子类类型，向下转型，即：

Cat c = (Cat)a;
c.catchMouse();

千万不要出现这样的操作，就是将父类对象转成子类类型，即：

Animal a = new Animal();
Cat c = (Cat)a;

我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。多态自始至终都是子类对象在做着变化。

instanceof关键字的使用

当我们使用向下转型时，确实是可以带来好处，即可以使用子类的特有功能。但是也会带来弊端——必须得面对具体的子类型。这即是说向下转型有风险，容易发生ClassCastException，只要转换类型和对象类型不匹配就会发生，想要安全，必须要进行判断，判断一个对象是否匹配某一个类型，这时我们就需要使用一个新的关键字——instanceof了，instanceof的用法为：对象 instanceof 类型。我们举例说明：

class DuoTaiDemo2 {
    public static void main(String[] args) {
        function(new Dog());    
        function(new Cat());
    }

    public static void function(Animal a) {
        a.eat();
        if(a instanceof Cat) {
            Cat c = (Cat)a;
            c.catchMouse();
        } else if(a instanceof Dog) {
            Dog d = (Dog)a;
            d.kanJia();
        }   
    }
}

多态特点

  • 在多态中，成员变量的特点：当子父类中出现同名变量时，多态调用时，只看调用该成员变量的引用所属的类中的成员变量。简单说：无论编译还是运行，都看等号(=)的左边(引用型变量所属的类)。
    明白了在多态中成员变量的特点之后，试着看以下代码的运行结果：

    class Fu
{
    int num = 5;
    void show()
    {
        System.out.println("num = " + this.num); // 打印num = 5
    }
}

class Zi extends Fu
{
    int num = 6;
}

class DuoTaiTest2 
{
    public static void main(String[] args) 
    {
        Fu f = new Zi();
        f.show();
    }
}

    很显然打印的是num = 5，为什么会这样呢？一图以蔽之：
    这里写图片描述

  • 在多态中成员函数(非静态)的特点：出现一模一样函数时，多态调用，在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败。在运行时期，参阅对象所属的类中是否有调用的方法。简单总结就是：成员函数(非静态)在多态调用时，编译看左边，运行看右边。
    在一些专业书上也有这样的表述：成员方法动态绑定到当前对象上。
  • 在多态中，静态成员函数(或者静态成员变量)的特点：出现一模一样函数时，多态调用，无论编译和运行，都参考左边（引用型变量所属的类）。其实我们要知道，真正调用静态方法是不需要对象的，直接类名调用。因为静态方法绑定到类上，所以这种情况更多用于面试中。

多态应用

例1，基础班学生：学习，睡觉；高级班学生：学习，睡觉。可以将这两类事物进行抽取。

abstract class Student {
    public abstract void study();
    public void sleep() {
        System.out.println("躺着睡");
    }
}

// 工具类
class DoStudent {
    public void doSomething(Student stu) {
        stu.study();
        stu.sleep();
    }
}

class BaseStudent extends Student {
    public void study() {
        System.out.println("base study");
    }
    public void sleep() {
        System.out.println("坐着睡");
    }
}
class AdvStudent extends Student {
    public void study() {
        System.out.println("adv study");
    }
}
class DuoTaiDemo {
    public static void main(String[] args) {
        DoStudent ds = new DoStudent();
        ds.doSomething(new BaseStudent());
        ds.doSomething(new AdvStudent());
    }
}

例2，需求：电脑运行示例，电脑运行基于主板。

// 接口定义规则
interface PCI {
    public void open();
    public void close();
}
class MainBoard {
    public void run() {
        System.out.println("mainboard run");
    }
    public void usePCI(PCI p) { // PCI p = new NetCard(); // 接口型引用指向自己的子类对象
        if(p != null) {
            p.open();
            p.close();
        }
    }
}
class NetCard implements PCI {
    public void open() {
        System.out.println("netcard open");
    }
    public void close() {
        System.out.println("netcard close");
    }
}
class SoundCard implements PCI {
    public void open() {
        System.out.println("soundcard open");
    }
    public void close() {
        System.out.println("soundcard close");
    }
}
class DuoTaiDemo {
    public static void main(String[] args) {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(null);
        mb.usePCI(new NetCard());
        mb.usePCI(new SoundCard());
    }
}

示意图：
这里写图片描述
例3，数据库的操作。数据是：用户信息。

  1. 连接数据库(JDBC Hibernate)
  2. 操作数据库(CRUD)——C creat R read U update D delete
  3. 关闭数据库连接
interface UserInfoDao {
    public void add(User user);
    public void delete(User user);
}
class UserInfoByJDBC implements UserInfoDao {
    public void add(User user) {
        1、JDBC连接数据库
        2、使用sql添加语句添加数据
        3、关闭连接
    }
    public void delete(User user) {
        1、JDBC连接数据库
        2、使用sql删除语句删除数据
        3、关闭连接
    }
}
class UserInfoByHibernate implements UserInfoDao {
    public void add(User user) {
        1、Hibernate连接数据库
        2、使用sql添加语句添加数据
        3、关闭连接
    }
    public void delete(User user) {
        1、Hibernate连接数据库
        2、使用sql删除语句删除数据
        3、关闭连接
    }
}

class DBOperate {
    public static void main(String[] args) {
        UserInfoDao ui = new UserInfoByHibernate();
        ui.add(user);
        ui.delete(user);
    }
}

示意图如下：
这里写图片描述

Object类

Object是所有对象的直接或者间接父类，传说中的上帝。该类中定义的肯定是所有对象都具备的功能。
Object类中已经提供了对对象是否相同的比较方法，如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有比较内容即可，这就是覆盖。
例，假如有一个Person类，其代码为：

class Person extends Object
{
    private int age;
    private String name;

    Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
}

现在我们的需求是：定义一个方法，判断两个Person对象是否是同一个，判断的依据是根据姓名和年龄，如果姓名和年龄都相同，视为同一个人。
我的分析：不用再自定义方法判断对象是否相同了，因为在Object父类中，已经定义了这样的方法，直接使用就可以了，但是判断的内容是根据Person的特点定义的，那就需要保留父类的功能声明，定义子类功能的特有内容，使用覆盖。所以要在Person类中加入如下equals方法：

public boolean equals(Object obj) // Object obj = p2;--->Object obj = new Person();
{
    // 提高点效率。如果两个引用指向了同一个对象，就不用再转换并比较内容了，直接判断地址就哦了。
    if (this == obj)
        return true;

    // obj.age是错误的，因为Object中没有age属性，
    // 想要使用子类对象的特有属性或行为，必须对其进行向下转型，并且需要进行类型判断
    if (!(obj instanceof Person))
    {
        // return false; 
        throw new ClassCastException("类型错误");
    }
    Person p = (Person)obj;
    // 如果判断姓名字符串是否相同，不要用==，字符串本身是一个对象，所以要使用String类的equals方法
    return this.name.equals(p.name) && this.age == p.age;
}

有时候，我们还需要重写Object类的toString()方法，建立Person对象特有的字符串表现形式。查询API帮助文档，我们可以发现：Object类的toString方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：getClass().getName() + '@' + Integer.toHexString(hashCode())。如果我们不在Person类中重写该方法，运行以下程序：

class ObjectDemo 
{
    public static void main(String[] args) 
    {
        Person p1 = new Person("lisi", 21);
        Person p2 = new Person("mazi", 25);

        System.out.println(p1); // Person@139a55，打印对象时，默认调用toString()方法
        System.out.println(p1.toString());
    }
}

则会输出Person@139a55，而且在打印对象时，默认调用了toString()方法。

  • 顺便说一下，如果要我们自己来弄，输出Person@139a55这样的东西，又该怎么做呢？
    这时，我们就要接触一点点反射的知识了，关于反射的知识以后会另开一篇专讲。A.class，B.class这些class文件都有名称，这些文件内都有构造函数，一般方法，java中用Class来描述这些class文件，可通过getName()获取名称。所以以下代码：

    Person p1 = new Person("lisi", 21);
Class c = p1.getClass();
System.out.println(c.getName()); // Person

    会输出Person。
    现在我们就可以自己来编写了，代码如下：

    Person p1 = new Person("lisi", 21);
Class c = p1.getClass();
System.out.println(c.getName()+"@@"+Integer.toHexString(p1.hashCode()));

    这时就会输出Person@@139a55这样的东西了。

说完toString()方法，我们须在Person类中重写该方法，所以应在Person类中添加如下toString()方法：

/**
建立Person对象特有的字符串表现形式，只要覆盖toString方法即可
*/
public String toString()
{
    return "Person[name = " + this.name +", age = " + this.age + "]";
}

这样，测试类的代码可这样写为：

class ObjectDemo 
{
    public static void main(String[] args) 
    {
        Person p1 = new Person("lisi", 21);
        Person p2 = new Person("mazi", 25);

        System.out.println(p1.equals(p2)); // 判断的是对象的内容，用equals。
        System.out.println(p1 == p2); // 判断的是对象的地址
    }
}

内部类

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。例如，A类要直接访问B类中的成员时，可以将A类直接定义到B类中，作为B类的内部类存在。
内部类的访问规则：

  • 内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类中的引用，格式：外部类名.this。用一个例子来验证：

    class Outer
{
    int num = 2;

    class Inner
    {
        int num = 3;

        void show()
        {
            int num = 4;
            System.out.println("show..." + Outer.this.num);
        }
    }

    public void method()
    {
        new Inner().show();
    }
}
class InnerClassDemo2 
{
    public static void main(String[] args) 
    {
        new Outer().method();
    }
}

  • 外部类要想访问内部类，只能创建内部类的对象来访问。

访问格式：

  • 非静态，非私有的内部类访问方式
    当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，可以直接建立内部类对象。格式为：外部类名.内部类名 变量名 = 外部类对象.内部类对象;，例，Outer.Inner in = new Outer().new Inner();示例代码如下：

    class Outer
{
    private int num = 4;
    class Inner // 内部类，相当于外部类中的一个成员，它就可以被成员修饰符所修饰，public private static
    {
        void show()
        {
            System.out.println(num);
        }
    }
}
class InnerClassDemo
{
    public static void main(String[] args) 
    {
        Outer.Inner in = new Outer().new Inner();
        in.show();
    }
}

    而且在非静态内部类中只允许定义静态的常量，存于常量池中，不能定义其他静态成员。所以，以下代码编译是没有任何问题的：

    class Outer
{
    private int num = 4;
    class Inner // 内部类，相当于外部类中的一个成员，它就可以被成员修饰符所修饰，public private static
    {
        static final int count = 5; // 在非静态内部类中只允许定义静态的常量，存于常量池中，不能定义其他静态成员
        void show()
        {
            System.out.println(num);
        }
    }
}
class InnerClassDemo
{
    public static void main(String[] args) 
    {
        Outer.Inner in = new Outer().new Inner();
        in.show();
    }
}

  • 静态，非私有的内部类访问方式，访问非静态成员
    当内部类在成员位置上时，就可以被成员修饰符修饰，比如，private将内部类在外部类中进行封装，static内部类就具备static的特性。当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。
    在外部其他类中，如何直接访问静态内部类非静态成员呢？答案是格式为new Outer.Inner().function();。示例代码如下：

    class Outer
{
    private static int num = 4;
    class Inner // 内部类，相当于外部类中的一个成员，它就可以被成员修饰符所修饰，public private static
    {
        void show()
        {
            System.out.println(num);
        }
    }

    static class Inner2 // 静态内部类，相当于一个外部类
    {
        void show2()
        {
            System.out.println("show2..." + num);
        }
    }

}
class InnerClassDemo
{
    public static void main(String[] args) 
    {
        Outer.Inner2 in = new Outer.Inner2();
        in.show2();
    }
}

  • 静态，非私有的内部类访问方式，访问静态成员
    在外部其他类中，如何直接访问静态内部类静态成员呢？答案是格式为Outer.Inner.function();。示例代码如下：

    class Outer
{
    private static int num = 4;
    class Inner // 内部类，相当于外部类中的一个成员，它就可以被成员修饰符所修饰，public private static
    {
        void show()
        {
            System.out.println(num);
        }
    }

    static class Inner2 // 静态内部类，相当于一个外部类
    {
        void show2()
        {
            System.out.println("show2..." + num);
        }

        static void show3()
        {
            System.out.println("show3..." + num);
        }
    }

}
class InnerClassDemo
{
    public static void main(String[] args) 
    {
        Outer.Inner2.show3();
    }
}

注意：当内部类中定义了静态成员，该内部类必须是static的。当外部类中的静态方法访问内部类时，内部类也必须是static的。

class Outer {
    private static int x = 3;
    static class Inner { // 静态内部类
        static void function() { // 当内部类中定义了静态成员，该内部类必须是static的
            System.out.println("inner::::"+x); // 当内部类被static修饰后，只能直接访问外部类中的static成员
        }
    }
    static class Inner2 {
        void show() {
            System.out.println("inner2 show");
        }
    }
    public static void method() {
        new Inner2().show(); // 当外部类中的静态方法访问内部类时，内部类也必须是static的
    }
}

内部类定义在局部时

  1. 不可以被成员修饰符修饰，因为private、static不能修饰局部成员。

  2. 可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量，主要原因是生命周期不同。注意：java8没这个区别了，但是被final修饰的变量是一个常量，只能被赋值一次，所以一经存在就不得更改。
    例，以下是java8的运行环境。

    class Outer {
    int x = 3;
    void method(int a) {
        // a++; // 从内部类引用的本地变量必须是最终变量或实际上的最终变量
        int y = 4;
        class Inner {
            void function() {
                System.out.println(a);
            }
        }
        new Inner().function();
    }
}
class InnerClassDemo {
    public static void main(String[] args) {
        Outer out = new Outer();
        out.method(7);
        out.method(8);
    }
}

为了能说明局部内部类只能访问被final修饰的局部变量，而且其主要原因是生命周期不同这一点，我们举例验证。

class Outer
{
    private int num = 4;
    Object obj;
    public void method()
    {
        /*final*/ int x = 5;
        class Inner extends Object // Inner本身继承Object
        {
            // 覆盖Object类中的toString()方法
            public String toString()
            {
                System.out.println("x = " + 5);
                System.out.println("show..." + num);
                return "Inner...abc";
            }
        }
        // 创建内部类的对象
        Inner in = new Inner();
        // 将内部类对象的地址赋值给obj
        obj = in;
    }

    public void function()
    {
        // 打印obj指向的对象的字符串表现形式
        System.out.println(obj.toString());
    }
}


class InnerClassDemo2 
{
    public static void main(String[] args) 
    {
        new Outer().method();
    }
}

以上例子在JVM内存中的示意图大概是这样的：
这里写图片描述

匿名内部类

  1. 匿名内部类其实就是内部类的简写格式。
  2. 定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
  3. 匿名内部类的格式：new 父类或者接口() {定义子类的内容}。
  4. 匿名内部类其实就是一个匿名子类对象，而且这个对象有点胖。可以理解为带内容的对象。

  5. 匿名内部类中定义的方法最后不要超过3个。
    例，

    abstract class AbsDemo {
    abstract void show();
}

class Outer {
    int x = 3;
    public void function() {
        AbsDemo d = new AbsDemo() {
            int num = 9;
            void show() {
                System.out.println("num==="+num);
            }
            void abc() {
                System.out.println("haha");
            }
        };
        d.show();
        // d.abc(); // 编译失败，因为父类中没有这个方法
    }
}

练习一：补全代码，通过匿名内部类。

interface Inter {
    void method();
}
class Test {
    // 补足代码。通过匿名内部类

}
class InnerClassTest {
    public static void main(String[] args) {
        Test.function().method();
    }
}

解：

interface Inter {
    void method();
}
class Test {
    // 补足代码。通过匿名内部类
    static Inter function() {
        return new Inter() {
            public void method() {
                System.out.println("Inter method");
            }
        };
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        // Test.function()：Test类中有一个静态的方法function
        // .method()：function这个方法运算后的结果是一个对象，而且是一个Inter类型的对象，
        // 因为只有是Inter类型的对象，才可以调用method()
        Test.function().method();
    }
}

面试时可能遇到的一个小问题（有关匿名内部类的），如果没有一个类继承或一个接口实现，还能使用匿名内部类吗？答案是可以的。

class InnerTest {

    public static void main(String[] args) {
        new Object() { // new Object() {}是Object类的子类对象
            public void function() {
                System.out.println("hello");
            }
        }.function();
    }
}
李阿昀
关注
专栏目录
面向对象之多态
zhouym_的博客
04-20 3984
面向对象之多态 先给大家讲个笑话 多态的引入： 生活中的多态 在生活中我们听到“打”一声可能只是 击，敲，攻击的意思，但是其实在不同的环境下，打的意思非常多。 例如：打车，打电话，打雷，打证明，打包裹 多态的概述 生活中: 同一个动作在不同环境下表现出来的不同状态 Java中: 同一个方法在不同的对象中体现出来不同的状态 内存中: 父类引用指向子类对象 多态的实现的必要条件:(重点要记下) 1....
面向对象--多态
简之恨寒的博客
08-08 314
是指同一行为，具有多个不同表现形式。面向对象的三大特性，为封装、继承、多态。个人认为，继承是三大特性的核心。封装是将代码进行整合，封装后增加代码的聚合度；继承是建立了类与类之间的关系，建立了耦合度；多态是通过重写方式实现不同效果的展示，降低了耦合度。三大特性是一个整体，虽然可以独立使用，但是相互配合，整合起来的代码，更有优势和效果，真正的去实现了代码的高内聚，低耦合。...
OC面向对象—多态
weixin_33979203的博客
05-03 305
  OC面向对象—多态 一、基本概念 多态在代码中的体现，即为多种形态，必须要有继承，没有继承就没有多态。 在使用多态是，会进行动态检测，以调用真实的对象方法。 多态在代码中的体现即父类指针指向子类对象。 Animal类的声明   Animal类的实现   Dog类继承自Animal类   Dog类的实现   测试程序：     二、使用注意 代码分析： Do...
多态学习，final修饰符
qq_48785525的博客
11-25 188
多态 概述 ​ 多态是继封装性，继承性之后，面向对象的第三大特性。 定义 ​ 多态：是指同一行为，具有多个不同的表现形式。 ​ 生活中，比如跑的动作，猫，狗，大象跑起来的动作都是不一样的，再比如飞的动作，昆虫、鸟类、人造飞机，飞起来的动作内容都是不一样的。可见，同一行为，通过不同的事物，可以表现出不同的形态。多态，描述的就是这样的一种状态。 前提 ​ 继承或者实现【二选其一】 ​ 父类的引用指向子类的对象 【格式体现】 ​
面向对象——多态实验报告.doc
12-11
面向对象编程是Java的核心特性之一，它通过封装、继承和多态等概念来构建复杂的软件系统。本实验报告主要探讨了多态性这一关键概念，通过设计一系列类及其子类来实现具体的功能。 首先，实验设计了一个名为`Person`...
面向对象编程——多态
m0_68989458的博客
05-01 1036
面向对象编程——多态
Java面向对象——多态
peiwen_java的博客
03-31 545
1、宠物饿了，需要主人给宠物喂食 ---- 不同宠物吃的东西不一样 ---- 不同宠物恢复后体力值不一样 ---- 狗狗类 增加狗狗吃东西的方法 ---- 企鹅类 增加企鹅吃东西的方法 ---- 创建主人类 编写给狗狗喂东西的方法 编写给企鹅喂东西的方法 ---- 编写测试方法 调用主人类给狗狗喂东西的方法 调用主人类给企鹅喂东西的方法 2、如果再领养XXX宠物，就需要给XXX喂食，怎么办？ ---- 添加XXX类，继承Pet类，实现吃食方法 ---- 修改Person类，添加
24、Java面向对象——多态、多态的使用、多态中的转型、instanceof运算符
最新发布
CSDN_Loveletter的博客
10-16 433
目录 课前先导 一、多态 1、定义 2、多态的前提和体现 3、多态中成员访问特点 二、多态的使用 1、代码演示 2、多态的优缺点 三、多态中的转型 1、向上转型 2、向下转型 四、instanceof运算符 1、instanceof运算符的作用 ​编辑2、instanceof运算符使用注意事项 3、instanceof运算符效果展现 五、多态的特点（优势）
面向对象-----多态
qq_46652775的博客
12-18 5820
1、多态的概念 （1）多态是面向对象的一个重要特征，指同一类事物同时具有多种形态，即同一类事物，在不同时刻，代表的对象不一样，指的是对象的多种形态。比如，对于笔记本电脑，它可以是苹果笔记本、华硕笔记本、弘基笔记本、神州笔记本。 （2）多态就是同一个行为具有多个不同表现形式或形态的能力，指的就是行为的多态。比如鸟类的飞行行为,鸽子,燕子,老鹰它们各自的飞行方式是不同的，再比如动物都有吃这个功能，但是它们吃的食物是不同的,老虎吃肉,牛吃草,猫吃猫粮,狗吃狗粮。 （3）多态就是同一个接口...
面向对象-多态
itzhuzhu的博客
09-29 334
目录： 什么是多态？ 多态的形式 使用多态有什么前提？ 多态的好处 引用类型转换 1.什么是多态？ 是指同一行为，具有多个不同表现形式 2.多态的形式： -多态是除封装、继承之后面向对象的第三大特征。 -多态是出现在继承或者实现关系中的 多态体现的格式： 父类类型 变量名 = new 子类/实现类构造器; 变量名.方法名(); 3.使用多态有什么前提？ 多态的前提：有继承关系，子类对象...
面向对象 — 多态
m0_61410724的博客
06-12 1921
多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的。多态的前提是：1.继承。2.重写。多态的具体体现为：1.方法的多态（重写和重载就体现多态）。2.对象的多态。（1）本质：父类的引用指向了子类的对象。（2）语法：父类类型 引用名 = new 子类类型();（3）特点：编译类型看左边，运行类型看右边，可以调用父类类型中的所有成员（需要遵守
面向对象 多态
guohao326的博客
09-28 220
面向对象的多态性： 是指在父类中定义的属性或行为被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在父类及各个子类中具有不同的语义。 on1.php<?php interface USB{ public function run(); } ?> key.php <?php include_once('./on1.php'); class key i
面向对象多态
chuqiao6658的博客
03-10 142
super super的引入：提出疑问 为什么子类构造方法执行时，会输出父类构造方法的输出语句 super概念+比较this this的概念：this表示当前对象，持有当前对象的地址 super的概念：在子类中表示父类的对象 区别this：s...
Java万物之根：Object类与面向对象继承多态
在Java编程中，"一切类的“祖先”——Object" 是一个核心概念，它阐述了面向对象编程语言的基础特性。Object 类是所有Java类的根类，无论它们多么复杂或具体，都间接地从Object派生。在Java中，类的定义通常采用继承...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李阿昀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值