多方法与重载的区别

在多方法中，我们使用方法的集合。并且所有方法都具有相同的名称、相同数量的参数，并且可以具有重叠的类型签名。在进行函数调用时的多方法的情况下，所有方法的集合被认为是可能的方法。

根据运行时的参数，选择正确的方法。可以说方法多态的泛化是多方法。

在多方法中，我们一般关注两点：

• 方法的名称。
• 调度值，由调度方法产生。

根据调度值选择正确的方法。

多方法示例：

Python3

from multimethod import multimethod
class myClass(object):
      
    @multimethod
    def GFG(self, x: int):
        print(2 * x)
  
    @multimethod
    def GFG(self, x: complex):
        print("GeeksforGeeks")
          
obj = myClass()
obj.GFG(3)
obj.GFG(6j)

输出：

6

GeeksforGeeks

在重载的情况下，我们有两个或多个名称相同但签名不同的方法。签名表示参数类型和参数数量。

这是一个面向对象的概念，其中我们有两个或多个名称相同但参数不同的函数。在函数重载的情况下，所有函数的名称都是相同的，但它们在参数方面会有所不同。

在函数重载中，重要的是所有具有相同名称的函数在参数方面需要不同，它们可能在返回类型方面也可能不同。它们可能具有相同的返回类型，也可能具有不同的返回类型。

int test() { }

int test(int a) { }

float test(double a) { }

int test(int a, double b) { }

这里所有的参数都不同，它们可能具有相同的返回类型。

int test(int a) { }

double test(int b){ }

上面的代码是不正确的，因为它们在返回类型方面不同，但它们具有相同的参数。

它是静态解决的，即在编译期间，取决于参数的类型和参数的数量。这是多方法的一个特例。

函数重载示例：

C++

#include 
using namespace std;
  
void display(int i) 
{
    cout << " It is int " << i << endl;
}
void display(double f) 
{
    cout << " It is float " << f << endl;
}
void display(char const *c) 
{
    cout << " It is char* " << c << endl;
}
  
int main() 
{
    display(1);
    display(1.1);
    display("GFG");
    return 0;
}

输出：

It is int 1

It is float 1.1

It is char* GFG

以下是多方法和重载之间的差异表

S. No.	Multi-methods	Overloading
1.	In multi-methods, the method is a dispatch based on dispatch value at runtime	In Overloading, the method is selected based on arguments type and number of arguments
2.	Here we can have the same name and same number of arguments	Here we have the same number but the different number of arguments
3.	In the case of multi-methods, we have an overlapping signature type signature	In case of overloading, we don’t have overlapping type signatures.
4.	It is decided at runtime time	It decided at compile time
5.	In multi-methods we use dispatch value to dispatch method at runtime.	In overloading, we use the type of argument and the number of arguments to choose the correct method at compile time.
6.	It is a collection of methods that have the same name and same number of arguments	In overloading, they are different in terms of arguments.
7.	It belongs to the generic function	It doesn’t belong to the generic function
8.	It is kind of virtual on any parameter	It is  not virtual
9.	It depends on the actual type of receiver and arguments	It depends on the declared type of the parameters