Python面向对象编程（Object Oriented Programming，OOP）之多态（Polymorphism）

柔情只为你懂 2022-05-17 23:48 140阅读 0赞

## 多态（Polymorphism） ##

同一操作作用于不同对象，可以有不同的解释，有不同的执行结果，这就是多态，简单来说就是：父类的引用指向子类对象。

Pyhon不支持Java和C\#这一类强类型语言中多态的写法，但其属于原生多态，其Python崇尚“鸭子类型”。

**鸭子类型**

在程序设计中，鸭子类型（英语：duck typing）是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试，“鸭子测试”可以这样表述：  
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

> **在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。**

实例：

class Duck():
        def walk(self):
            print('I walk like a duck')
    
        def swim(self):
            print('i swim like a duck')
    
    
    class Person():
        def walk(self):
            print('this one walk like a duck')
    
        def swim(self):
            print('this man swim like a duck')

可以很明显的看出，Person类拥有跟Duck类一样的方法，当有一个函数调用Duck类，并利用到了两个方法walk()和swim()。我们传入Person类也一样可以运行，函数并不会检查对象的类型是不是Duck，只要他拥有walk()和swim()方法，就可以正确的被调用。  
下面我们对比Java和Python多态：

Polymorphism.java

class Dance {
        public void play() {
            System.out.println("Dance.play");
        }
    
        public void play(int i) {
            System.out.println("Dance.play" + i);
        }
    }
    
    class Latin extends Dance {
        @Override
        public void play() {
            System.out.println("Latin.play");
        }
    
        public void play(char c) {
            System.out.println("Latin.play" + c);
        }
    }
    
    class Jazz extends Dance {
        @Override
        public void play() {
            System.out.println("Jazz.play");
        }
    
        public void play(double d) {
            System.out.println("Jazz.play" + d);
        }
    }
    
    public class Polymorphism {
        private void perform(Latin dance) {  // 定义perform方法
            dance.play();
        }
    
        private void perform(Jazz dance) {   // 定义perform方法
            dance.play();
        }
    
        public static void main(String[] args) {
            new Polymorphism().perform(new Latin()); // 向上转型
            new Polymorphism().perform(new Jazz());  // 向上转型
        }
    }

结果：

> Latin.play  
> Jazz.play
> 
> Process finished with exit code 0

Polymorphism.py

class Dance:
        def play(self):
            print("Dance.play")
    
        # def play(self,i):  # 提示已经定义了一个play方法，不能在一个类中重复定义，下面简略
        #     print("Dance.play" + i)
    
    
    class Latin(Dance):
        def play(self):
            print("Latin.play")
    
    
    class Jazz(Dance):
        def play(self):
            print("Jazz.play")
    
    
    if __name__ == '__main__':
        l = Latin()
        j = Jazz()
        l.play()
        j.play()

结果：

> Latin.play  
> Jazz.play
> 
> Process finished with exit code 0

通过Java和Python同一实现的代码我们可以知道：

1.  Python中处处是多态，Java需要通过继承、重写和父类引用指向子类的对象三个条件才能实现多态。
2.  Python代码比Java简单，Java在实现多态的时候需要上下转型，可以选择编译时的多态还是执行时的多态。

> **Python处处是多态，仅供参考!**

--------------------