Java多态(如果想知道Java中有关多多态的知识点,那么只看这一篇就足够了!)

简介: Java多态(如果想知道Java中有关多多态的知识点,那么只看这一篇就足够了!)

为了更好地理解多态,我们需要掌握以下核心概念:(先进行了解即可)

  1. 方法重写(Override): 子类可以提供对父类中已有方法的新实现。在子类中重新定义一个与父类中方法名、参数列表和返回类型相同的方法,从而覆盖(重写)了父类中的方法。
    向上转型(Upcasting): 可以将子类的对象引用赋给父类类型的变量,这被称为向上转型。这样做可以让我们在父类引用上调用子类的方法,从而实现多态性。
    动态绑定(Dynamic Binding): 运行时多态性的关键概念之一。它意味着方法的调用是在程序运行时根据对象的实际类型来确定的,而不是在编译时。
    instanceof 运算符: 用于检查一个对象是否是特定类的实例。它可以帮助我们在运行时确定对象的类型,从而进行适当的操作。

为了理解学习多态,让我们先学习一下这些核心知识,接下来我们将一一学习它们。

1.向上转型+向下转型

       先来让我们认识一下什么是向上转型和向下转型。

       (1)向上转型

       向上转型(Upcasting): 将子类的对象引用赋给父类类型的变量,这被称为向上转型。其作用为可以让我们在父类引用上调用子类的方法,从而实现多态性。

了解完了什么是向上转型之后,让我们看一个向上转型的例子来进一步理解:

//父类Animal
class Animal {
    void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
//子类Dog
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}
 
public class Test {
    public static void main(String[] args) {
        // 创建一个Dog对象
        Dog myDog = new Dog();
 
        // 向上转型:将Dog对象赋值给Animal引用
        Animal myAnimal = myDog; // 这就是向上转型
    }
}

       在这个例子中,我们有一个Animal类和一个Dog类,其中Dog是Animal的子类。在main方法中,我们创建了一个Dog对象,并将其赋值给一个Animal类型的引用myAnimal,这就是向上转型的一个例子。

了解了什么是向上转型之后,在让我们看一下什么是向下转型。

       

       (2)向下转型

        向下转型(downcasting):将一个子类对象经过向上转型之后当成父类方法使用,再无法调用子类的方法,但有时候可能需要调用子类特有的方法,此时,将父类引用再还原为子类对象即可,即向下转换。

了解了什么是向下转型,现在让我们使用一个向下转型的例子来进一步理解(还是继续使用上面的案例):

//父类Animal
class Animal {
    void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
//子类Dog
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}
 
public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal myAnimal = new Dog();
 
        // 检查myAnimal是否真的是Dog的一个实例  
        if (myAnimal instanceof Dog) {
            // 向下转型:将Animal引用转换为Dog引用  
            Dog myDog = (Dog) myAnimal; // 这就是向下转型  
        } else {
            //如果不是Dog类
            System.out.println("myAnimal is not a Dog");
        }
    }
}

       在这个例子中,我们首先创建了一个Dog对象,并将其赋值给了一个Animal类型的引用myAnimal。然后,我们使用instanceof操作符来检查myAnimal是否真的是Dog的一个实例。如果是,我们就可以安全地进行向下转型,将myAnimal转换为Dog类型的引用myDog,如果不是,则返回 “myAnimal is not a Dog”

补充:instanceof

       在这个案例中我们看到出现了一个关键词instanceof,那么instanceof的作用是什么呢?

目前我们可以理解instanceof的作用为:

       instanceof是一个运算符,其用于测试对象是否是一个类的实例。

instanceof使用的语法形式为:

if (object instanceof Class) {
    // object 是 Class 类型或其子类的实例
}

这样我们就大致的了解了什么是向上转型和向下转型了。

2.方法重写

       方法重写是Java多态中的核心步骤之一,那么什么是方法重写呢?

       方法重写(Override): 即子类可以提供对父类中已有方法的新实现。在子类中重新定义一个与父类中方法名、参数列表和返回类型相同的方法,从而覆盖(重写)了父类中的方法。

       嗯嗯嗯......看是大致看懂了,但是还是不是太理解,接下来我们使用实例来帮助你进一步理解什么是方法重写(继续使用上面的案例):

//父类Animal
class Animal {
    void makeSound(String name) {
        System.out.println("The animal makes a sound");
    }
}
//子类Dog
class Dog extends Animal {
    
    //对父类的方法重写
    @Override
    void makeSound(String name) {
        System.out.println("The dog barks");
    }
}

       我们可以看到子类Dog继承了其父类Animal,并且也创建了一个同父类中的makeSound()方法相同的方法,只不过内部的实现有所区别,这就是方法的重写。

       注意: 子类在重写父类的方法时,一般必须与父类方法原型一致: 即返回值类型,方法名,参数列表要完全一致(如图):

当然,对于Java中的方法重写,还有许多需要注意的事项:

1. 被重写的方法返回值类型可以不同,但是必须是具有父子关系;

2. 子类的访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类方法被public修饰,则子类中重写该方法就不能声明为 protected;

3. 父类被static、private修饰的方法、构造方法都不能被重写;

4. 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.;

这样我们就大致的了解了什么是方法重写了。

3.静态绑定+动态绑定

       讲到多态时,我们都会提及静态绑定和动态绑定,那么什么是静态绑定、动态绑定呢?

       (1)静态绑定

       静态绑定:也称为前期绑定(早绑定),即在编译时,根据用户所传递实参类型就确定了具体调用那个方法。

其中最常见的例子就是方法的重载(例如):

// 第一个重载方法,没有参数
    public void display() {
        System.out.println("No parameters passed.");
    }
 
    // 第三个重载方法,接受一个字符串参数
    public void display(String message) {
        System.out.println("A string parameter: " + message);
    }
 
    // 第三个重载方法,接受两个整数参数
    public void display(int num1, int num2) {
        System.out.println("Two integer parameters: " + num1 + " and " + num2);
    }

在调用这些方法的时候,我们可以在编译的时候就知道调用的是哪一个方法(因为它们的参数不同),这就是静态绑定。

       (2)动态绑定

       动态绑定:也称为后期绑定(晚绑定),即在编译时,不能确定方法的行为,需要等到程序运行时,才能够确定具体调用那个类的方法。

其中最常见的例子就是多态中的方法的调用,这里先不进行讲解,下文合适时会提及。

这样我们就大致的了解了什么是静态绑定和动态绑定了。

4.多态

       铺垫了这么多的知识,终于到了本文最重要,最核心的知识了——什么是Java中的多态?

先让我们了解一下多态的定义:

       多态(Polymorphism)是面向对象编程的核心概念之一。它源于希腊语,意为“多种形态”。多态性使得我们可以使用通用的接口来表示不同的对象,并且能够在运行时确定对象的具体类型,从而调用相应的方法。

鹅鹅鹅......没看懂,那么我们接下来使用更加平易近人的方式来描述一下什么是多态:

       通俗来说,多态就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。

为了更好的使你了解什么是多态,我们使用一个案例进行讲解(每一步都有详解):

// 定义一个基类(父类)
class Animal {
    void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
// 定义一个派生类(子类),继承自Animal类
class Dog extends Animal {
    // 重写父类的方法
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}
// 另一个派生类(子类),也继承自Animal类
class Cat extends Animal {
    // 重写父类的方法
    @Override
    void makeSound() {
        System.out.println("The cat meows");
    }
}
 
// 主类,用于演示多态
public class Test {
    public static void main(String[] args) {
        //创建两个对象,一个为Dog类,一个为Cat类
        Animal animalDog = new Dog();
        Animal animalCat = new Cat();
 
        //分别调用makeSound方法
        animalDog.makeSound();
        animalCat.makeSound();
    }
}

当你运行这个Test方法时,你会看到控制台输出了以下结果:

       通过这个案例,我们就知道了Java中多态是如何工作的,我们尽管都是调用了父类(Animal)的makeSound方法,但是最终调用的为其子类中对其重写的方法,这就是所谓的Java中的多态。

不知道你是否还记得上文中提及的动态绑定,这也是一个动态绑定的例子:

       动态绑定:也称为后期绑定(晚绑定),即在编译时,不能确定方法的行为,需要等到程序运行时,才能够确定具体调用那个类的方法。

       我们在编译的时候,都是调用的其父类的makeSound方法,这就是在编译时,不能确定方法的行为,但是当我们运行后,其就会调用特定对象中的方法,,即需要等到程序运行时,才能够确定具体调用那个类的方法。

       ——了解了Java中的多态之后,那么为什么要使用多态呢?

多态的优点:

  1. 代码重用: 可以使用通用的接口来操作不同类型的对象,从而减少了代码的重复编写。
  2. 灵活性: 可以轻松地扩展程序,添加新的子类而无需修改现有的代码。
  3. 可维护性: 通过多态,我们可以将代码组织得更加清晰和易于维护。
  4. 简化接口: 多态性允许我们使用通用接口,而不必关心对象的具体类型。
  5. 提高代码的可读性: 代码更易于理解,因为它更符合现实世界的模型。

当然多态在日常生活中也有许多的实际用处,只不过我们需要将其转换为代码的形式而已,例如:

  1. 图形绘制: 图形绘制程序可以使用多态性来处理不同类型的图形对象,如圆形、矩形和三角形。
  2. 汽车制造: 汽车制造公司可以使用多态性来处理不同型号和品牌的汽车,从而简化生产流程。
  3. 动态插件: 软件应用程序可以使用多态性来支持动态加载和卸载插件,从而增加灵活性。
  4. 电子商务: 电子商务平台可以使用多态性来处理不同类型的商品和付款方式。
  5. 游戏开发: 游戏开发中的角色和道具可以使用多态性来实现不同的行为。

这样我们就了解了什么是java中的多态了。

相关文章
|
3天前
|
Java 开发者
【Java探索之旅】初识多态_概念_实现条件
【Java探索之旅】初识多态_概念_实现条件
28 16
|
9天前
|
Java 数据安全/隐私保护
Java中的类继承与多态详解
Java中的类继承与多态详解
|
11天前
|
Java
Java面向对象 ( 多态 | final关键字 | 接口 )
Java面向对象 ( 多态 | final关键字 | 接口 )
|
18天前
|
安全 Java
深度解读Java的继承和多态的特性
深度解读Java的继承和多态的特性
|
2天前
|
Java
Java面试题:什么是多态以及在Java中如何实现?请详细解释说明
Java面试题:什么是多态以及在Java中如何实现?请详细解释说明
7 0
|
2天前
|
存储 并行计算 安全
Java面试题:Java内存管理、多线程与并发框架的面试题解析与知识点梳理,深入Java内存模型与垃圾回收机制,Java多线程机制与线程安全,Java并发工具包与框架的应用
Java面试题:Java内存管理、多线程与并发框架的面试题解析与知识点梳理,深入Java内存模型与垃圾回收机制,Java多线程机制与线程安全,Java并发工具包与框架的应用
9 0
|
2天前
|
存储 算法 安全
Java面试题:Java内存模型及相关知识点深度解析,Java虚拟机的内存结构及各部分作用,详解Java的垃圾回收机制,谈谈你对Java内存溢出(OutOfMemoryError)的理解?
Java面试题:Java内存模型及相关知识点深度解析,Java虚拟机的内存结构及各部分作用,详解Java的垃圾回收机制,谈谈你对Java内存溢出(OutOfMemoryError)的理解?
10 0
|
2天前
|
Java
Java面试题:Java内存模型与并发编程知识点,解释Java中“happens-before”的关系,分析Java中的内存一致性效应(Memory Consistency Effects)及其重要性
Java面试题:Java内存模型与并发编程知识点,解释Java中“happens-before”的关系,分析Java中的内存一致性效应(Memory Consistency Effects)及其重要性
8 0
|
3天前
|
安全 Java 程序员
【Java探索之旅】多态:向上下转型、多态优缺点、构造函数陷阱
【Java探索之旅】多态:向上下转型、多态优缺点、构造函数陷阱
8 0
|
3天前
|
搜索推荐 Java 编译器
【Java探索之旅】多态:重写、动静态绑定
【Java探索之旅】多态:重写、动静态绑定
8 0