python中类的封装性_(09)-Python3之--类的三大特性（封装、继承、多态）

python中继承也非常简单，定义一个Animal类，下面有一个eat()方法，再定义一个Dog类，Dog类中什么都不写，用pass代替。然后实例化一个dog，让dog继承Animal类,dog可以使用eat()方法。

class Animal(object):

def __init__(self,name):

self.name = name

def eat(self):

print(self.name,"吃饭")

class Dog(Animal):

pass

dog=Dog("旺财")

dog.eat()

结果：

旺财 吃饭

重写：和父类的方法名称一样。但是在子类里面，重新实现。

1、完全覆盖

class Animal:

def __init__(self,name,private_v1):

self.name = name

self._private_v1 = private_v1

self.__private_v2 = "private_really"　　# 私有化，不对子类开放

def run(self):

print("跑！！")

class Dog(Animal): # 继承父类(Animal)

def __init__(self,name,kind):

self.name = name

self.kind = kind

def eat(self):

print("一只名叫 {} 的 {} 在啃骨头！！".format(self.name,self.kind))

def run(self): # 重写父类的run()方法

print("我是一条狗，我有四条腿跑！！")

# 实例化

dog = Dog("二狗","哈士奇")

dog.run()

dog.eat()

结果：

我是一条狗，我有四条腿跑！！

一只名叫 二狗 的 哈士奇 在啃骨头！！

2、保留父类的做法，在它的基础上再扩展其它的内容。(扩展方式：super())

super()的2种表达：

super().方法(参数列表)

super(子类名，self).方法(参数列表)

class Animal:

def __init__(self, name, private_v1):

self.name = name

self._private_v1 = private_v1

self.__private_v2 = "private_really"

def run(self):

print("跑！！")

class Dog(Animal): # 继承父类Animal

def __init__(self, name, kind, private_v1):

# 方法一

super().__init__(name, private_v1) # 调用父类现成的方法

# 方法二

# super(Dog,self).__init__(name)

self.kind = kind # 扩展子类自己的特性

def eat(self):

print("一只名叫 {} 的 {} 在啃骨头！！".format(self.name, self.kind))

def gogo(self): # 完全颠覆父类的做法

super().run() # 父类做法

print("我是一条狗，我有四条腿跑！！") # 我的做法

# 实例化

dog = Dog("小白","二哈","private_v1")

dog.eat()

dog.gogo()

结果：

一只名叫 小白 的 二哈 在啃骨头！！

跑！！

我是一条狗，我有四条腿跑！！

多继承：

在python中是可以多继承的，继承的先后顺序是有区别的，当我们调用方法的时候，如果第一个继承的找不到，才会去第二个中找，但是只要在第一个类中找到调用的那个方法，即使参数个数不匹配也不会调用第二个父类中的，此时会报错。

class Student:

def study(self):

print("我是学生，我爱学习，我爱班级！")

class Employee:

def work(self):

print("我要赚钱，我要工作，我爱工作！！")

class People(Student,Employee): # 继承Student类,Employee类

def do_something(self):

self.work()

self.study()

p = People()

p.do_something()

结果：

我要赚钱，我要工作，我爱工作！！

我是学生，我爱学习，我爱班级！

3.多态

python中本质上是没有真正多态这种思路，只是形式上有这样一个多态的思路。

class Animal(object):

def __init__(self,color):

self.color=color

def eat(self):

print("吃饭")

class Cat(Animal):

def eat(self):

print("猫吃鱼")

class Dog(Animal):

def __init__(self,name,age,color):

super(Dog,self).__init__(color)

self.name=name

self.age=age

def eat(self):

print("狗吃肉")

def feed(obj):

obj.eat()

an=Animal("白色")#实例化Animal

cat=Cat("棕色")#实例化Cat

dog=Dog("小黄",2,"黄色")#实例化Dog

feed(an)

feed(cat)

feed(dog)

结果：

吃饭

猫吃鱼

狗吃肉

定义了一个Animal父类，两个子类Cat和Dog里面都有eat()方法，最后再定义一个feed()喂养方法，

传入一个obj对象，调用obj.eat()，然后实例化Animal，Cat和Dog，分别在feed中传入实例化对象an，cat和dog会分别打印出不同的语句，这个就是python中的多态。