【学习笔记】--- 老男孩学Python，day18 面向对象------抽象类(接口类), 多态, 封装

抽象类,接口类

Python没有接口这个概念

抽象类(接口类): 目的是制定一个规范

要学会归一化设计,有重复的东西就要想把它们合并起来

 from abc import ABCMeta, abstractclassmethod

 class Payment(metaclass=ABCMeta): # 创建一个抽象 (接口) 类 的父类,
     @abstractclassmethod
     def pay(self): pass   # 制定一个规范   只是放在那里

 class Alipay(Payment):
     def __init__(self,money):
         self.money = money

     def pay(self):
         print('使用支付宝支付了%s' % self.money)

 class Jdpay(Payment):
     def __init__(self, money):
         self.money = money

     def pay(self):
         print('使用京东闪付支付了%s' % self.money)

 class WeChatpay(Payment):
     def __init__(self,money):
         self.money = money

     def pay(self):
         print('使用微信支付了%s' % self.money)

 # 都有pay这个方法  就建一个pay的函数
 def pay(obj):
     obj.pay()

 # 实例化一个Alipay的对象
 a1 = Alipay(2000)

 # 实例化一个Jdpay的对象
 j1 = Jdpay(1999)

 # 实例化一个Wechatpay的对象
 w1 = WeChatpay(1)

 pay(a1)
 pay(j1)
 pay(w1)

多态( python没有多态  有鸭子类型. ):  鸭子类型 : 看着像鸭子,他就是鸭子.

python是 弱类型语言

name = 'alex'

python 不管什么类型,传入函数,封装到对象中都可以.

这些类 都互称为鸭子.都有index方法

 class Str:
     def index(self):
         pass

 class List:
     def abc(self):
         pass

 class Tuple:
     def rrr(self):
         pass

封装

广义的封装: 实例化一个对象,给对象空间封装一些属性.
狭义的封装: 私有制.

私有成员:  __私有静态字段(变量),   __私有方法,   __私有对象属性

self.__ XXX 才可以访问

类的内部可以访问

# 类外部不能访问 # 类的内部可以访问 # 类的派生类也不能访问

私有静态字段(变量) 

私有静态字段：仅类内部可以访问；

 class B:
     __money = 100000

 class A(B):
     name = 'alex'
     __age = 1000

     def func(self):
         print(self.__age)
         print(A.__age)    # 对于私有静态字段,类的内部可以访问.
         print('func....')
     def func1(self):
         print(self.__money)
         print(A.__money)
 a1 = A()
 print(a1.name)
 print(A.name)

 print(a1.__age)  # 实例化对象不能访问私有静态字段
 print(A.__age)  # 类名不能访问私有静态字段
 # 对于私有静态字段,类的外部不能访问.

 a1.func()

 # 对于私有静态字段,类的内部可以访问.

 a1.func1()

 # 对于私有静态字段来说,只能在本类中内部访问,类的外部,派生类均不可访问.

 # 可以访问,但是工作中千万不要用.
 print(A._A__age)
 print(A.__dict__)

私有方法

私有方法:仅类内部可以访问

 class B:
     __money = 100000
     def __f1(self):
         print('B')

 class A(B):
     name = 'alex'

     def __func(self):
         print('func....')

     def func1(self):
         # self.__func()   # 类的内部可以访问
         self.__f1()
 a1 = A()
 a1.__func()  # 类外部不能访问
 a1.func1()  # 类的内部可以访问
 a1.func1()  # 类的派生类也不能访问.

私有对象属性

 class Bmi:
     def __init__(self,name, weight, heigth):
         self.name = name
         self.__weight = weight
         self.heigth = heigth

     def bmi(self):
         b = self.__weight / (self.__weight**2)
         return self.__weight

 p1 = Bmi('张三',89,1.77)

 print(p1.bmi())

面试题

 class Parent:
     def __func(self):  # ③
         print('in 父类 func')

     def __init__(self):  # ②
         self.__func()

 class Son(Parent):
     def __func(self):
         print('in 子类 func')

 son1 = Son()   # ①

 '''
 1.实例化一个son的对象
 2.找__init__()方法  子类里面没有,找父类,父类中有__init__()方法
 3.类外部不能访问  类的内部可以访问  类的派生类也不能访问
 '''

面向对象结构与成员

 ''''''
 '''
 class A:
     name = '静态字段'  # ======> 第一部分 静态字段 部分

     def __init__(self):
         pass
                       # ======> 第二部分 方法部分
     def func(self):
         pass

 '''

 class A:
     company_name = 'old_boy_educaion'  # 静态变量
     __iphone = '138xxxxxxxxx'  # 私有静态变量(私有静态字段)

     def __init__(self,name,age):  # 普通方法(构造方法)
         self.name = name          # 对象属性(普通字段)
         self.age = age            # 私有对象属性(私有普通字段)

     def func1(self):              # 普通方法
         pass

     def __func(self):             # 私有方法
         pass

     @classmethod                  # 类方法
     def class_func(cls):
         # 定义静态方法,无默认参数
         print('静态方法')

     @staticmethod                 # 静态方法
     def static_func():
         # 定义静态方法,无默认参数

     @property                     # 属性
     def prop(self):
         pass