python（私有属性，方法，装饰器，封装继承多态，工厂模型，单例模型）

python方法中没有重载，不要使用重名的方法，会直接覆盖掉

私有属性和私有方法（实现封装）

两个下划线开头的属性是私有属性。

class Employee:

    def __init__(self,name,age):

        self.name = name
        self.__age = age #私有属性
    def __work(self):#私有方法
        print("好好工作")
      
e = Employee("高琪",18)
print(e.name)
print(e._Employee__age)#私有方法调用方法
e._Employee__work()#私有方法调用方法

@property装饰器

@property可以将一个方法的调用方式变成"属性调用"

class Employee:
    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary
 
    def get_salary(self):
        return self.__salary
    def set_salary(self,salary):
        if 1000<salary<50000:
            self.__salary = salary
        else:
            print("录入错误")

e = Employee("高琪",30000)
print(e.get_salary())
e.set_salary(2000)
print(e.get_salary())

使用@property装饰器

class Employee:
    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary

    @property
    def salary(self):
        return self.__salary
    @salary.setter
    def salary(self,salary):
        if 1000 < salary < 50000:
            self.__salary = salary
        else:
            print("录入错误")

e = Employee("高琪",30000)
e.salary = 2000  #区别就是可以直接想调用属性一样直接调用
print(e.salary)

面向对象三大特征

封装：隐藏对象的属性和实现的细节，支队外提供必要的方法
继承：子类具有父类的特性
多态：

继承

python支持多继承，一个子类可以继承多个父类
格式：
class 子类类名（父类1，父类2…）
如果定义中没有指定的父类，则默认父类为object类，也就是object是所有类的父类，里面有定义了所有类共有的默认实现。

类成员的继承和重写
子类可以重新定义父类中的方法，这样就会覆盖父类的方法。

多态

同一方法调用，但是由于对象不同肯能会产生不同的行为

class Man:
    def eat(self):
        print("饿了，吃饭啦")
class Chinese(Man):
    def eat(self):
        print("筷子")
class English(Man):
    def eat(self):
        print("叉子")
def manEat(m):
    if isinstance(m,Man):#如果m是Man的子类的话
        m.eat()
    else:
        print("不能吃饭")
manEat(Chinese())#多态
manEat(English())#多态

组合

#使用继承实现代码的复用
class A1:
    def say_a1(self):
        print("a1,a1,a1")
class B1(A1):
    pass

b1 = B1()
b1.say_a1()

#使用组合实现复用
class A2:
    def say_a2(self):
        print("a1,a1,a1")
class B2:
    def __init__(self,a):
        self.a = a
a2 = A2()
b2 = B2(a2)
b2.a.say_a2()

设计模式

工厂模式
当程序运行输入一个“类型”的时候，需要创建于此相应的对象。这就用到了工厂模式。

class CarFactory:
    def create_car(self, brand):
        if brand == "奔驰":
            return Benz()

        elif brand == "宝马":
             return BMW()

        elif brand == "比亚迪":
            return BYD()
        else:
            return "无法识别"
class Benz:
    pass
class BMW:
    pass
class BYD:
    pass
factory = CarFactory()
c1 = factory.create_car("奔驰")
print(c1)

单例模式
“我们在使用class创建类的时候, 只会创建一个类对象, 但是, 当我们实例化这个类对象的时候, 一个类对象, 可以实例化出很多不同的对象, 而我们每次实例化出来一个对象, 就会在内存中重新分配一块空间, 单例模式, 就是为了解决上述问题, 使得由一个类对象所实例化出来的全部对象都指向同一块内存空间.”

原理：重写__new__()这个方法, 让他在第一次实例化一个对象之后, 分配一块地址, 在此后的所有实例化的其他对象时, 都不再分配新的地址, 而继续使用第一个对象所被分配的地址, 因此, 我们可以在类对象里, 定义一个类属性, 初始值设为None, 如果这个值是None就调用父类的__new__()方法, 为其分配地址, 并返回这个地址(__new__方法一定要返回一个地址)