学习Java中的多态性

DebugUsery
138 阅读8分钟

Java中的多态性

Polymorphism 多态性是指一个对象可以有多种形式的能力。在这篇文章中，我们将介绍多态性，并举一些例子来进一步了解多态性。我们将进一步讨论多态性的两种类型，即 和 多态性。此外，我们将看看多态性的优点，最后是多态性的特点。现在让我们来详细了解一下。static dynamic

多态性是指一个对象有不止一种形式。我们也可以说，多态性是一种允许以多种方式执行一项任务的特性。为了更好地理解这一概念，我们将使用下面的例子。

多态性的例子包括。

  • 一个人有一个身体，但在身体内部，有各种器官在执行不同的任务。心脏泵血，胃消化食物，肺用于呼吸，等等。在这个例子中，你可以注意到，人体允许在身体内进行不止一项任务。

  • 另一个例子是人。一个人可以有不同的任务，这取决于他所扮演的角色。他可以是一个家庭中的父亲，扮演父亲的角色。他可以是工作中的老板，同样履行老板的工作。最后，他可以是学习，他为此成为一名学生。从上述情况来看，你可以注意到这个人可以是父亲、老板和学生。这表明这个人可以是多态的。

简介

Java是一种面向对象的编程语言。但OOP通常被称为什么？是的，面向对象编程的四大支柱。

这四大支柱包括。

  • Abstraction - 是向用户隐藏不太重要的功能，而显示仅有的重要功能的过程。这一基本原则使用户了解到一个程序做什么，而不是程序如何做。

  • Inheritance - 是指一个类，通常是子类，继承另一个被称为父类的属性。

  • Encapsulation - 是相关数据被绑定在一起成为一个单元的基本要素。

  • Polymorphism - 理解多态性的最简单方法是有多种形式。我们将在本教程中进一步讨论多态性。

什么是多态性

多态性是一个希腊词，两个词结合起来就有了一个意思。有趣的是，你可以说这个词是多态的。

这两个词是poly 和morph ，其中poly是指许多，morph是指一种或多种形式。

多态性的类型

多态性可以分为两种类型。

1.静态多态性

静态多态是指在编译代码时将函数或方法与对象联系起来。这是在运行代码之前。

为了理解什么是编译时错误和编译时多态性，让我们举一个案例。当你在写一段代码时，可能是在创建一个方法，而你偶然创建了两个或多个同名的方法。你会得到一个警告，说你的代码中有一个重复的方法。

这种错误被称为Compile-time error 。在你的代码中接收错误警报的能力是由编译器实现的。当编译器在有关多态性的问题上解决冲突时，它被视为Compile-time Polymorphism 。

一个例子包括方法重载或函数重载。

为了清楚起见。

Method overloading 是通过拥有多个名称相同但参数不同的方法或拥有不同大小的参数来实现的。参数的不同可以是有不同的参数，有不同类型的数据类型，或者有不同大小的参数。这将避免编译时的错误。

让我们用一个代码片段来了解更多关于静态多态性的信息。

class MyClass {
    int height;

    MyClass() {
        System.out.println("bricks");
        height = 0;
    }
    MyClass(int i) {
        System.out.println("Building new house that is "+i+" feet tall");
        height =i;
    }
    void info() {
        System.out.println("House is "+height+" feet tall");
    }
    void info(String s) {
        System.out.println(s+": House is " +height+ " feet tall");
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass t = new MyClass(10);
        t.info();
        t.info("overloaded method");

        //Overloaded Constructor
        new MyClass();
    }
}

//Output
Building new house that is 10 feet tall
House is 10 feet tall
overloaded method: House is 10 feet tall
bricks

在上面的例子中，你可以看到我们创建了两个方法，它们都有相同的名字MyClass ，但有不同的参数。当第一个类被调用时，它将避免输出所述的字符串，因为没有说明要返回的特定数据类型。

另一方面，第二个类，MyClass，有一个参数是整数。当我们调用它时，输出不仅有打印的输出，而且还能识别出输出中包含的一个整数。这个例子表明，我们可以有多个名称相同但参数不同的方法，这就是所谓的方法重载。

2.动态多态性

动态多态性是一种多态性，当你调用一个重载方法时，这种冲突会在你运行代码时解决，通常称为运行时。它也可以被称为run time polymorphism 。

方法重写是动态多态性的一个例子。

Method overriding 是一种功能，你可以有一个父方法和一个子方法。父方法和子方法都有相同的名字，但子方法会倾向于修改或覆盖父方法。

下面是一个片段，详细解释了这个概念。

class Animal {
    public void sound() {
        System.out.println("Animals make sound");
    }
}
class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Woof");
    }
}
class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
        Animal b = new Dog();
        Animal c = new Cat();

        a.sound();
        b.sound();
        c.sound();
    }
}

// Output
Animals make sound
Woof
Meow

在上面的例子中，我们有两个类，狗类和猫类，它们都扩展了动物类。你可以注意到，当我们调用对象dog和cat时，我们收到了它们各自类中方法的输出。

这表明animal类中的方法被子类重写了。通常情况下，为了更容易理解代码，我们使用@Override 关键字来表示哪个方法被父方法所覆盖。这给出了一个动态多态性的好例子。

多态性的优点

我们现在要看一下多态性的优点。

  1. Support for Method Overriding - 这是一个子方法可以修改父方法的规范的功能。这也使得一个方法的创建和修改可以为多个方法服务。
  2. Method specification - 这允许子类在实现前对父类进行修改或改进。
  3. Method Overloading - 这允许在不同的方法上使用相同的方法名，但修改参数和参数以避免编译时的错误。

多态性的特点

  1. Polymorphic Coercion -协同是将数据类型从一种形式自动转换为另一种形式。上述过程的一个例子是将双数转换为整数。上述情况也可以被称为隐式类型转换。

下面的例子将说明java是如何实现协整的。

// Explicit type conversion
double x;
x=(double)2;

// Implicit type conversion
double x;
x=2;

在第一个例子中，你首先要初始化数据类型，然后在分配变量时，指定变量的类型。在Implicit类型转换中，情况是不同的。在你初始化数据类型后，你只需要分配变量，编译器就会自动将其识别为double。

  1. Operator Overloading - 这就是同一符号或运算符即使在同一代码中使用也有多种含义的情况。下面是一个解释运算符重载的例子。
String str = "5"+5;
int sum = 5+5;

System.out.println("str=%s sum=%d",str,sum);

//Output
str = 55
str = 10

在上面的例子中，你可以注意到+ 运算符不仅被用作数学运算符，用于加法，它也被用作字符串连接，将一个字符串和一个整数连接起来。从输出中可以看出，尽管使用的运算符是相同的，但输出却不同。这表明运算符重载是如何发生的。

  1. Polymorphic parameters - 这个特殊的特性允许一个参数或方法的名称与本地或全局的不同数据类型相关联。
public class Dog extends Animal {
    private string legs;
    public String setDogLegs(){
        int legs = 4;
        this.legs = this.legs + legs;
    }
}

多态参数的声明会导致variable hiding 。

变量隐藏发生在局部变量的声明覆盖了同名的全局变量。

在上面的例子中，我们在全局上将腿声明为字符串，然后在本地将其声明为整数。通常情况下，会发生变量隐藏。但是为了解决这个问题，我们使用了一个全局引用this ，在本地环境中指向全局变量。

总结

通过这篇文章，你现在可以认识到多态性不仅是java的支柱，也是任何OOP语言的支柱。不同类型的多态性显示了多态性可以用不同的方式执行。了解编译时和运行时的多态性将大有帮助，因为它适用于主要的编程语言。

avatar
文章
阅读
粉丝