核心编程（三）：面向对象——逻辑交互与组合

进击のpython

*****

逻辑交互

一说这个词，woc！是真专业！

啥意思？？一点一点来呗！

啥叫交互啊，我跟你说话就是交互

你看我文章就是我文章在跟你交互

如果之间的交互存在着某种规则

那就叫逻辑交互！

人狗大战中，人打狗，狗咬人，是不是都是逻辑交互啊！

那模板的面向对象写法是不是写出来了

那现在是不是应该学用面向对象的方式写bite（）这种函数了？

其实我们在上节都已经写过了，只是没有仔细的讲一下

# -*- coding: utf-8 -*-
# @Time    : 2019.07.15
# @Author  : 爪爪
# @Url     : https://www.cnblogs.com/jevious/

class Dog:
    role = "name"

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

    def bite(self, person):
        person.life_val -= self.attack_val
        print("狗[%s]咬了人[%s],人掉血[%s],还剩血量[%s]..." % (self.name, person.name, self.attack_val, person.life_val))


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

    role = "person"

    def attack(self, dog):
        dog.life_val -= self.attack_val
        print("人[%s]打了狗[%s],狗掉血[%s],还剩血量[%s]..." % (self.name, dog.name, self.attack_val, dog.life_val))

然后进行逻辑交互是吧！

d1 = Dog(100, 10, "erha", "ponny")
d2 = Dog("laswer", 20, 120, "haskey")

p = Person(20, "zhangsan", 120, "男")

p.attack(d1)
d1.bite(p)

打印出你很喜欢的东西

人[zhangsan]打了狗[ponny],狗掉血[20],还剩血量[80]...
狗[ponny]咬了人[zhangsan],人掉血[10],还剩血量[110]...

我们的目的是不是就达到了！

强烈建议自己敲几遍！！！否则眼睛会了，手不会！

类和类的关系

说到交互啊，就要说说类和类之间的关系了

在前文的时候就提过

说：这个类和对象啊是用代码将真实世界描绘出来

那真实世界有什么关系，类和类之间就应该有相应关系！

依赖关系

人依赖水才能活

狗依赖主人才能活
关联关系

你和你的女朋友互相认为彼此是对象

（单身就更应该好好敲代码！）
聚合关系

你现在看我文章用的电脑，手机

是不是一个一个零件构成的啊

那这些零件是不是通过某种图纸（逻辑）

聚合起来了啊

但是你的某个组件坏了，也不能影响整个电脑
组合关系

比聚合关系更加紧密

就像人，你人死了，是不是所有器官都不行了？

但是电脑坏了，你是不是还能拆吧拆吧卖零件
继承关系

类的三大特性之一！子承父业！

依赖关系：

# -*- coding: utf-8 -*-
# @Time    : 2019.07.15
# @Author  : 爪爪
# @Url     : https://www.cnblogs.com/jevious/

class Dog:
    def __init__(self, name, age, breed, master):
        self.name = name
        self.age = age
        self.breed = breed
        self.master = master  # master传进来的应该是个对象
        self.sayhi()  # 调用自己的方法在实例化的时候

    def sayhi(self):
        print("Hi, I'm %s, a %s dog, my master is %s" % (self.name, self.breed, self.master.name))


class Person:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def walk_dog(self, dog_obj):
        """遛狗"""
        print("主人[%s]带狗[%s]去溜溜。。。" % (self.name, dog_obj.name))

我不用每句代码都讲了吧。

在Dog中，我添加了一个master，这就是Dog的主人对吧，

那主人是不是一个真实的？

那主人是真实的，那主人就是一个对象（实例化的对象）！

那主人的名字是不是就应该是master.name！

那我应该怎么交互？

p = Person("zhangsan",26,"Male")
d = Dog("ponny",5,"erha",p)

像这种关系就是依赖关系

组合关系：一堆组件构成一个完整的实体，组建本身独立，自己不能运行

开始进阶版人狗大战！

我可以搞一下什么呢？给人整个装备！可以不！

# -*- coding: utf-8 -*-
# @Time    : 2019.07.15
# @Author  : 爪爪
# @Url     : https://www.cnblogs.com/jevious/

class Weapon:
    def stick(self, obj):
        """打狗棒"""
        self.name = "打狗棒"
        self.attack_val = 40
        obj.life_val -= self.attack_val
        self.print_log(obj)

    def knife(self, obj):
        """屠龙刀"""
        self.name = "屠龙刀"
        self.attack_val = 80
        obj.life_val -= self.attack_val
        self.print_log(obj)

    def gun(self, obj):
        """AK47"""
        self.name = "AK47"
        self.attack_val = 100
        obj.life_val -= self.attack_val
        self.print_log(obj)

    def print_log(self, obj):
        print("[%s]被[%s]攻击了，掉血[%s],还剩血量[%s]..." % (obj.name, self.name, self.attack_val, obj.life_val))


class Dog:
    role = "dog"

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

    def bite(self, person):
        person.life_val -= self.attack_val
        print("狗[%s]咬了人[%s],人掉血[%s],还剩血量[%s]..." % (self.name, person.name, self.attack_val, person.life_val))


class Person:
    def __init__(self, name, sex, attack_val, life_val):
        self.attack_val = attack_val
        self.name = name
        self.life_val = life_val
        self.sex = sex
        self.Weapon = Weapon()

    role = "person"

    def attack(self, dog):
        dog.life_val -= self.attack_val
        print("人[%s]打了狗[%s],狗掉血[%s],还剩血量[%s]..." % (self.name, dog.name, self.attack_val, dog.life_val))


d = Dog("ponny", "erha", 30, 100)
p = Person("zhangsan", "man", 50, 100)

d.bite(p)

p.Weapon.gun(d)

狗[ponny]咬了人[zhangsan],人掉血[30],还剩血量[70]...
[ponny]被[AK47]攻击了，掉血[100],还剩血量[0]...

没毛病吧！能看懂吧！（不能看懂就用断点调试来做）

武器这个类是不是不能自己执行？

是不是要跟人绑在一起才能执行？

所以这就是组合关系

关联关系：你和你女朋友的关系

# -*- coding: utf-8 -*-
# @Time    : 2019.07.15
# @Author  : 爪爪
# @Url     : https://www.cnblogs.com/jevious/

class Person:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.partner = None  # 另一半，是个对象

    def do_private_stuff(self):
        """和男/女盆友干点羞羞的事"""
        print("%s is doing %s in the 7th hotel." % (self.name, self.partner.name))


p1 = Person("武大郎", 25, "男")
p2 = Person("黑姑娘", 23, "女")
p1.partner = p2  # 两个对象要互相绑定彼此
p2.partner = p1
p1.do_private_stuff()
p2.do_private_stuff()

以上虽然实现了2个对象的关联，但细想其实是有问题的

武大郎和黑姑娘需要在自己的实例中分别绑定下彼此才能实现伴侣关系

假如有一方忘记了关联，那这个伴侣关系就只是单方面成立

黑姑娘知道自己的另一伴是武大郎，武大郎却不识黑姑娘

为了确保这两人的关系是一致的，怎么办呢？

可以创建个单独的类，存储2个人的关系状态

2个人在查自己的感情状态时，都到这个单独的实例里来查

# -*- coding: utf-8 -*-
# @Time    : 2019.07.15
# @Author  : 爪爪
# @Url     : https://www.cnblogs.com/jevious/

class RelationShip:
    """保存2个人的感情关联关系"""

    def __init__(self):
        self.couple = []

    def make_couple(self, obj1, obj2):
        self.couple.append(obj1)
        self.couple.append(obj2)
        print("[%s] 和 [%s] 正式结为对象..." % (obj1.name, obj2.name))

    def break_up(self):
        if self.couple:
            print("[%s] 和 [%s] 要分手了...真好" % (self.couple[0].name, self.couple[1].name))
            self.couple.clear()
        else:
            print("你根本就没对象，你分手个蛋呀...")

    def get_my_partner(self, obj):
        """返回我的另一半"""
        for i in self.couple:
            if obj != i:  # copule列表里有2个值，一个是我自己，一个是我对象，只要跟传进来的obj不相等，代表找到了我对象
                return i.name
        else:
            print("你没有对象，自己心里没有点数么....")


class Person:
    def __init__(self, name, age, sex, relation_obj):
        self.name = name
        self.age = age
        self.sex = sex
        self.relation = relation_obj  # 把RelationShip对象传进来
        # self.partner = None # 另一半，是个对象

    def do_private_stuff(self):
        """和男/女盆友干点羞羞的事"""
        print("%s is doing %s in the 7th hotel." % (self.name, self.relation.get_my_partner(self)))


relation_obj = RelationShip()
p1 = Person("武大郎", 25, "男", relation_obj)
p2 = Person("黑姑娘", 23, "女", relation_obj)
relation_obj.make_couple(p1, p2)  # 把2个人结合在一起
p1.do_private_stuff()
p2.do_private_stuff()
p1.relation.break_up()  # 要分手了
p1.relation.get_my_partner(p1)  # 再去查，就没有对象了
p2.relation.get_my_partner(p2)  # 再去查，就没有对象了

其实你慢慢的就发现，每句代码你都懂，但是，对吧

一看就会，一写就废

所以说，还是要多练啊！

开发一个反恐游戏，有警察、恐怖分子，还有各种武器，他们可以互砍互杀。

注意，警察不能用C4包，恐怖分子可以。C4包一用，全部玩家都得死。

提示：可以只写一个Person类，一个weapon类。

下一篇，就写最重要的！！！！！继承！！！！！！！！！

*继承有啥用* *关注我博客*

posted @ 2019-07-17 00:00 吃夏天的西瓜阅读(765) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

吃西瓜的汤圆酱

一起进步~

核心编程（三）：面向对象——逻辑交互与组合

进击のpython

逻辑交互

类和类的关系

公告

吃西瓜的汤圆酱

一起进步~

~~核心编程（三）：面向对象——逻辑交互与组合~~

进击のpython

逻辑交互

类和类的关系

公告

核心编程（三）：面向对象——逻辑交互与组合