多态与封装

多态

什么是多态？

一种事物/一个类的多种形态。

例如：动物有多种形态：人、猪、狗；文件有多种形态：执行文件、文本文件；水有多种形态：液态水、固态水、水蒸气

import adc
class File(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def click(self):
        pass
    
class Text(File):
    def click(self):
        print('open file')
        
    
class ExeFile(File):
    def click(self):
        print('execute file')

多态性：多个不同类对象响应同一个方法，返回不同的结果

多态性的好处？

1、增加了程序的灵活性：以不变应万变，不论对象千变万化，使用者都是同一种方式去调用。如：fun(animal)

2、增加了程序的可扩展性：通过继承Animal类创建一个新类，使用者无需更改代码，还是用fun(animal)调用

'''多态性：一种调用方式，不同的执行效果（多态性）
    def func(obj):
        obj.run()
    func(peo1)
    func(pig1)
    func(d1)
    
    # 多态性依赖于：继承
	# 多态性：定义统一的接口
'''

class Cat(Animal):  # 属于动物的另外一种形态：猫
    def talk(self):
        print('say miao')

def func(animal):  # 对于使用者来说，自己的代码根本无需改动
    animal.talk()

cat1 = Cat()  # 实例出一只猫
func(cat1)  # 甚至连调用方式也无需改变，就能调用猫的talk功能

多态小结

多态：同一种事物的多种形态，动物分为人类，猪类（在定义角度）
多态性：一种调用方式，不同的执行效果（多态性）

封装

什么是封装？

隐藏对象的属性和实现细节，仅对外提供公共访问方式

先装后封：

​ 装：把数据和方法装到类里面。

​ 封：把类里面的数据和方法封起来，不让人访问。

封装原则：将不需要对外提供的内容都隐藏起来。把属性都隐藏，提供公共方法对其访问。

为什么要封装：

1、保护隐私，比如：你买了个充气娃娃，你能让人知道吗？这时候就把你买的娃娃封装起来，然后自己偷偷用。

2、隔离复杂度，比如：你有尿尿这个功能（方法），你不需要知道你尿是经历了多少化学反应才流出来的，你只需要掏出你的接口直接用尿这个功能就行，这不就隔离了复杂度嘛。

封装的两个层面：

无论那种层面的封装，都要对外界提供接口，访问你内部隐藏的内容。使用者都只能通过这个接口访问。

1、创建类和对象会分别创建二者的名称空间，我们只能使用类名.或者对象.的方式访问名称空间里面的名字，这本身就是一种封装。

2、把某些属性隐藏起来（或者说定义成私有的），只在类内部使用，外部无法访问。或者留下少量接口，供外部访问。

重要：在python中，使用双下划线 __的方式实现隐藏属性（设置成私有）

重要：类中所有双下划线开头的名称如 __X 会自动变形 _类名__X 的形式

私有属性：用双下划线开头的属性

class A:
    __N = 0   #变形为_A__N
    def __init__(self):
        self.__X = 10   #变形成self._A__X
    
    def __foo(self):   #变形成：_A__foo
        pass
    
    def bar(self):
        self.__foo()   #只有在类内部可以通过__foo访问。
        
#注意：A.__N访问不到，A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形  

print(A.__dict__) # {'__module__': '__main__', '_A__N': 0, '__init__': <function A.__init__ at 0x1005704d0>, '_A__foo': <function A.__foo at 0x100570830>, 'bar': <function A.bar at 0x1004c2b00>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}

print(A._A__N)  # 0 
a = A()
print(a._A__N)  # 0 
print(a.__N) # AttributeError: 'A' object has no attribute '__N'

自动变形的特点：

​	1、类中定义的 __x 只能在内部使用，如 self.__x, 引用的就是变形的结果
​	2、这种变形是针对外部的变形，在外部无法通过 self.__x 这个名字访问到。
​   3、在类中定义的 __x 不会覆盖父类定义的 __x, 因为子类中的 __x 变形成了 _子类__x, 父类中的 __x 则变形成了 _父类__x 
所以子类定义的私有属性是无法覆盖父类的。因为变形成了不同的属性

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

class A:
	def __fa(self): #在定义时，变形为_A__fa
		pritn('from A')
	def test(self):
		self.__fa()   #类内部调用自己的私有方法，实际上为self._A__fa()
        
class B(A):
    def __fa(self):
        print('from B')
        
b = B()
b.test()  # from A

封装在于明确区分内外，让类使用者可以修改封装内的东西而不影响外部调用。

#类的设计者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area


#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
        return self.__width * self.__length * self.__high

#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()

property属性

什么是property属性？

property属性是一种特殊的属性。使用@property装饰器可以将一个函数当做数据属性来使用。

class A:
    def __init__(self, w, h):
        self.__w = w
        self.__h = h

    @property
    def bmi(self):
        return self.__w / self.__h ** 2

a = A(67, 1.76)
print(a.bmi) # 21.62964876033058

import math
class Circle():
    def __init__(self, radius):
        self.__radius = radius

    @property
    def area(self):
        return math.pi * self.__radius ** 2

    @property
    def perimeter(self):
        return 2 * math.pi * self.__radius


c = Circle(10)
print(c.area)
print(c.perimeter)

#注意：此时的特性area和perimeter不能被赋值
c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

为什么要用property?

将一个类的函数定义成特性以后，对象使用的时候obj.name，根本无法察觉自己的name是执行了一段函数然后就算出来的。这种特性的使用方式遵循了统一访问的原则。

property属性是无法修改的。python中提供了 @定义成特性的函数.setter 装饰器来修改，提供了 @定义成特性的函数.deleter 装饰器来防止删除。

class Foo:
    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError('输入的名字必须是字符串类型的')
        self.__name = value

    @name.deleter
    def name(self):
        raise TypeError('特性name不能被删除')


f = Foo('大帅比')
print(f.name)

f.name = '我是你爹'
print(f.name)

f.name = 10  #TypeError: 输入的名字必须是字符串类型的

del f.name  # TypeError: 特性name不能被删除

'''
	注意：只有在函数被 @property 装饰器修饰成一个特性以后，才能使用 函数名。setter, 函数名.dellter
'''

@classmethod

类的绑定方法，当类里面的函数不需要用到对象的属性时可以使用类绑定方法

class Classmethod_Demo():
    role = 'dog'

    @classmethod
    def func(cls):
        print(cls.role)

Classmethod_Demo.func()

@staticmethod

静态方法，当类里面的函数不需要用到类属性、对象属性时，可以使用静态方法

class Staticmethod_Demo():
    role = 'dog'

    @staticmethod
    def func():
        print("当普通方法用")

Staticmethod_Demo.func()