Day18 python基础---面向对象三大特性---多态、封装

一，多态

　　1.什么是多态：

　　　同一类的事物有多种不同的形态，python中通过继承来实现

　　　由于在python中：函数的参数不需要指定数据类型，所以我们也不需要通过继承的形式来统一一组类的的类型，换句话说，所有的对象其实都是object类型，所以在python当中其实处处是多态。

class Animal:pass  #Animal类表现出了Dog，Cat两种形态
class Dog(Animal):pass
class Cat(Animal):pass

　　2.为什么要把多态单独列出来

class Applepay:
    def pay(self):pass
class Alipay:
    def pay(self):pass

def pay(obj,money):  #两个不同的类复用pay函数
    obj.pay()

　　举例对比java的函数写法：

def func(str name,int age)   #java中，传入参数需要定义参数的数据类型
    print(name,age)
func('str',2)            

#java函数无法简便实现上面类似上面两个不同的类对pay()函数的复用
#java中运用多态来解决参数的时候 数据类型的规范问题
#多态在java中表现：在一个函数中需要给参数指定数据类型，如果这个地方，可以接收两个或多个以上的类型，那么这些类型应该有一个父类，这个父类是所有子类对象的类型

　　3.多态在python中的应用:

　　 object：

　　　　　python新式类中都默认继承object类，所以python中处处使用了多态，传参的时候都有一个共同的父类，所以不需要指定数据类型：

　　　鸭子类型：概念性的，相对的

 # len()：str,list,tuple,dict set range()
 # index() ：str,list,tuple
 # print() ：所有的对象都是鸭子类型

#不是明确的通过继承实现的多态
#而是通过一个模糊的概念来判断这个方法能不能接受这个类型的参数

二，封装

　　1.广义的封装：是为了只有这个类的对象才能使用定义在类中的方法

class 类名:
    def 方法1(self):pass

2.狭义的封装：定义私有属性（把一个名字藏在类中）

class Goods:
    __discount = 0
    print(__discount)
    def func(self):
        print(Goods.__discount)   #私有的静态属性可以在类的内部使用，用来隐藏某个变量的值
#类中的静态变量和方法名在程序加载的过程中就已经执行完了，不需要等待调用
#在这个类加载完成之前，Goods这个名字还没有出现在内存空间中
g = Goods()  
g.func()
#print(Goods.__discount)  #在类的外部不能引用私有的静态变量，否则报错
print(Goods.__dict__)  #变形：_类名__私有变量
print(Goods._Goods_discount)   #编程规范的角度上出发，我们不能在类的外部使用私有的变量

　　3.我们为什么要定义一个私有化变量？

　　　#我不想让你看到这个值

　　　#我不想让你修改这个值

　　　#我想让你在修改这个值得时候做一下限制：保证数据的安全

　　 #有些方法或者属性不希望被子类继承

4.类中的私有成员

#私有的静态属性
class Student:
    def __init__(self,name,age):
        self.__name = name
        self.age = age

    def name(self):
        return self.__name

s = Student('alex',20)
print(s.name())

#私有的对象属性和私有的方法
class User:
    def __init__(self,username,password):
        self.usr = username
        self.__pwd = password  #为对象封装私有化的对象属性，变形为_User__pwd
        self.pwd = self.__getpwd() #为对象封装在类内部经过算法处理后的数据
    def __getpwd(self):          #私有的方法  变形为_User__getpwd
        return hash(self.__pwd)  #哈希算法处理

u = User('alex','alex3417')
# print(u.__pwd)    #在类外部无法访问处理前的私有化的对象属性
print(u.pwd)
# print(u.__getpwd())  #私有的方法，无法被外部调用

#私有变量只能在类内部定义，因为私有变量在类内部会发生变形
#父类的私有变量不能被继承

三，内置函数（装饰器）：

　　1.property：是一个装饰器函数，用来装饰方法的，将一个方法伪装成一个属性

　　2.所有的装饰器函数都怎么用？

　　　　在函数、方法、类的上面一行直接@property（@+装饰器名）

　　3.装饰器的分类：

　　　　#装饰函数

　　　　#装饰方法：property

　　　　#装饰类

class Student:
    def __init__(self,name,age):
        self.__name = name
        self.age = age
    @property #将一个方法伪装成一个属性
    def name(self):
        return self.__name
s = Student('alex',20)
print(s.name)


from cmath import pi
class Circle:
    def __init__(self,r):
        self.r = r
    @property
    def area(self):
        return self.r**2*pi
    @property
    def perimeter(self):
        return 2*self.r*pi
    
c1 = Circle(3)
print(c1.area)
print(c1.perimeter)
c1.r = 5
print(c1.area)
print(c1.perimeter)