面向对象的三大特性之多态，封装基础

面向对象的三大特性  ：  继承    多态    封装

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

在python中：因为函数的参数不须要指定数据类型，因此也不须要经过继承的形式来统一一组类的类型

　　换句话说，全部的对象都有有一个共同的父类（object），即类型均可以是object类型，因此python中到处是多态。

在Java中：在一个函数中须要给参数指定数据类型，若是这个地方能够接受俩个以上的类型的参数，那么这些类型都应该定义一个共同的父类，这个父类是因此子类对象的类型。

　　　　就是运用多态来解决传参数的时候，数据类型的规范问题。

　　鸭子类型：指若是看起来像，叫声像鸭子，那么它就是鸭子

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

　　例：利用标准库中定义的各类“与文件相似”的对象，尽管这些对象的工做方式像文件，但他们没有继承内置文件对象的处理方法

封装：

　　封装的好处：将变化隔离；便于使用；提升复用性；提升安全性

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

　　广义上的封装：就是把属性函数（打包）都放在类里，方便类的对象进行调用

　　就是只有这个类实例化的对象才能使用类中的方法

　　狭义上的封装：就是私有的

class Goods:
    __discout = 0   #在类中定义私有的   就是 __变量名    这样的格式
    print(__discout)    #直接打印  0
# print(Goods.__discount)     #报错。说明在类的外部不能直接引用私有的静态变量
print(Goods.__dict__)       #能够经过查看类中的全部属性和方法   找到'_Goods__discout': 0,
print(Goods._Goods__discout)    #打印  出  0　　从编程规范的角度上来讲，咱们不能再类的外部使用
　　　　　　　　　　　　　　　　　　　　　　　　　私有的变量

　　　　类中的静态变量和方法名在程序的加载过程当中就已经执行完了，而不是在调用的时候才加载

　　　　当类中全部的属性加载完以后，才在内存中显示出这个类的名字。

　　　　私有的静态属性能够在类的内部直接使用，它的做用就是为了隐藏某个变量的值

 

class Student:
    def __init__(self,name,age):
        self.__name = name
        self.age = age
    def name(self):     #能够经过方法来查看私有的属性
        return self.__name
l1 = Student("alex",18)
print(l1.name())        #经过调用方法来显示私有变量的内容

class Goods:
    __discount = 0.7
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property       #property 是一个装饰器函数  调用的这个方法的时候就能够再也不方法后面加（）  自我理解
    def price(self):
        return self.__price * self.__discount
    def change_price(self,new_price):
        if type(new_price) is int:
            self.__price = new_price        #私有的变量只能在内部经过方法来进行修改
        else:
            print("本次价格修改不成功")
a1 = Goods("苹果",5)
print(a1.price)    #3.5   #经过装饰器后,这里就能够不加括号
a1.change_price(8)  #调用方法修改私有的变量
print(a1.price)     #5.6

类中的私有成员：

　　私有的静态属性　　(__name = "alex")

　　私有的对象属性　　(self.__name = name)

　　私有的方法　　(父类不想让子类覆盖本身的方法，能够将方法定义为私有的）

class User:
    __nationality = "China"     #私有静态属性
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd        #私有的对象属性
        self.pwd = self.__getpwd()
    def __getpwd(self):         #私有的方法
        return hash(self.__pwd)
    @property
    def nationality(self):
        return User.__nationality
obj = User("alex","alex123")
print(obj.nationality,obj.name,obj.pwd)     #China alex -1388251584925158483

我为何要定义一个私有变量？：

　　我不想让你看到这个值

　　我不想让你修改这个值

　　我想让你在修改这个值的时候有一些限制

　　有些方法或者属性不但愿被子类继承

私有变量不能再外部被定义：

　　例：

class A:
    __county = "China"  #在类的内部会发生变形    变成了_A__county
    print(__county)
A.__Language = "Chinese"    #这个只是在类中增长了一个静态属性
print(A.__dict__)   
print(A.__Language)

私有变量不能被继承（可使用（按照规范又不能这样作））

　　

class A:
    __county = "China"
    def __init__(self,name):
        self.__name = name
class B(A):
    # print(__county)     #报错NameError: name '_B__county' is not defined
    print(A._A__county)     #就是经过类名去调用的
    def get_name(self):
        return self.__name
b = B("alex")
print(b._A__county)     #China
print(b.__dict__)   #{'_A__name': 'alex'}