面向对象三大特性之多态以及封装

面向对象的三大特性之多态

什么是多态

Animal类表现出了Dog，Cat两种形态

class Animal:pass
class Dog(Animal):pass
class Cat(Animal):pass

class Payment:pass
class Alipay(Payment):
    def pay(self):pass
class Applepay(Payment):
    def pay(self):pass
def pay(obj,money):
    obj.pay()
app=Applepay()
print(type(app))
pay(app,123)
alp=Alipay()
pay(alp,456)

java中运用多态来解决传参数时候  数据类型的规范问题 

str  就是一个类 

a = ‘123’

a = str('123')　　str是一个类，str()就是实例化，a是一个对象，是str类的对象，a的type 就是str

什么是多态呢？

一个类表现出的多种形态：通过继承来实现的

在java中的表现：在一个函数中需要给参数指定数据类型，如果这个地方可以接受两个以上类型的参数，

　　　　　　　　那么这些数据类型应该有一个父类，这个父类是所有子类对象的类型

def func(Cat mao):pass
def func(Dog gou):pass
def func(Animal gou|mao):pass

在python中：函数的参数不需要指定数据类型，所以我们也不需要通过继承的形式来统一一组类的类型，

　　　　　　换句话说   所有的对象其实都是object类型，所以在python当中其实处处是多态。

def func(a)：　　a既可以传猫也可以传狗类型，随便传任意类型

鸭子类型：不是明确的通过继承实现的多态，而是通过一个模糊的概念来判断这个函数能不能接受这个类型的参数

def len(obj)

len()     str、list、tuple、dict、set、range()

print()　　所有的对象都是鸭子类型

面向对象的三大特性之封装

广义上的封装

class 类名：

　　def 方法1(self)：pass

是为了只有这个类的对象才能使用定义在类中的方法

狭义上的封装

把一个名字藏在类中

class Goods:
    __discount = 0       #私有的静态变量
    print(__discount)       #在内部可以调用
print(Goods.__discount)     #在外部不可以调用

类中的静态变量和方法名在程序加载的过程中就已经执行完了，不需要等待调用

在这个类加载完成之前，Goods这个名字还没有出现在内存空间中

私有的静态属性可以在类的内部使用，用来隐藏某个变量的值

class Goods:
    __discount = 0    #私有的静态变量
       #变形：_类名__私有变量
print(Goods.__dict__)
print(Goods._Goods__discount)

class Goods:                              
    __discount = 0.7    #私有的静态变量          
    def __init__(self,name,price):        
        self.name=name                    
        self.__price=price                
    def price(self):                      
        return self.__price*Goods.__discou
    def change_price(self,new_price):     
        if type(new_price) is int:        
            self.__price = new_price      
apple=Goods('APPle',5)                    
print(apple.price())            #3.5      
apple.change_price(10)                    
print(apple.price())             #7.0     

class User:
    def __init__(self,username,password):
        self.user=username
        self.__pwd=password
        self.pwd=self.__getpwd()
    def __getpwd(self):
        return hash(self.__pwd)
obj=User('wang','wang123')
print(obj.user,obj.pwd) 
#wang   6040613234356822785

类中的私有成员：

　　私有的静态属性

　　私有的对象属性

　　私有的方法

为什么要定义私有变量？

　　不想让别人看到这个值

　　不想让别人修改这个值

　　让别人在修改这个值的时候加一些限制

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

私有变量不能在外部定义

私有变量不能被继承

class A:
    __country = 'China'
    def __init__(self,name):
        self.__name=name    #'_A__name'
class B(A):
    # print(__country)
    # NameError: name '_B__country' is not defined
    def get_name(self):
        return self.__name    #'_B__name'
b=B('alex')
print(b.__dict__)   #{'_A__name': 'alex'

广义上的封装：把属性函数放到类里

狭义上的封装：定义私有成员