python_小白的修炼笔记_2018/1/6_多态

对比java和python的多态

java：

//定义一个Animals类
class Animals {

    public void bark() {
        System.out.println("Animals bark");
    }

}


//定义了一个Cats类继承了Animals类
class Cats extends Animals {

    //重写了父类Animals的bark()方法
    public void bark() {
        System.out.println("Cats bark, 喵喵喵...");
    }

    //定义了一个同名不同参数的方法，需要传入一个boolean变量
    public void bark(boolean bigCat) {
        System.out.println("bigCats bark, 吼吼吼...");
    }

}

//定义一个Persons类 与 Animals类没有继承关系
class Persons {

    //定义了bark()方法
    public void bark() {
        System.out.println("Persons bark, 啊啊啊...");
    }

}

java实现多态：

public class TestPolymorphism {
    public static void main(String[] args) {

        /*
            No.1
                父类引用指向子类对象
                通过该引用调用子类方法
        */
        Animals animal = new Cats();
        animal.bark();

        // 可以把对象new Cats()作为参数传给Animals引用，因为二者是继承关系
        test(new Cats());   

        // 但是不可以把new Person()作为参数传给Animals引用，因为二者没有继承关系
        // test(new Person());

        /*
            No.2
                方法重载，调用同名不同参的方法，实现不同功能
        */
        Cats cat = new Cats();
        cat.bark();
        cat.bark(true);

    }

    //定义了一个需要Animals类型对象的方法
    public static void test(Animals animal) {

        //通过引用调用bark()方法
        animal.bark();
    }
}

Python：

class Animals(object):

    def bark(self):
        print("Animals bark")


class Cats(Animals):

    def bark(self):
        print("Cats bark, 喵喵喵...")


class Persons(object):

    def bark(self):
        print("Persons bark, 啊啊啊...")

python实现多态：

No.1
因为python定义变量时没有指明其类型，所以类似于java中

Animals animal = new Cats();
animal.bark();

这种形式的多态就没了
但是,与这种形式相同的多态还可以在函数里使用

# 类外定义一个函数，有一个形参
def test(temp)：
    #通过形参调用被传入对象的bark()方法
    temp.bark()

cat = Cats()
person = Persons()

# 以下两条语句都能正常运行
test(cat)
test(person)

这时候又出现不同了，在java中因为指定了形参类型为Animals，所以Persons对象不能传入方法中；
但是在python中，因为不指明形参类型，所以Persons对象也可以传入函数（只要Persons中也有bark()方法，程序就不会报错，否则会出现AttributeError）

No.2
Python中有没有方法重载？？？
为了解决这个问题，我在Cats类中添加了一个方法（在bark(self) 之后）

def bark(self, bigCats):
    print("bigCats bark, 吼吼吼....")

# 删除之前类外的代码，重新写入
cat = Cats()
cat.bark(True)
cat.bark()

运行：

cat = Cats()
cat.bark(True)

这两句正常运行，运行结果：

bigCats bark, 吼吼吼....

但是cat.bark()这条语句出现错误：

TypeError: bark() missing 1 required positional argument: 'bigCats'

说明后添加的bark(self, bigCat) 把先定义的bark(self) 给覆盖了
为了验证是不是后定义的会把先定义的方法覆盖
我改变了bark(self, bigCat)和bark(self) 的定义顺序 ，先bark(self, bigCat)后bark(self)
运行到cat.bark(True) 就出现错误

TypeError: bark() takes 1 positional argument but 2 were given

由此说明python不支持方法重载，对于同名方法，后定义的会把先定义的覆盖掉

综上所述，python支持多态，但是不够明显
只能够通过函数传参的形式来实现多态