面向对象基础(三)

# 面向对象继承的主要作用是
# 优化代码,节省代码.
# 提高代码的复用性.
# 提高代码的维护性.
# 让类与类之间发生关系.

# 例：
class Parent:
    def __init__(self):
        self.func()

    def func(self):
        print('Parent')

class Son(Parent):
    def __init__(self):
        self.func()

    def func(self):
        print('Son')

son1 = Son()
# result:Son，继承中优先使用派生类中的方法

class A:
    lst = []


p1 = A()
p2 = A()
p1.lst.append(1)

print(p1.lst,p2.lst,A.lst)

# result:[1] [1] [1]，列表是可变数据类型，这里可以参考函数默认值使用的都是同一块内存地址


class A:
    name = 'Tian'


p1 = A()
p2 = A()
p1.name = 'wuser'

print(p1.name,p2.name,A.name)

# result:wuser Tian Tian str类型是可hash的对象只能访问类的静态字段无法修改

# python中是没有接口这个概念的
# 接口类,抽象类: 制定一个规范。
# 归一化设计

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

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


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

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


apay = Alipay(100)
jpay = Jdpay(200)

apay.pay()
jpay.pay()
# 支付是一个统一的概念，这里明显无法统一,那如何实现统一

def pay(obj):
    obj.pay()
pay(apay)

# 这样是不是看起来统一了，这就是归一化设计抽象类也是借鉴了这个概念

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
        #装饰器 制定一个规范当派生类缺失pay方法时会报错
        @abstractmethod
        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)

apay = Alipay(100)
jpay = Jdpay(200)

# result:TypeError: Can't instantiate abstract class Jdpay with abstract methods pay

# python中没有多态的概念，但他有鸭子类型

# class Str:
#     def index(self):
#         pass

# class List:
#     def index(self):
#         pass
#
# class Tuple:
#     def index(self):
#         pass

# 当三个类中的方法相同时我们称其为鸭子类型

# 广义的封装: 实例化一个对象,给对象空间封装一些属性.
# 狭义的封装: 私有制.
# 私有成员:私有静态字段,私有方法,私有对象属性

class A:
    # 这就是A类的私有静态字段只有在A类内部调用时才能访问，外部无论是派生类还是实例都无法访问
    __money = 1000

a1 = A()

# print(a1.__money)
# print(A.__money)
# 报错，这里有个bug因为python设计的时候会在私有字段前面加类名
print(a1._A__money)
# 这是python设计问题没有人会这么用

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

    def __init__(self):
        self.__func()

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

son1 = Son()

# result:in Parent func

class Person:
    def __init__(self,name,sex,age):
        self.__name = name
        self.__sex = sex
        self.age = age

    def func(self):
        print(self.__name)


p1 = Person(1,2,3)

# print(p1.__name)  报错
p1.func()
# 在类内部执行__name时他会在前面添加_Person

面向对象基础(三)

猜你喜欢