面向对象2

新式类与经典类

区别

# 1、类型区别
#    经典类  通过type查看到的实例类型都叫做instance
#           类和实例之间只能够通过__class__属性进行关联
#    新式类  通过type查看到的实例类型就是类名
#
# >>> class B: pass
# ...
# >>> b = B()
# >>> type(b)
# <type 'instance'>
# >>> b.__class__
# <class __main__.B at 0x7f24cb53ef30>
# >>>
# ----------------------------------------------------------
# >>> class A: pass
# ...
# >>> a = A()
# >>> type(a)
# <class '__main__.A'>
# >>> a.__class__
# <class '__main__.A'>
# >>>

继承与顺序

#经典类：  深度优先
#新式类：  广度优先的c3算法

c3算法

# 首先将自身类加入本序列，然后对继承序列的元素依次判断。
# 若某元素不在其他序列或者它是所有继承序列的第一个，那么把这个元素提取到本序列

python中的下划线

class P:
    """
    this is p
    :return
    """
    _min = 1   #保护属性
    __max = 10 #私有属性

    def __init__(self):
        self.name = "sc"
        self._age = 4
        self.__desc = "it"

    def __make(self):
        print("这是一个私有方法")
        print(self.__desc)

    def _protectmake(self):
        print("这是一个保护方法")

    def show(self):
        print(self.__max, self.__desc)

class Child(P):
    def show(self):
        print(self.__max)
        # print(self._P__max)

p = P()
c1 = Child()
#访问保护属性
# print(p._min, c1._min)
# p._protectmake()
# c1._protectmake()

#私有属性：
#只能类内部自己访问，子类都不能访问

#访问私有属性
# print(p.__max, p.__desc)
# p.show()
# c1.show()

#python中的私有是一种伪私有
#查看属性p的命名空间
# print(p.__dict__)
#self.__desc  --> self._P__desc
# print(p._P__desc)

#在类的内部看到双下划线开头的方法或者属性
#会在对变量名做一层转换 -- 》 __max -->_类名__max

#以双下划线开头和以双下划线结尾的属性或方法在python中是有特殊含义的
# __dict__ 查看命名空间
# __name__ 类名
print(P.__name__)
#__class__ 查看对象属于哪个类
print(p.__class__)
#__module__ 查看所在模块
print(P.__module__)
#__doc__ 文档注释
print(P.__doc__)
# print(help(P))

静态方法和类方法

#属性：  对象的描述信息 （数据）
#静态属性  -- 类属性
#普通属性  -- 实例属性

#方法   （函数）
#实例方法
#静态方法
#类方法

class A:
    name = "ATM"
    def __init__(self):
        self.country = "china"

    #普通（实例）方法
    #第一个参数代表实例本身
    def normal_method(self,name):
        print("normal:")
        print(self.name, name)

    #类方法
    #第一个参数代表类
    @classmethod
    def class_method(cls,name):
        print("classmethod:")
        print(cls)

    @staticmethod
    def static_method(name):
        print("staticmethod:")

a1 = A()

#############实例方法，静态方法，类方法都能通过实例去调用
# a1.normal_method("a1")
# A.normal_method(a1,"a1")
# a1.class_method("a1")
# a1.static_method("a1")

#可以通过类名去调用 类方法和静态方法
#调用实例方法 ，必须要传入一个实例对象
A.class_method("A")
A.static_method("A")
A.normal_method(a1,"A")

self详解

#self 表示实例本身
#self 不必非写成self

# class A:
#     name = "sc"
#     age = 4
#
#     def info(self, sex):
#         print(f"我是:{self.name}, 今年{self.age}岁， 性别{sex}")
#         print(self)
#         print(id(self))
#
#     def info2(this):
#         print(f"this is {this}")
#
#     # 放在类空间的普通函数
#     def info3():
#         print("this is none")
# a = A()
# print(id(a))

#在python解释器内部，我们调用a.info()时，实际上运行的是A.info(a),也就是把对象a传给了self
# a.info("man")
#实际上运行：
# A.info(a,"man")
#
# a2 = A()
# print(id(a2))
#
# # a2.info("fmale")
# A.info(a2, "fmale")

# a.info2()  #-- > A.info2(a)
# a.info3()  #-->A.info3(a)
# A.info3()

#1、self代表实例本身
#2、self名字不是强制规定的，大家都约定俗成用self来表示
#3、方法中可以不传入self，如果不写的话不能使用对象调用
#4、实例调用方法的时候，默认就会把当前实例传给self，不需要手动传入

class Parent:
    def pprt(self):
        print(self)

class Child(Parent):
    def cprt(self):
        print(self)

c = Child()
c.cprt()
c.pprt()

python多态

#在面向对象语言中，接口的多种不同的实现方式即为多态。
# 多态性的好处
# • 增加了程序的灵活性
#     • 以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
# • 增加了程序额可扩展性
#     • 通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用
#     •多态：同一种事物的多种形态，动物分为人类，猪类（在定义角度）
#     • 多态性：一种调用方式，不同的执行效果（多态性）
# • 实现接口重用

#python的多态
#python里不支持多态， python处处是多态


#支付接口
#支付宝
#微信
#银行卡

# if zhifubao:
#     zhifubao.pay()
# if weixin:
#     weixin.pay()
class moneypay():
    pass
class zhifubao(moneypay):
    def pay(self):
        print("this is zhifubao pay")
class weixin(moneypay):
    def pay(self):
        print("this is weixin pay")
class yinhangka(moneypay):
    def pay(self):
        print("this is yinghangka pay")

zhi = zhifubao()
wei = weixin()
ying = yinhangka()

def pay(obj):
    obj.pay()

###############java
#def pay2(a string):
#   print(a)

#def pay(obj moneypay):
    # obj.pay()

#python中不支持多态  语法上的多态  不需要额外实现多态代码
#按照多态的语法 不属于多态（父类作为参数，传递子类对象）

#python 里处处是多态 python是一个多态类型语言，本身就实现了多态，崇尚鸭子类型

#不关心对象是什么类型，到底是不是鸭子，只关心行为