python学习Day19--面向对象的三大特性

【知识点】

 # python 没有接口这个概念

1、 接口类，抽象类：制定一个规范

　　如下几行代码就是制定规范的过程

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):# 抽象类（接口类）
    @abstractmethod              # 强制执行一个规范，凡是继承我的类中必须有pay方法，否则实例化对象就会报错
    def pay(self):   pass        # 制定了一个规范

　　具体的一个例子如下：

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):# 抽象类（接口类）
    @abstractmethod              # 强制执行一个规范，凡是继承我的类中必须有pay方法，否则实例化对象就会报错
    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 Wechat(Payment):
    def __init__(self,money):
        self.money=money

    def pay(self):             # 归一化设计
        print("使用微信支付了%s" % self.money)

def pay(obj):
    obj.pay()

a1=Alipay(500)
w1=Wechat(200)
pay(a1)         #归一化设计
pay(w1)         #归一化设计

2、多态：（python面向对象三大特征之一，python中处处是多态）

　　没有多态？它有什么？它有鸭子类型

　　# 鸭子类型：看着像鸭子，它就是鸭子

 3、封装：（广义）实例化一个对象，给对象空间封装一些属性

　　　　　（狭义）私有制

　　　　　  私有成员：私有静态字段，私有方法，私有对象属性

　　　　#1、私有静态字段：（可以访问，但不要使用）

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

# 私有静态字段
class B:
    __money=20

class A(B):
    name='alex'
    __age=100
    def func(self):
        print(self.__age)   #可以
        print(A.__age)      #可以
        print('func....')
    def func1(self):
        print(self.__money)  #不可以
a1=A()
# print(a1.name)
# print(A.name)
# print(a1.__age)   #实例化对象不能访问私有静态字段
# print(A.__age)    #类名不能访问私有静态字段

#   对于私有静态字段，类的外部不能访问
a1.func()    # 类的内部可以访问私有静态字段
a1.func1()   # 报错
#   对于私有静态字段，只能在本类中内部访问，类的外部，派生均不可访问

　　　　#2、私有方法：

　　　　　　对于私有方法，只能在本类中内部访问，类的外部，派生均不可访问

# 私有方法
class B:
    __money=1000

    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()

　　　　【一道题】

class Parent:
    def __func(self):    # _Parent__func
        print('in Parent func')

    def __init__(self):
        self.__func()    # 对象.__Parent__func

class Son(Parent):
    def __func(self):    #_Son__func
        print('in Son func')

son1=Son() # 运行结果是？
# 结果：in Parent func

　　　　分析：一开始就产生了_Parent__func，要执行的就是对象._Parent__func