私有属性和私有方法、@property装饰器、面向对象三大特征、类的继承和重写、object根类、多重继承、特殊属性、组合

方法的动态性（方法是可以在外部进行改变的）

class Person:

    def work(self):
        print("好好上学！")


def play_game(s):
    print(f"{s}在玩游戏")

def work2():
    print("努力学习知识，毕业后找到一个好工作！")

p = Person()
p.work()
# p.play_game()   # 没法用，因为Person中没有play_game()这个属性
Person.play = play_game    # 在Person中添加了play_game的属性
p.play()

p.work = work2    # 在Person中更改了work方法为work2

p.work()

添加或者更改类中的方法时，不加括号！

# 测试私有属性
class Employee:

    def __init__(self, name, age):
        self.name = name
        self.__age = age


e = Employee("TGZ", 25)
print(e.name)
print(e._Employee__age)
print(dir(e))

# @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("录入错误！请输入1000--50000之间的数字!")

'''
    def get_salary(self):
        return self.__salary

    def set_salary(self, salary):
        if 1000<salary<50000:
            self.__salary = salary
        else:
            print("录入错误！请输入1000--50000之间的数字!")
'''



emp1 = Employee("TGZ", 30000)
# print(emp1._Employee__salary)
# print(emp1.get_salary())
# emp1.set_salary(2000)
# print(emp1.get_salary())

print(emp1.salary)
emp1.salary = 20000
print(emp1.salary)

# 测试继承
class Person:

    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def say_age(self):
        print("年龄是不能随便说出来的！")

class Student(Person):

    def __init__(self, name, age, score):
        Person.__init__(self, name, age)    # 必须显式地调用父类初始化方法，不然解释器不会去调用
        self.score = score

# Student-->Person-->object类
print(Student.mro())

s = Student("TGZ", 25, 90)
s.say_age()
print(s.name)
print(s._Person__age)
print(dir(s))

# 重写object()中的__str__()

class Person:

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

    def __str__(self):
        return f"名字是：{self.name}"

p = Person("TGZ")
print(p)

多重继承可以实现，但是不推荐，因为会将整体地结构弄得很复杂

重写上面的方法，就实现了重载

# 测试has-a 的关系，使用组合

class MobilePhone:
    def __init__(self, cpu, screen):
        self.cpu = cpu
        self.screen = screen

class CPU:
    def calculate(self):
        print("算你个锤子12345!")
        print("CPU对象：", self)


class Screen:
    def show(self):
        print("显示一个好看的图片")
        print("Screen 对象：", self)

m = MobilePhone(CPU(), Screen())
m.cpu.calculate()
m.screen.show()

# 测试工厂模式

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("奔驰")
c2 = factory.create_car("宝马")
c3 = factory.create_car("比亚迪")
print(c1)
print(c2)
print(c3)

# 测试单例模式

class MySingleton:

    __obj = None        # 类属性？
    __init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:
            cls.__obj = object.__new__(cls)

        return cls.__obj

    def __init__(self, name):
        if MySingleton.__init_flag:
            print("init...")
            self.name = name
            MySingleton.__init_flag = False

a = MySingleton("aa")
b = MySingleton("bb")
print(a)
print(b)
c = MySingleton("cc")
print(c)