面向对象之封装继承多态

Posted zhangdajin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象之封装继承多态相关的知识,希望对你有一定的参考价值。

封装

‘‘‘
封装: 对外隐藏类中一些属性与方法的实现细节
?
优点:外界不能直接访问,让内部的属性与方法具有安全保障
‘‘‘
?
class A:
   # 类的属性:__开头的属性,在外界不能通过 cord | __cord 直接访问:对外隐藏了
   __cord = ‘01012300‘
?
   # 类的方法:__开头的方法,在外界不能通过 get_money | __get_money 直接访问:对外隐藏了
   @classmethod
   def __get_money(cls):
       print(‘输入密码,取出100w零花钱‘)
   
   # 对象的方法:一般的实现需求都是,这些方法只在内部使用
   def __test(self):
       pass
   
   # 对象的属性:封装目的
   # 1.对象的属性值一般都来源于外界,外界是有权力再次访问的
   # 2.封装的目的不是让外界无法访问,而且不让其直接访问,可以在完成安全处理后再访问
   # 3.如何做到外界还是通过变量名来对属性进行取值赋值,但是是走的方法间接拿到的值
   #       -- __money被封装,外界还是可以通过 对象.money 取值赋值
   def __init__(self, money)
  self.__money = money
       
   # 取值
   @property  # 在外界可以 对象.money 进行取值
   def money(self):
       # print(‘走方法拿到的money‘)
       return self.__money
?
   # 赋值
   @money.setter  # 在外界可以 对象.money = 新值 进行赋值
   def money(self, money):
       self.__money = money
?
   # 删除
   @money.deleter
   def money(self):
       del self.__money

 

继承

单继承:一个类只继承一个父类

# 抽离:先有多个有共同点的类,抽离出共性形成的类 => 父类
# 派生:通过已有的父类,再去定义该类的子类,这种方式就叫做派生
?
# 继承:继承是一种关系,子类可以通过父类获取属性和方法,能获取的根据就是继承
?
# 继承的语法:
# class 父类名:pass
# class 子类名(父类名): pass
class Sup:
   pass
class Sub(Sup):
   pass
?
# 继承的规则
# 1.父类的所有未封装的属性和方法,子类都能访问
# 2.父类的所有封装的属性和方法,子类都不能访问
#       -- 在外界通过子类或子类对象,不能访问
#       -- 在子类内部通过子类或子类对象也不能访问
?
class Sup:
   __num = 10  # 封装被更名为_Sup__num
class Sub(Sup):
   def test(self):
       print(self.__num)  # 本质去访问_Sub__num,所以不能访问
       
# 继承父类的方法:子类没有明文书写父类的方法,通过继承关系拿到
class Sup:
   def test(self):
       print(self)  # 父类对象调用就是父类对象,子类对象调用就是当前调用的子类对象
       
class Sub(Sup):
   pass
Sub().test()
?
# 重写父类的方法:子类明文书写父类同名的方法,并且实现体自定义
class Sup:
   def test(self):
       print(self)  # 父类对象调用就是父类对象,子类对象调用就是当前调用的子类对象
       
class Sub(Sup):
   def test(self):
       print(‘自己的方法‘, self)
Sub().test()
?
# 重用父类的方法:子类明文书写父类同名的方法,有自己的实现体,但也用父类原有的功能
class Sup:
   def test(self):
       print(self)  # 父类对象调用就是父类对象,子类对象调用就是当前调用的子类对象
       
class Sub(Sup):
   def test(self):
       super().test()  # 本质 super(Sub, self).test() py2必须这么写
       print(‘自己的方法‘, self)
Sub().test()
?

super关键字

class Sup:
   def __init__(self, name):
       self.name = name
   
   def test(self):
       print(self)
?
?
class Sub(Sup):
   # 默认父级的__init__可以被继承过来,
   # 但是会出现子类对象的属性比父类多
   def __init__(self, name, salary):
       super().__init__(name)  # 父级有的共性功能通过super()交给父级做
       self.salary = salary  # 子类特有的自己来完成
   
   # 有继承关系下,只要名字相同,即使参数不同,还是属于同一个方法
   def test(self, num):
       super().test()  # 使用父级的方法
       print(num)
       
# 外界通过Sub对象来调用test方法,一定找自己的test方法(属性的查找顺序)
   
?
# 重点:super() 可以得到调用父级功能的对象,调用者还是子类对象
# -- super()只能在子类的方法中使用
# -- super()本质 super(子类类名, 当前对象)
# -- super().父类普通方法 | super().__init__() | super()能调用父类所有可继承方法

 

多继承

# 属性的查找顺序:优先找自己的,如果没有,按照继承先后查找父级
class A:
   name = ‘A‘
   num = 10
?
class B:
   name = ‘B‘
   count = 100
?
# 子类可以继承所有父类的所有可继承属性
class C(A, B):  # 自己 => A => B
   # name = ‘C‘
   pass

 

复杂多继承

class A:
   name = "A"
class B(A):
   name = "B"
class C:
   name = "C"
class D(C):
   name = "D"
class E(B, D):  # 先将B的所有父级们找完再找D的分支
   name = "E"
print(E.mro())  # E => B => A => D => C

 

菱形继承

# 经典类:python2中才有,没有继承任何类的类 - 深度优先
# 新式类:python2中直接或间接继承object的类,python中所定义的所有类 - 广度优先
?
# 深度优先,在查找第一个分支是就将菱形的头查找了
# 广度优先,菱形的头在所有分支查找接收后再被查找
?
# 通过 类.mro() 查看继承顺序图

 

多态

# 多态:对象的多种状态 - 父类对象的多种(子类对象)状态
?
import abc
class People(metaclass=abc.ABCMeta):
   def __init__(self, name):
       self.name = name
   @abc.abstractmethod
   def speak(self): pass
?
class Chinese(People):
   def speak(self):
       print(‘说中国话‘)
class England(People):
   def speak(self):
       print(‘说英国话‘)
       
if __name__ == ‘__main__‘:
   # 多态的体现:功能或是需求,需要父类的对象,可以传入父类对象或任意子类对象
   #       注:一般都是规定需要父类对象,传入子类对象
   def ask_someone(obj):
       print(‘让%s上台演讲‘ % obj.name)  # 父类提供,自己直接继承
       obj.speak()  # 父类提供,只不过子类重写了
?
   ch = Chinese(‘王大锤‘)
   en = England(‘Tom‘)

   # 传入Chinese | England均可以,因为都是People的一种状态(体现方式)
   ask_someone(ch)
   ask_someone(en)

   # 传入str不可以,因为str的对象没有name和speak
   # s = str(‘白骨精‘)
   # ask_someone(s)
   # p = People(‘kkk‘)
?

鸭子类型

# 需求:需要一个对象,该对象有name属性及speak方法,就可以作为一种状态的体现被传入
def ask_someone(obj):
   print(‘让%s上台演讲‘ % obj.name)
   obj.speak()
?
# 鸭子类型:
# 1.先规定:有什么属性及什么方法的类的类型叫鸭子类型
# 2.这些类实例化出的对象,都称之为鸭子,都可以作为需求对象的一种具体体现
class A:
  # 能有自己特有的属性和方法,可以和B完全不一样,但是必须有鸭子类型规定的属性和方法,不然就不是鸭子类型
   def __init__(self, name):
       self.name = name
   def speak(self):
       print(‘说AAAA‘)
 
       
class B:
   # 能有自己特有的属性和方法,可以和A完全不一样,但是必须有鸭子类型规定的属性和方法,不然就不是鸭子类型
   def __init__(self, name):
       self.name = name
   def speak(self):
       print(‘说BBBB‘)
       
ask_someone(B(‘B‘))
?
?

以上是关于面向对象之封装继承多态的主要内容,如果未能解决你的问题,请参考以下文章

19.Python面向对象之:三大特性:继承,封装,多态。

JAVA面向对象,继承、封装、多态

面向对象之:三大特性:继承(已讲),封装,多态

Python3-2020-测试开发-20- 面向对象之封装,继承,多态

python面向对象之继承/多态/封装

Python进阶(十六)----面向对象之~封装,多态,鸭子模型,super原理(单继承原理,多继承原理)