Python面向对象之三:类空间与对象空间及类间关系

Python面向对象之三:类空间与对象空间及类间关系

一、类空间与对象空间

1、相关定义

1、类空间:创建一个类就会创建一个类的名称空间,用来存储类中定义的所有类变量,这些类变量称为类的属性

2、类的属性:分为静态属性和动态属性,静态属性是直接在类中定义的变量,动态属性是类中定义的方法

3、对象空间:创建(实例化)一个对象就会创建一个对象的名称空间,以对象名创建的变量,称为对象的属性。

2、类和对象的添加属性及查询顺序
1、类的查询顺序
class Person():

    animal = '高级动物'
    soul = '有灵魂'


    def __init__(self, country, name, sex, age, hight):
        self.country = country
        self.name = name
        self.sex = sex
        self.age = age
        self.hight = hight

    def eat(self):
        print('%s吃饭' % self.name)

    def sleep(self):
        print('睡觉')

    def work(self):
        print('工作')

Person.language = '语言'
print(Person.animal)#高级动物
print(Person.language)#语言
print(Person.eat)#<function Person.eat at 0x00000219B7714E50>

分析:
1、类的属性不仅可以在类内部添加,还可以在类的外部添加,如language属性就在类外部添加
2、查找顺序:先从本类空间找,如果找不到,再从父类找…

2、对象的查找顺序
class Person():

    animal = '高级动物'
    soul = '有灵魂'
    name = '如花'

    def __init__(self, country, name, sex, age, hight):
        self.country = country
        self.name = name
        self.sex = sex
        self.age = age
        self.hight = hight

    def eat(self):
        print('%s吃饭' % self.name)

    def sleep(self):
        print('睡觉')

    def work(self):
        print('工作')

mother = Person('China', '围裙妈妈', '女', 35, 172)
print(mother.name)#围裙妈妈      对象中有,首先调用对象自己的
print(mother.animal)#高级动物    对象中没有,去类中查找

mother.buy = '买买买'
print(mother.buy)#买买买, 在类外部添加属性

mother.soul = '母性灵魂'
print(mother.soul)#母性灵魂  对象只能改自己在类中的属性
print(Person.soul)#有灵魂    对象不能修改类的属性

分析:
1、对象的属性可以在__init__里面添加,也可以在类的其他方法或者类的外面添加。
2、在对象中修改类的属性只会修改对象本身的属性,不会修改类的属性。
3、对象的查找顺序:先从对象空间找,如果找不到,再从类空间找,再找不到,再从父类找…

3、实例化对象的过程

1、在内存中开辟了一个对象空间。
2、自动执行类中的__init__方法,并将这个对象空间(内存地址)传给了__init__方法的第一个位置参数self。
3、执行__init__ 方法给对象空间封装属性。

图解:

在这里插入图片描述

二、类间关系

1、依赖关系

执行某个动作的时候, 需要另一个动作来帮助你完成这个操作, 此时的关系是最轻的, 随时可以更换另外一个动作来完成此操作

以某个对象为主体,主体要使用副体的某个功能,任何的对象只要拥有这个功能的,都能成为这个副体, 那么主体与副体的关系就是依赖关系

class Person():
    def play(self, tools):
        tools.run()
        print('play game!')

class Computer():
    def run(self):
        print('电脑已经打开!')

class Phone():
    def run(self):
        print('手机已经打开')

c = Computer()
p = Phone()
me = Person()
me.play(c)
# 电脑已经打开!
# play game!
me.play(p)
# 手机已经打开
# play game!

分析:人玩游戏依赖于电脑或者手机,所以执行人玩游戏这个动作,需要电脑中的打开电脑动作或手机的打开手机动作来完成,打开电脑和打开手机这个动作在完成人玩游戏这个动作是可以替换的。Person的一个功能是Computer或者Phone的run方法。

2、关联关系

两种事物必须是互相关联的,但是在某些特殊情况下是可以更改和更换(对象里面包含对象)

主体的某个属性是一个对象(副体) ,这个对象在赋值给主体的属性之后,相当属于主体的一部分,如果主体要使用副体的功能可以直接通过属性找到该对象之后,进行功能的调用就可以了

1、一对一的关系:

class Boy:

    def __init__(self, name,  girlFriend = None):
        # 在初始化的时候可以给一个对象的属性设置成另一个类的对象
        self.girlFriend = girlFriend  # 一个男孩有一个女朋友

    def chi(self):
        if self.girlFriend:
            print(f"带着他的女朋友{self.girlFriend.name}去吃饭")
        else:
            print("单身狗, 吃什么吃? 滚去学习.")

    def movie(self):
        if self.girlFriend:
            print(f"带着他的女朋友{self.girlFriend.name}去看电影")
        else:
            print("单身狗, 看什么看? 滚去学习.")


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

b = Boy('华仔')
b.chi()#单身狗, 吃什么吃? 滚去学习.
b.movie()#单身狗, 看什么看? 滚去学习.

g1 = Girl('大S')
g2 = Girl('小S')

#给华仔介绍个女朋友
b.girlFriend = g1
b.chi()#带着他的女朋友大S去吃饭
b.movie()#带着他的女朋友大S去看电影

#给华仔换个女朋友
b.girlFriend = g2
b.chi()#带着他的女朋友小S去吃饭
b.movie()#带着他的女朋友小S去看电影

分析:Boy类的一个属性是Girl。

2、一对多的关系:

class School:
    def __init__(self, name):
        self.teach_list = []
    def zhaopin(self,teach):
        self.teach_list.append(teach)
    def shagnke(self):
        for t in self.teach_list:
            t.work()
class Teacher:
    def   __init__(self, name):
        self.name = name
    def work(self):
        print(f'{self.name}在上课')
x = School('xxx学校')
t1 = Teacher('教师1')
t2 = Teacher('教师2')
t3 = Teacher('教师3')
t4 = Teacher('教师4')

x.zhaopin(t1)
x.zhaopin(t2)
x.zhaopin(t3)
x.zhaopin(t4)

x.shagnke()
'''
教师1在上课
教师2在上课
教师3在上课
教师4在上课
'''

分析:School类的一个属性是Teacher类。

3、聚合关系

聚合(aggregation):指的是整体与部分的关系。通常在定义一个整体类后,再去分析这个整体类的组成结构。从而找出一些组成类,该整体类和组成类之间就形成了聚合关系。需求描述中“包含”、“组成”、“分为…部分”等词常意味着聚合关系。

比如电脑,电脑⾥有CPU、硬盘、内存等等,电脑挂了,CPU还是好的,还是完整的个体。

class Cpu(object):

    def __init__(self):
        self.type = '286'

class Computer(object):

    def __init__(self, cpu):
        self.cpu = cpu  # 有一个CPu类的实例对象

    def __del__(self):
        print ("没有权力和Cpu by by!")

old_cpu = Cpu()
old_computer = Computer(old_cpu)
del old_computer

分析:old_computer对象被删除的时候,old_cpu对象不会被删除,这种关系就是聚合

4、组合关系

组合(composition):也表示类之间整体和部分的关系,但是组合关系中部分和整体具有统一的生存期。一旦整体对象不存在,部分对象也将不存在。部分对象与整体对象之间具有共生死的关系。

将一个类的对象封装到另一个类的对象的属性中,就叫组合。

class Cpu(object):

    def __init__(self):
        self.type = '286'


class Computer(object):

    def __init__(self):
        self.cpu = Cpu()  # 包含CPu类的实例对象

    def __del__(self):
        print ("Cpu by by!")

old_computer = Computer()
del old_computer

分析:old_computer对象被删除,同时在old_computer对象内部一起创建的Cup也会被删除,这种同生共死的关系就是组合。

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页