DAY8-方法的动态性、私有属性、私有方法、@property、面向对象、方法的重写、设计模式

方法的动态性

可以动态的为类添加新的方法， 或者动态的修改类的已有的方法。

私有属性

1. 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2. 类内部可以访问私有属性(方法)
3. 类外部不能直接访问私有属性(方法)
4. 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)

私有方法

def __init__(self,name,age):
self.name = name
self.__age = age
def __work(self):
  print("好好工作“）

@property装饰器

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

@property #相当于 salary 属性的 getter方法
def salary(self):
print("月薪为{0},年薪为
{1}".format(self.__salary,(12*self.__salary)))
return self.__salary;

面向对象的三大特征

封装、继承、多态

继承

方法的重写

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    #def say_age(self):
    def say_introduce(self):
        print("我的名字是：{0}".format(self.name))
class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)
        self.score=score
s=Student("miao",18,100)
s.say_introduce()
'''
'''class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say_age(self):
        print(self.name,"的年龄是",self.age)
obj=object()
print(dir(obj))
s2=Person("miao",18)
print(dir(s2))

object（）根类

object 类是所有类的父类，因此所有的类都有 object 类的属性和方法。

重写__str__（）方法

object 有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数 str()
经常用于 print()方法，帮助我们查看对象的信息。str()可以重写。

class Person():
    def __init__(self,name):
        self.name=name
    def __str__(self):
        return"名字是：{0}".format(self.name)
p=Person("miao")
print(p)

多重继承

mro()

MRO（Method Resolution Order）：方法解析顺序。 我们可以通过mro()方法获得
“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。

super()

获得父类的方法：

多态

指同一个方法调用由于对象不同可能会产生不同的行为

class Man:
    def eat(self):
        print("饿了，吃饭啦")
class Chinese(Man):
    def eat(self):
        print("中国人用筷子吃饭")

class English(Man):
    def eat(self):
        print("英国人用叉子吃饭")
class Indian(Man):
    def eat(self):
        print("印度人用左手吃饭")

def Man_eat(m):   #定义的函数
    if isinstance(m,Man):#m是man的子类的话
        m.eat()
    else:
        print("不能吃饭")
Man_eat(English())

特殊方法和运算符重载

class Person:
    def __init__(self,name):
        self.name=name
    def __add__(self, other):
        if isinstance(other,Person):
            return "{0}-{1}".format(self.name,other.name)
        else:
            return "不是同类对象，不能相加"
    def __mul__(self, other):
        if isinstance(other,int):
            return self.name* other
        else:
            return "不是同类对象，不能相乘"
p1=Person("miao")
p2=Person("COCO")
x=p1+p2
print(x)

print(x*30)

特殊属性

对象的浅拷贝、深拷贝

import copy

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)
c1=CPU()
s1=Screen()
m1=MobilePhone(c1,s1)
m2=copy.copy(m1)
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)

m3=copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)

组合

“is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。 “is-a
关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。
has-a”关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU。

设计模式

工厂模式

工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进
行统一的管理和控制。

class CarFactory:
    def createCar(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.createCar("奔驰")
c2=factory.createCar("宝马")
print(c1)
print(c2)

单例模式

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一
个访问该实例的全局访问点。