C/C++、Java、Go、Python总结对比19-重载和多态

笔者在平时的学习过程中，经常碰到这两个词，但是如果不进行总结的话，经常会弄混淆。这里说一下这两个概念的的层次的上的不同，重载是在同一个层次的概念，比如都在同一个类中。而多态说的是不同的层次，即父类和子类具有相同的函数，但是功能有所不同，这是多态。下面看代码：

c++的写法

 #include <iostream>
#include <string>
#include <stdio.h>
#include <cstring>

using namespace std;
//定义父类
class Father {
public:
    string name;

    virtual void printName() {  //定义虚函数，让子类重写该方法实现多态
        cout << "father name is "<< name <<endl;
    }
    void printName(string nickname) {  //定义和虚函数名相同的函数，参数和返回值可以不同，实现重载
        cout << "father nickname is "<< nickname <<endl;
    }
};

class Son: public Father {
public:
    void printName() {  //重写父类的虚函数
        cout << "son name is "<< name <<endl;
    }
};


int main() {
    Father *people = new Son();  //定义类的指针
    people->name = "MR";  //成员变量赋值
    people->printName();  //这里会调用子类的方法，也就是多态
    people->printName("wan");  //调用父类的方法，实现重载
    delete people;  //释放对象
    return 0;
}

java的写法

public class Father {
    public String name;
    public void getName() {  //定义该方法实现多态
        System.out.println("father name is "+name);
    }
    public void getName(String nickname) {  //定义同名不同参的方法实现重载
        System.out.println("father nickname is "+nickname);
    }
}

 

public class Son extends Father {
    public void getName() {  //重写父类的方法
        System.out.println("son name is "+name);
    }
}

 

public class Main {
    public static void main(String[] args) {
        Father people = new Son();
        people.name = "MR";
        people.getName();  //多态
        people.getName("wan");  //重载
    }
}

go的写法

 type Person interface {  //通过接口实现多态
	SayHello()
}

type Girl struct {
	Sex string
}

type Boy struct {
	Sex string
}

func (this *Girl) SayHello() {
	fmt.Println("Hi, I am a " + this.Sex)
}

func (this *Boy) SayHello() {
	fmt.Println("Hi, I am a " + this.Sex)
}

func main() {
	person1 := Person(&Girl{"girl"}) //实现多态
	person1.SayHello()

	person2 := Person(&Boy{"boy"}) //实现多态
	person2.SayHello()
}

python的写法

class Person(object):
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex

    def print_title(self):
        if self.sex == "male":
            print("man")
        elif self.sex == "female":
            print("woman")


class Child(Person):  # Child 继承 Person
    def print_title(self):  # 重写父类的方法
        if self.sex == "male":
            print("boy")
        elif self.sex == "female":
            print("girl")


if __name__ == "__main__":
    May = Child("May", "female")
    Peter = Person("Peter", "male")

    print(May.name, May.sex, Peter.name, Peter.sex)
    May.print_title()  # 分别调用子类和父类的函数实现多态
    Peter.print_title()

对比总结：

1. c++和java的多态和重载的实现比较相似，go和python中可以实现多态，没有重载；

2. 重载要解决的是参数类型和参数个数的问题，对于类型，python不像是c语言整型要写int，字符串要写str,这些python都不需要所以也就不需要重载。

3. go的官方文档中说到，不支持重载机制可以简化方法调度。从其他语言的经验上看，重载只是偶尔有用，但会在实践中引起误解和导致脆弱性。