Python中的封装、继承与多态
1. 前言
面向对象的三大特性，想必大家肯定是耳熟能详。就是今天要介绍的内容：封装、继承、多态。面向对象的思想都是一样的，这里我用Python进行实现！
2. 封装
2.1 什么是封装呢？
封装就是：我写了一个类，我将一个类的属性、方法全部包装到了一个类中。我对类中某些方法和属性进行了隐藏，（外部实例化之后，无法通过对象.方法或对象.属性来进行直接调用）。因为我不想让外部了解我的实现机理或属性，但是会留出一些公开的方法来供外部间接调用这些“封装”好的属性和方法！这就是封装！！！
# coding:utf-8
class Parents(object):
__name = "kaka"
__age = 35
job = "teacher"
def __hobby(self):
print("pingpong")
# 调用私有方法hobby
def get_hobby(self):
self.__hobby()
# 获取年龄
def get_age(self):
return self.__age
# 获取姓名
def get_name(self):
return self.__name
if __name__ == "__main__":
# 实例化
p = Parents()
# 调用封装好的私有属性
print(p.name)
print(p.__name)
报错，无法直接调用
私有方法也无法调用
# coding:utf-8
class Parents(object):
__name = "kaka"
__age = 35
job = "teacher"
def __hobby(self):
print("pingpong")
# 调用私有方法hobby
def get_hobby(self):
self.__hobby()
# 获取年龄
def get_age(self):
return self.__age
# 获取姓名
def get_name(self):
return self.__name
if __name__ == "__main__":
# 实例化
p = Parents()
# 调用封装好的私有方法
p.hobby()
报错，无法直接调用
# coding:utf-8
class Parents(object):
__name = "kaka"
__age = 35
job = "teacher"
def __hobby(self):
print("pingpong")
# 调用私有方法hobby
def get_hobby(self):
self.__hobby()
# 获取年龄
def get_age(self):
return self.__age
# 获取姓名
def get_name(self):
return self.__name
if __name__ == "__main__":
# 实例化
p = Parents()
# 通过留出来的公有方法进行获取封装好的属性
print(p.get_name())
print(p.get_age())
# 通过留出来的公有方法进行调用封装好的方法
p.get_hobby()
输出
kaka
35
pingpong
3.继承
3.1什么是继承？
字面意思就是，一个类是另一个类的子类，那么这个类就可以拥有和父类一样的属性、方法。这就好比是现实当中，儿子会遗传父亲的性格、长相等。
3.2 单继承
单继承就是，这个类只继承了一个父类，只拥有一个父类的属性和方法。
# coding:utf-8
# 父类
class Father(object):
sex = "male"
job = "teacher"
age = 35
surname = "Zhang"
def run(self):
print("running...")
def hobby(self):
print("basketball")
# 子类
class Son(Father):
job = "student"
age = 10
def hobby(self):
print("swimming...")
if __name__ == "__main__":
s = Son()
# 继承了父亲的性别和姓氏
print(s.sex)
print(s.surname)
输出
male
Zhang
3.3多继承
多继承就是当前子类继承了多个父类，这样就拥有了多个父类的属性和方法。如果父类有相同的属性和方法，优先继承靠前父类的属性和方法。
# coding:utf-8
# 父类
class Father(object):
sex = "male"
job = "teacher"
age = 35
surname = "Zhang"
def run(self):
print("running...")
def hobby(self):
print("basketball")
# 母亲类
class Mother(object):
sex = "female"
job = "doctor"
age = 35
surname = "Li"
def run(self):
print("running...")
def hobby(self):
print("pingpong")
def test(self):
print("hello")
# 多继承,先继承了Father类，然后继承了Mother类
class Son(Father, Mother):
job = "student"
age = 10
if __name__ == "__main__":
s = Son()
# 两个父类里面都有surname和sex
# 因为先继承的Father类，所以表现的是Father类的属性
print(s.surname, s.sex)
# 因为先继承的Father类，所以表现的是Father类的方法
s.hobby()
# 继承了Mother类的test方法
s.test()
输出
Zhang male
basketball
hello
4.多态
4.1 什么是多态？
举一个现实中的例子，同样的一件事情，不同的人处理起来，他们的实现过程是完全不同的，会表现出不同的形态。比如：都是吃饭这个事情，中国人表现的是用筷子吃饭，而美国人表现的是用叉刀吃饭。这个就是相同的事情，表现出了不同的“形态”。
总结一句话就是：将不同的对象传入同一函数中，表现出不同的形态，这就是多态。
4.2 多态的注意点
- 多态的前提是：继承、重写。
- 多态指的是方法的多态，多态与属性无关。
4.3代码示例
# coding:utf-8
# 父类
class Father(object):
def __init__(self, sex, job, age, surname):
self.sex = sex
self.job = job
self.age = age
self.surname = surname
def run(self):
print("running...")
def hobby(self):
print("basketball")
# 子类1
class Son(Father):
def __init__(self, sex, job, age, surname, school_name):
# 调用父类现有方法
super().__init__(sex, job, age, surname)
# 进行扩展
self.school_name = school_name
# 重写
def hobby(self):
print("swimming")
# 子类2
class Daughter(Father):
def __init__(self, sex, job, age, surname, school_name):
# 调用父类现有方法
super().__init__(sex, job, age, surname)
# 进行扩展
self.school_name = school_name
# 重写
def hobby(self):
print("drawing")
# 获取爱好
def get_hobby(obj):
obj.hobby()
if __name__ == "__main__":
s = Son(sex="male", job="student", age=10, surname="Zhang", school_name="CHD")
d = Daughter(sex="female", job="student", age=12, surname="Zhang", school_name="CHD")
# 将s、d两个对象传入相同的函数get_hobby
get_hobby(s)
get_hobby(d)
输出
swimming
drawing
以上就是python中的封装，继承，多态的介绍，希望对你有所帮助。