python_面向对象-多态封装

一、多态

　　什么是多态？

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

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

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

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

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

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

from abc import ABCMeta,abstractmethod
class Anmial(metaclass=ABCMeta):
    def __init__(self,name):
        self.name = name

    @abstractmethod
    def eat(self):pass

class Dog(Anmial):

    def eat(self):
        print('%s狗粮' %(self.name))

class Cat(Anmial):

    def eat(self):
        print('%s狗粮' % (self.name))

d = Dog('小黑狗')
c = Cat('小花猫')

d.eat()
c.eat()

View Code

　　鸭子类型？

　　　　不是明确的通过继承实现的多态

　　　　而是通过模糊的概念来判断这个函数能不能接收这个类型的参数　

二、封装

　　广义的封装

　　　　class A:

　　　　　　def f(self):pass

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

　　狭义上的封装

　　　　class Foo:

　　　　　　__count = 0 #私有的静态属性

　　　　　　def __f(self):pass #私有的静态方法

　　　　print(Foo.__count) #报错

　　　　在类的外部不能引用私有的静态变量

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

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

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

class Goods:
    __discount = 0.7

    def __init__(self,name,price):
        self.name = name
        self.__price = price

    def price(self):
        return self.__price * self.__discount

    def changePrice(self,new_price):
        if type(new_price) is int:
            self.__price = new_price
        else:
            print('价格修改不成功')

g = Goods('apple',5)
print(g.price())
g.changePrice('aaa')
print(g.price())
g.changePrice(10)
print(g.price())

View Code

　　类中的私有成员

　　　　私有静态属性

　　　　私有对象属性

　　　　私有静态方法

　　为什么定义私有变量？

　　　　我不想让你看到这个值

　　　　我不想让你修改这个值

　　　　我想让你修改这个值的时候受到限制，保证数据的安全性

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

三、内置函数补充

　　1、property是一个装饰器函数，将一个方法伪装成属性

from math 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(10)
print(c1.area)
print(c1.perimeter)
c1.r = 5
print(c1.area)
print(c1.perimeter)

View Code