Python类、继承、多态的简单使用（与Java类比）

作为一个学python的新晋小白，简单表达一下自己的想法。之前对Java略懂一二，因此基于两者的异同来阐述自己的观点。如有不妥之处还望指正。

1.python类和java类的使用一览

java:
public class Car {
    private String color;
    private String model;
    private int year;

    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }

    public String getColor() {
        return color;
    }

    public String getModel() {
        return model;
    }

    public int getYear() {
        return year;
    }
}

python:
class Car:
    def __init__(self, color, model, year):
        self.color = color
        self.model = model
        self.year = year

从代码行上来看，显然还是python的代码行较少，显得较为简洁，同时，这个也可以被称为Python的优点之一。而且从中也可以明显看出python类中的变量可以直接使用，但是java中使用变量需要先声明再使用。

2.Python的继承

python和java在继承方面最大的区别就是python子类可以继承多个父类，但是java子类只能继承一个父类，如果一个子类需要多继承的话一般设计成interface接口的方式来实现。比如创造一个child类，类型father和mother。在Python中，father类和mother类可以都设计成child的父类，但在java中可以设计成father父类和mother接口，继承需要extends关键字实现，接口需要implements关键字实现

python实现

class child（father，mother）：

java实现

 class child extends father implements mother

3. Python多态

java中的多态跟Python中的多态是有区别的。java中的多态定义：
多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。

java多态演示

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}
执行以上程序，输出结果为：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

Python多态

 
类具有继承关系，并且子类类型可以向上转型看做父类类型，如果我们从 Person 派生出 Student和Teacher ，并都写了一个 whoAmI() 方法：
 
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def whoAmI(self):
        return 'I am a Person, my name is %s' % self.name
 
class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def whoAmI(self):
        return 'I am a Student, my name is %s' % self.name
 
class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def whoAmI(self):
        return 'I am a Teacher, my name is %s' % self.name
在一个函数中，如果我们接收一个变量 x，则无论该 x 是 Person、Student还是 Teacher，都可以正确打印出结果：
 
def who_am_i(x):
    print x.whoAmI()
 
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')
 
who_am_i(p)
who_am_i(s)
who_am_i(t)
运行结果：
 
I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice
这种行为称为多态。也就是说，方法调用将作用在 x 的实际类型上。s 是Student类型，它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法，但调用 s.whoAmI()总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。
 
由于Python是动态语言，所以，传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以，只要它有一个whoAmI()的方法即可：
 
class Book(object):
    def whoAmI(self):
        return 'I am a book'
这是动态语言和静态语言（例如Java）最大的差别之一。动态语言调用实例方法，不检查类型，只要方法存在，参数正确，就可以调用。

文章部分转载自https://blog.csdn.net/u012762054/article/details/81980750https://www.zhihu.com/question/27194944/answer/933997424