依赖：类之间的依赖关系【python】

类之间的依赖关系：

        八股文如下：

依赖关系是最常见的一种关系，是一种使用关系，即一个类的实现(或部分方法的实现)需要另外一个类的协助，所以应尽量避免双向的互相依赖关系；

对象 A 持有对象 B 的引用，对象 A 需要借助对象 B 的协助，假如 A 是一个类，那么 B 可以是局部变量，也可以是类中方法参数，或者对静态方法的调用；(对象 A 可以依赖B，也可以不依赖 B，用到了有 B 的部分方法就依赖了 B)

直接上代码:

首先展示一个简单的类之间的交互：（这里以人狗大战为例）

#类之间的简单交互操作
class Dog:
    def __init__(self,name,breed,attack_val):
        self.name=name
        self.breed=breed
        self.attack_val=attack_val
        self.life_val=100

    def bite(self,person):
        #狗可以咬人，从这里传进来一个人的对象
        person.life_val-=self.attack_val  #狗咬人，人的生命值根据狗的攻击力而下降
        print('狗：',self.name,'咬了人：',person.name,self.attack_val,'滴血。人还剩：',person.life_val,'滴血！！')

class Person:
    role='person'   #人类的角色属性都是人

    def __init__(self,name,sex,attack_val):
        self.name=name
        self.sex=sex
        self.attack_val=attack_val
        self.life_val= 100

    def attack(self,dog):
        #人可以攻击狗，从这里传进来的dog是狗对象
        #人攻击狗，狗的生命值根据人的攻击力下降
        dog.life_val-=self.attack_val
        print('人：',self.name,'打了狗：',dog.name,self.attack_val,'滴血。狗还剩：',dog.life_val,'滴血！！')

#类的实例化,类实例化完之后，变成一个真正的实体--对象
d1=Dog('小贝','柯基',10)

d2=Dog('小金','金毛',20)

p1=Person('小王','男',30)

#两个对象之间的交互，一般通过类方法进行交互
p1.attack(d1)
d1.bite(p1)

'''
类之间的关系包括：
    1、依赖关系：狗和主人的关系
    2、关联关系：和我们的同学
    3、组合关系：人体器官组合---组合关系比聚合关系还要紧密：人如果死亡，这些器官也会随之死亡
    4、聚合关系：电脑配件：如何电脑死了，但是其中的显示器，cpu等都还可以继续操作
    5、继承关系：类的三大特性之一：子承父业
'''
#依赖关系：
#狗和主人的关系，可以理解为一种依赖关系，如果没有主人，狗就可能变成流量狗，可能会死

接下来展示如何实现类之间的依赖关系？

#依赖关系：
#狗和主人的关系，可以理解为一种依赖关系，如果没有主人，狗就可能变成流量狗，可能会死
class Dog:
    def __init__(self,name,sex,age,master):
        self.name=name
        self.sex=sex
        self.age=age
        self.master=master  #这里需要注意的是绑定的是键盘输入的实例，这里的master实例是对象，将人的属性绑定到狗类的实例当中

    def sayhi(self):
        print('hello,my name is %s,my age is %s,%s is my master!!'%(self.name,self.age,self.master.name))

class Person:
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age
'''
一般在构造函数中绑定另一个类的对象可以称之为依赖关系--只能够单向绑定，不能够双向绑定！也就是说只能够一个依赖另一个，不能够双向依赖
    双向依赖一般都代表着   关联关系！！
'''

p1=Person('小王','20','11')
#在狗的实例化当中将对象p1传进d1当中，这种方式就叫做依赖关系
d1=Dog('小贝','公狗','5',p1)
d1.sayhi()

注解：在这里我们可以看到将人的对象传入狗类的构造函数的master实例属性中去，实现了单向的绑定操作，这种操作也称之为依赖关系！！

一般在构造函数中绑定另一个类的对象可以称之为依赖关系--只能够单向绑定，不能够双向绑定！也就是说只能够一个依赖另一个，不能够双向依赖
    双向依赖一般都代表着   关联关系！！

（1）类B以参数的形式传入类A的方法。我个人将它就取名为“参数依赖”。
（2）类B以局部变量的形式存在于类A的方法中。我个人将它就取名为“局部依赖”。
（3）类A调用类B的静态属性或方法。我个人将它就取名为“静态依赖”。
UML图中实现使用一条带有箭头的虚线指向被依赖的类

1、什么是类？

def Dog(name,d_type):{



}

该部分其实就是一个类，类中定义了这些对象的都具备的属性、共同的方法

2、什么是对象？

说简单一点，对象就是实实在在的东西！！---实体

d3=Dog('tiger','泰迪')
d4=Dog('贝贝','柯基')

d3,d4相当于现实世界当中实实在在存在的实体，即就叫做对象！！

3、什么叫做实例化？

说简单一点就是模板调用的过程（类的调用过程）就叫做实例化！！--实例化之后产生的东西就叫做对象！

4、什么是封装?

def Dog(name,d_type):
    dog1 = {
        'name': name,
        'd_type': d_type,
        #'attack': 18,
        'year': 10
    }
    if d_type in attack:
        Dog["attack"]=attack[d_type]
    else:
        dog1["attack"]=15
    return dog1

假设在这里我创建了一个狗类的方法和一个人类的方法，所谓封装可以简单的理解为：狗类的方法人理论上是不运行人去调用的！

多态和继承我会在后续代码中进行详细讲解！！

类的基本语法：

        1、为了编程的规范：python中类首字母应该大写

            直接就可以在类中定义属性
            像下面这种在类中直接定义的属性，叫做类属性、类变量（是所有对象都可以公共共享的一个属性）

            类中的方法：第一个参数必须是self（也可以是其他名字）---这里的self代表实例本身

class Dog:
    #直接就可以在类中定义属性
    # 像下面这种在类中直接定义的属性，叫做类属性、类变量
    d_type='泰迪'
    def hello(self):    #方法：第一个参数必须是self（也可以是其他名字）---这里的self代表实例本身
        print('Hello!,I am a',self.d_type)

             当类写完之后，我们需要对类进行实例化，将其变成一个真正的实体，对象---python中一切皆对象

       当我们实例化一个对象之后，就可以通过对象去调用类中的方法
'''
1、调用类中的方法： 实例.方法
2、调用类中的属性:  实例.属性
'''（#小写的f代表类属性，大写的F代表普通函数）

#当类写完之后，我们需要对类进行实例化，将其变成一个真正的实体，对象---python中一切皆对象
D1=Dog()    #生成了一个实例
D2=Dog()
#当我们实例化一个对象之后，就可以通过对象去调用类中的方法
D1.hello()
'''
1、调用类中的方法： 实例.方法
2、调用类中的属性:  实例.属性
'''
#小写的f代表类属性，大写的F代表普通函数
D1.d_type

问题：我们如何定义对象之间私有的属性（只属于自己的属性）？

答：定义初始化方法又叫做构造方法、构造函数，实例化时进行一些初始化工作（自动进行执行）

在类中定义初始化方法：

    def __init__(self,name,age,sex):#初始化方法，构造方法，构造函数，实例化时会自动执行，进行一些初始化工作
        #要想把name ,age 两个值，真正的存到实例种去，就要把2个值和实例去进行绑定--self存在意义
        self.name=name  #绑定参数值到实例中去
        self.age=age
        self.sex=sex    #相当于D.sex=" 雄性"

2、self用什么实际意义？

以上述代码进行举例：

要想把name ,age 两个值，真正的存到实例种去，就要把2个值和实例去进行绑定--self存在意义

#为了编程的规范：python中类首字母应该大写
class Dog:
    #直接就可以在类中定义属性
    # 像下面这种在类中直接定义的属性，叫做类属性、类变量
    d_type='泰迪'
    def hello(self):    #方法：第一个参数必须是self（也可以是其他名字）---这里的self代表实例本身
        print('Hello!,I am a',self.d_type,'My name is',self.name,'I am',self.age,'years!')
    def __init__(self,name,age,sex):#初始化方法，构造方法，构造函数，实例化时会自动执行，进行一些初始化工作
        #要想把name ,age 两个值，真正的存到实例种去，就要把2个值和实例去进行绑定--self存在意义
        self.name=name  #绑定参数值到实例中去
        self.age=age
        self.sex=sex    #相当于D.sex=" 雄性"


#当类写完之后，我们需要对类进行实例化，将其变成一个真正的实体，对象---python中一切皆对象
D1=Dog('贝贝',2)    #生成了一个实例
D2=Dog('tiger',10)
#当我们实例化一个对象之后，就可以通过对象去调用类中的方法
D1.hello()

'''
1、调用类中的方法： 实例.方法
2、调用类中的属性:  实例.属性
'''
#小写的f代表类属性，大写的F代表普通函数
D1.d_type
D1.sex='雄性'
print(D1.sex)

我们也可以直接在类的外部，运用实例化之后的对象进行创建  D1.sex='雄性' 相当于在初始化方法中添加sex属性，并用self进行实例化绑定

def __init__(self,name,age,sex):#初始化方法，构造方法，构造函数，实例化时会自动执行，进行一些初始化工作
        #要想把name ,age 两个值，真正的存到实例种去，就要把2个值和实例去进行绑定--self存在意义
        self.name=name  #绑定参数值到实例中去
        self.age=age
        self.sex=sex    #相当于D.sex=" 雄性"

实例属性又叫做成员变量

小总结：

                类属性，类变量，公共属性-----所有实例共享

                实例属性，实例变量，成员变量-------每个实例独享