[关闭]
@SuHongjun 2020-05-21T10:00:42.000000Z 字数 2119 阅读 155

Python-Day 20:类和对象 - 中级知识1:

Python 2020春季学期


继承(单继承):

  1. class Person( ):
  2. cat = '灵长类'
  3. planet = '地球'
  4. def __init__(self,name,age=0,gender='unknown'):
  5. self.name = name
  6. self.age = age
  7. self.gender = gender
  8. def say_hi(self):
  9. print('Hi')
  10. class American(Person):
  11. pass
  12. class Chinese(Person):
  13. pass

继承(多继承)【少用】:

  1. class A():
  2. def say_hi(self):
  3. print("I am A")
  4. class B():
  5. def say_hi(self):
  6. print("I am B")
  7. class C(A,B): #多继承
  8. pass
  9. >>> c=C()
  10. >>> c.say_hi()
  11. I am A

虽然 Python 在语法上支持多继承,但多继承的情况比较复杂,初学者不容易掌握。
多继承容易让代码逻辑复杂、思路混乱,一直备受争议,中小型项目中较少使用,后来的 Java、C#、PHP 等干脆取消了多继承。
使用多继承经常需要面临的问题是,多个父类中包含同名的类方法。对于这种情况,Python 的处置措施是:根据子类继承多个父类时这些父类的前后次序决定,即排在前面父类中的类方法会覆盖排在后面父类中的同名类方法。
逼不得已,建议大家不要使用多继承。

多态:

  1. class American(Person):
  2. ...
  3. class Chinese(Person):
  4. ...
  5. class Chinese_man(Chinese):
  6. ...
  7. class Chinese_woman(Chinese):
  8. ...
  9. class Person( ):
  10. cat = '灵长类'
  11. planet = '地球'
  12. def __init__(self,name,age=0,gender='unknown'):
  13. self.name = name
  14. self.age = age
  15. self.gender = gender
  16. salary = 5000
  17. def say_hi(self):
  18. print('Hi')
  19. class American(Person):
  20. country = 'USA'
  21. def say_hi(self):
  22. print("How are you?")
  23. class Chinese(Person):
  24. country = '中国'
  25. def say_hi(self):
  26. print("您好!")
  27. class OldKunMingPeople(Chinese):
  28. province = '云南'
  29. city = '昆明'
  30. def say_hi(self):
  31. print("你家,饭咯吃了?")

封装:

  1. class Student(Person):
  2. def __init__(self,name,age=0,gender='unknown'):
  3. #Person.__init__(self,name,age,gender)
  4. super().__init__(name,age,gender)
  5. self.score = None #未作封装

简单的理解封装(Encapsulation),即在设计类时,刻意地将一些属性和方法隐藏在类的内部,这样在使用此类时,将无法直接以“类对象.属性名”(或者“类对象.方法名(参数)”)的形式调用这些属性(或方法),而只能用未隐藏的类方法间接操作这些隐藏的属性和方法。

封装的好处:
首先,封装机制保证了类内部数据结构的完整性,因为使用类的用户无法直接看到类中的数据结构,只能使用类允许公开的数据,很好地避免了外部对内部数据的影响,提高了程序的可维护性。

除此之外,对一个类实现良好的封装,用户只能借助暴露出来的类方法来访问数据,我们只需要在这些暴露的方法中加入适当的控制逻辑,即可轻松实现用户对类中属性或方法的不合理操作。

并且,对类进行良好的封装,还可以提高代码的复用性。

封装的简单例子

  1. class Person( ):
  2. cat = '灵长类'
  3. planet = '地球'
  4. def __init__(self,name,age=0,gender='unknown'):
  5. self.name = name
  6. self.age = age
  7. self.gender = gender
  8. salary = 5000
  9. def say_hi(self):
  10. print('Hi')
  11. #通过对 __score属性的封装,实现合法性检查
  12. class Student(Person):
  13. def __init__(self,name,age=0,gender='unknown'):
  14. super().__init__(name,age,gender)
  15. self.__score = None #封装、私有属性
  16. def get_score(self):
  17. return self.__score
  18. def set_score(self, mark):
  19. if 0<=mark<=100:
  20. self.__score = mark
  21. else:
  22. print("分数不合理,请重新设定分数!")

综合作业

以小组进行,每个组最多3个人

题目:
...........?????

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注