python之面向对象的关系

类外面可以给对象封装属性

class A:
        
        address = '美丽富饶的沙河'
        
        def __init__(self, name):
                        self.name = name
        def func(self):
        if self.name == 'dsb':
                        self.skins = '吉利服'

obj = A('dsb')
# 类外面可以给对象封装属性
respons = input('太白帅不帅!')
if respons == '帅':
                obj.weapon = 'AWM'
                
print(obj.__dict__)

类内部封装属性

obj.func()
print(obj.__dict__)

A.teamp = '39.5'
print(A.__dict__)
obj = A('dsb')
# A.func1(111)
A.func1(obj)
print(A.__dict__)

空间角度研究类

class Person:

    mind = '有思想'
    language = '会使用语言'

    def __init__(self, name, age):

        self.name = name
        self.age = age

    def work(self):
        print('人类一般都需要工作')

p1 = Person('dsb', 21)
del p1.mind  # 报错
# print(p1.mind)
# p1.mind = '无脑'
# print(p1.mind)
# print(Person.mind)

注意: 对象无法改变类中的属性,对象只能查询或调用类里面的内容,但是不能改变,

类是一个公共区域,所有对象只能使用公共区域里面的东西,但是不能改变这些东西

类内部的各个对象是相互独立的(除去组合这种特殊的关系之外),各个对象之间是不能相互引用或者改变的,但是也可以产生关系:

对象取值顺序

对象如果想要查询一个属性: 对象空间>类空间>父类空间

类取值顺序

类查询一个对象: 类空间>父类空间

单向不可逆原则

二、类与类之间的关系

一般的关系不可能是一个

类与类之间是可以产生关系的

python中的三种关系:

1.依赖关系(主从关系)

# 大象自己进冰箱

# 大象类
class Elephant:

                def __init__(self, name):
                                self.name = name
                
                def open(self,ref1):
                                print('大象默念三声: 芝麻开门')
                                ref1.open_door()
                def close(self):
                                print('大象默念三声: 芝麻关门')
                                
# 冰箱类
class Refrigerator:
                
                def __init__(self, name):
                                self.name = name
                                
                def open_door(self):
                                print('冰箱门被打开了...')
                                
                def closer_door(self):
                                print('冰箱门被关闭了...')
        
ele = Elephant('齐齐')
ref = Refrigerator('美菱')
ele.open(ref) # 这一步是关键,将ref这个类传入到Elephant的方法open中

依赖关系:就是将一个类的类名或者对象传给另一个类的方法中

练习题:

实现两个
大象执行open方法:
显示:'哪个大象 大象默念三声:芝麻开门'
显示:'哪个冰箱门,冰箱门被打开了'
# 大象类
class Elephant:

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

        def open(self,ref1):
                # print(ref1)
                print(f'大象{self.name}默念三声: 芝麻开门')
                # ref1.open_door()
        def close(self):
                print('大象默念三声: 芝麻关门')


# 冰箱类
class Refrigerator:

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

        def open_door(self,ele1):
                # print(ele1)
                print(f'{self.name}冰箱门被打开了...')


        def closer_door(self):
                print('冰箱门被关闭了...')


ele = Elephant('齐齐')
ref = Refrigerator('美菱')
ele.open(ref)
ref.open_door(ele)
ele1.open(ref)
# 以上代码敲十遍

一句话总结

依赖关系:就是将一个类的类名或者对象传给另一个类的方法中
就是将一个类Refrigerator('美菱')的类名或者实例化后的对象ref传给另一个类Elephant的ele.open方法中

2.组合关系(关联组合聚合)

class Boy:
        
                def __init__(self, name):
                                self.name = name
        
                def meet(self,girl_friend=None):
                self.girl_friend = girl_friend
                
                def have_diner(self):
                                if self.girl_friend:
                        print(f'{self.name}请{self.girl_friend.name}一起吃六块钱的麻辣烫')
        else:
                        print('单身狗,看别人吃')
     
class Girl:
        
        def __init__(self, name, age):
                        self.name = name
                        self.age = age
# 操作1
wu = Boy('吴超')
# wu.have_diner()
# 输出结果
单身狗,吃什么吃
# flower = Girl('如花', 48)

# 操作2
flower = Girl('如花', 48)
# 组合: 将一个类的对象封装成另一个类的对象的属性中
wu.meet(flower)
# 输出结果
吴超请如花一起吃六块钱麻辣烫

敲十遍的练习题

class GameRole: # 定义一个游戏的类

    def __init__(self, name, ad, hp): # 设置默认方法:姓名,攻击力,血量

        self.name = name
        self.ad = ad
        self.hp = hp

    def attack(self,p1): # 设置一个攻击的方法,传入的值是,被攻击人的名字
        p1.hp = p1.hp - self.ad # 传入被攻击人的血量等于被攻击人原来的血量减去攻击人的攻击力
        print(f'{self.name}攻击{p1.name},{p1.name}掉了{self.ad}血,还剩{p1.hp}血') # 这里self.name就是攻击人的名字,p1是被攻击人的名字,被攻击人掉的血也就是是攻击人的攻击力,还剩下的血量是被攻击人之前的血量减去攻击人的攻击力

    def equit_weapon(self,wea):# 定义了一个装备武器的方法,传入的值是
        self.weapon = wea

class Weapon:

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

    def attick(self, p1, p2):
        self.p1 = p1
        self.p2 = p2

        print(f'{self.p1}使用{self.name}攻击了{self.p2},{self.p2}掉了{self.ad}血')

gailun = GameRole('盖伦', 100, 10) #传入一个 盖伦的对象属性
jianhao = GameRole('剑豪', 200, 20)

gailun_gj = Weapon('青龙偃月刀', 20)
jianhao_gj = Weapon('九门大提督枪', 30)

gailun.equit_weapon(gailun_gj) #
jianhao.equit_weapon(jianhao_gj)
gailun.weapon.attick('盖伦', '剑豪')
jianhao.weapon.attick('剑豪', '盖伦')

一句话总结:

依赖关系:   就是将一个类的类名或者对象传给另一个类的方法中
组合关系就是,将一个类的对象封装到另一个类的对象的属性中,以如花为例,将类Girl('如花', 48)的实例化后的对象flower封装到另一个类Boy('吴超')的实例化对象wu的meet属性中,用wu.meet(flower)表示

继承关系

class A:
                pass

class B:
                pass