面向对象之初识

函数vs对象

　　面向过程式编程：提高了代码的可读性，减少了代码的重复性

　　面向过程式编程：

　　　　优点：出色的完成你之前布置的所有的需求

　　　　坏处：但凡更改或者增加一条需求，可能整个项目都随之改变

　　面向对象编程（优点）：是一类相似功能函数的集合体，使你的代码更加清晰化合理化

　　类：就是具有相似功能和特性的一类事物

　　对象：类的具体体现

　　类的第二个优点：你要站在上帝的角度上去考虑，类一个公共模板，对象是从这个公共的模板产出的

　　面向对象，要拥有上帝的视角看问题，类其实就是一个公共模板（厂房），对象就从具体的模板实例化出来

　　class是关键字与def用法相同，定义一个类 类名具有描述性，类名首字母大写，类名不易用__

　　类的结构从大方向来说就分为两个部分： 静态变量 动态方法

　　面向对象的结构： 结构上分析：

class Student:
    daily='学习'            #  变量（之前的方法）叫：静态属性，属性   或   静态字段
    examination='考试'
​
    def work(self):         #  函数（之前）   叫：方法，动态方法，       或   动态属性
        print('每天要上课')
​
    def homework(self):
        print('家庭作业')

从类名的角度研究：

　　从类名的角度类名调用类中的属性：

　　　　查看类中所有内容：类名.__ dict__方法。只用于获取类中的全部

class Student:
    daily='学习'            #  变量（之前的叫法）叫：静态属性，属性    或   静态字段
    examination='考试'
​
    def work(self):         #  函数（之前的叫法）叫：方法，动态方法，  或   动态属性
        print('每天要上课')
​
    def homework(self):
        print('家庭作业')
​
# 2.万能的点。
print(Student.daily)   # 查
Student.cloth='校服'    # 增
print(Student.__dict__)
Student.examination='不考试'  # 改
print(Student.examination)
del Student.daily   # 删
print(Student.__dict__)
​
# 如果想查询类中的所有内容，通过__dict__方法，如果只是操作单个属性值这用万能的点

　　类名的角度调用动态方法

　　　　前提：一般不会通过类名操作一个类中的方法。除了两个特殊方法：静态方法，类方法之外，

class Student:
    """
    此类是构建学生类
    """
    daily = '学习'
    examination = '考试'
​
    def work(self):
        print('每天要上课')
        
    def homework(self):
        print('家庭作业')
 
Student.work(123)        #  通过类名调用类中的动态方法，必须要传一个参数否则会报错
Student.homework(456)
Student.__dict__['work'](111)  # Human.__dict__['work']指向函数的内存地址

从对象的角度分析类：

　　实例化过程：类名加上（），这就是一个实例化过程，实例化一个对象的过程

　　实例化一个对象总共发生三件事：

　　　　1.在内存中开辟一个对象空间

　　　　2.自动执行__ init__ 方法，并将这个对象空间（的内存地址）传给了__ init__ 的第一个参数self。

　　　　3.执行__ init__ 方法里面的代码，给对象空间封装属性。

　　对象操作对象中的属性：

　　　　　对象查询对象中所有属性：对象.__ dict__

　　　　　对象操作对象空间属性：

　　　　　万能的点：对象.属性=值 如果属性没有就添加，有且值不相同就修改

　　　　　del 对象.属性 删除某个属性 ​ print（对象.属性 ） 查看某个值

class Student:    #创建一个Student空间  类中的方法和属性依次加载进去
    daily='学习'
    examination='考试'
​
    def __init__(self):
        self.name='小黑'
        self.sex='随便'
​
​
    def work(self):
        print('每天要上课')
​
    def homework(self):
        print('家庭作业')
​
obj=Student()    #  创建一个obj空间，执行__init__
# print(obj)
​
# 对象可以操作对象空间的属性  通过万能的点
​
obj.age=18   # 增
del obj.name # 删
obj.sex='女'   # 改
print(obj.name)  # 查
​
print(obj.__dict__) # 查看对象中的所有内容

　　对象查看类中的属性

　　　　只能查看不能修改

class Student:
​
    daily = '学习'
    examination = '考试'
​
    def __init__(self,n,a,h):
        self.name = n
        self.age = a
        self.hobby = h
​
    def work(self,c):
        # self.color = '绿色'
        self.color = c
        print(f'{self.name}每天要上课')
​
    def homework(self):
        # 利用self 对象空间,为所欲为
        print('家庭作业')
​
# 对象查看类中的属性
sq=Student('骚强',18,'跳唱')
print(sq.daily)
sq.daily='骚麦'    # 这里相当于给sq这个对象添加了一个属性
print(sq.daily)
print(sq.__dict__)  # 修改的是对象中的属性，并没有对类种的daily进行操作
print(Student.daily)  # 类中的daily并没有发生改变

　　对象操作类中的方法

　　　　对象.方法名()

class Student:
    daily='学习'
    examination='考试'
​
    def __init__(self,n,a,h):
        self.name=n
        self.age=a
        self.habby=h
​
​
    def work(self,c):
        self.color=c
        print('每天要上课')
​
    def homework(self):
        print('家庭作业')
​
ly=Student('小黑',21,'学习')
ly.work('黑色')
print(ly.__dict__)
​

　　self是什么

　　　　self 就是类中方法的第一个位置参数，

　　　　如果通过对象执行此方法，解释器就会自动的将此对象空间当做实参传给self

　　　　约定俗称：类中的方法第一个参数一般都设置成self

类的空间问题：

　　何处添加对象属性

　　　　对象的属性不仅可以再__ init__里面添加，还可以在类的其他方法或l类的外面添加

class A:
    def __init__(self,name):
        self.name=name
​
    def func(self,sex):
        self.sex=sex
​
# 类的外面：
obj=A('barry')
obj.age=18
​
print(obj.__dict__)   #{'name': 'barry', 'age': 18}
​
# 类的内部
obj=A('barry')    # init可以添加
obj.func('男')    # func方法也可以
print(obj.__dict__)    #{'name': 'barry', 'sex': '男'}

　　何处添加类的对象属性：

　　　　类的属性不仅可以在外部添加也可以在内部添加

class A:
    def __init__(self,name):
        self.name=name
​
    def func(self,sex):
        self.sex=sex
​
    def func1(self):
        A.bbb='ccc'
​
# 类的外部可以添加,通过类名.属性名=值的形式
A.ccc='taibai'
​
print(A.__dict__)
​
# 类的内部可以添加，通过动态方法添加
A.func1(111)   # 通过类名调用动态方法需要传值
print(print(A.__dict__))

 　　对象如何找到类的属性：

　　　　具体过程：

　　　　　　1.实例化一个对象，产生一个对象空间，此时这个对象空间不是空的而是有一个类对象指针(相当于指示牌)

　　　　　　2.自动执行__ init方法，将对象空间传给self

　　　　　　3.执行__ init__中的代码，给对象空间封装属性 对象之所以可以找到类，是因为对象空间中有类指针这个东西

　　　　执行流程：

　　以下顺序都是单向不可逆的：

　　　　对象查找属性的顺序：先从对象空间中找--------->类空间--------->父类空间中找--------->……

　　　　类名查找属性的顺序：先从本类空间中找--------->父类空间中找--------->……

　　　　对象与对象之间原则上是互相独立（除去组合这种特殊的关系之外）

类与类之间的关系

　　类与类之间的关系：

　　　　1.依赖关系

　　　　2.组合关系

　　　　3.继承关系(类的三大特性之一：继承。)

　　依赖关系(主从关系)

　　　　将一个对象或者类名传递到另一个类的方法中

class Elephant:
    def __init__(self,name):
        self.name=name
​
    def open(self,ref):
        print(f'{self.name}大象默念三声：芝麻开门')
        ref.open_door()
​
    def close(self,ref):
        print(f'{self.name}大象默念三声：芝麻关门')
        ref.close_door()
​
class Refrigerator:
    def __init__(self,name):
        self.name=name
​
    def open_door(self):
        print(f'{self.name}冰箱门被打开了')
​
    def close_door(self):
        print(f'{self.name}冰箱门被关上了')
​
        
ele=Elephant('琪琪')    # 实例化一个大象
ref=Refrigerator('美菱')  # 实例化一个冰箱
ele.open(ref)   
ele.close(ref)

　　组合关系（聚合，组合，关联）

　　　　1.关联关系. 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更改和更换的.

　　　　2.聚合关系. 属于关联关系中的⼀种特例. 侧重点是xxx和xxx聚合成xxx. 各⾃有各⾃的声明周期. 比如电脑. 电脑⾥有CPU, 硬盘, 内存等等. 电脑挂了. CPU还是好的. 还是完整的个体

　　　　3.组合关系. 属于关联关系中的⼀种特例. 写法上差不多. 组合关系比聚合还要紧密. 比如⼈的⼤脑, ⼼脏, 各个器官. 这些器官组合成⼀个⼈. 这时. ⼈如果挂了. 其他的东⻄也跟着挂了

class Boy:
    def __init__(self,name,):
        self.name=name
​
    def meet(self,girl_friend=None):
        self.girl_friend=girl_friend   # 相当于给wu这个对象空间添加一个属性，这个属性值                               # 是flower这个对象空间因此我们可以通过self.gril_friend对                              # flower这个对象空间里面的属性进行操作
​
​
    def have_diner(self):     # self==wu这个对象空间
        if self.girl_friend:
            print(f'{self.name}和{self.girl_friend.name}一起吃六快钱的麻辣烫')
            self.girl_friend.shopping(self)  # self相当于wu这个对象空间
        else:
            print('单身狗，吃什么饭')
class Girl:
    def __init__(self,name,age):
        self.name=name
        self.age=age
​
    def shopping(self,boy):
        print(f'{boy.name}和{self.name}一起去购物')
​
wu=Boy('吴超')
# wu.have_diner()
flower=Girl('如花',32)
wu.meet(flower)   # 把flower这个对象封装给wu这个对象空间
wu.have_diner()

　　组合：将一个类的对象封装到另一个类的对象的属性中，就叫做组合

　　　　一个类的方法只能由此类的方法去调用

　　　　一个类的方法的第一个self只接受此类的对象

class class Gamerole:
    def __init__(self,name,ad,hp):
        self.name=name
        self.ad=ad
        self.hp=hp
​
    def attack(self,p1):
        p1.hp -= self.ad
        print(f'{self.name}攻击了{p1.name},掉了{self.ad}血,还剩{p1.hp}血')
​
    def equip_weapon(self,wea):
        self.wea=wea     # 把武器对象封装给Gamerole这个类，通过类可以对者个属性进行操作，可以调用里面的动态方法和静态属性
​
​
​
class Weapon:
    def __init__(self,name,ad):
        self.name=name
        self.ad=ad
​
    def weapon_attack(self,p1,p2):
        p2.hp -= p1.ad+self.ad
        print(f'{p1.name}利用{self.name}攻击了{p2.name},{p2.name}掉了{self.ad+p1.ad}血，还剩{p2.hp}血')
​
barry = Gamerole('太白',10,200)
panky = Gamerole('金莲',20,50)
pillow=Weapon('绣花枕头',2)
barry.equip_weapon(pillow)   # 把武器装备给对象
barry.wea.weapon_attack(barry,panky)
​
class Gamerole:
    def __init__(self,name,ad,hp):
        self.name=name
        self.ad=ad
        self.hp=hp
​
    def attack(self,role1):
        role1.hp -= self.ad
        print(f'{self.name}攻击了{role1.name},{role1.name}掉了{self.ad}血，还剩{role1.hp}血')
​
    def equip_weapon(self,weap):
        self.weapon=weap    # 组合：相当于把great_seord这个对象封装到gailun这个对象中，                            # 作为gailun的一个属性
​
​
class Weapon:
    def __init__(self,name,ad):
        self.name=name
        self.ad=ad
​
    def weapon_attack(self,p1,p2):
        p2.hp -= self.ad+p1.ad
        print(f'{p1.name}使用{self.name}攻击了{p2.name},{p2.name}掉了{self.ad+p1.ad}血，还剩{p2.hp}血')
​
​
gailun=Gamerole('盖伦',10,100)
zhaoxin=Gamerole('赵信',20,90)
great_sword=Weapon('大保健',30)
# gailun.attack(zhaoxin)
gailun.equip_weapon(great_sword)
gailun.weapon.weapon_attack(gailun,zhaoxin)   # gailun.weapon==grrat_sword