Python Day23

Posted 2020-10-07

面向对象2：

一、之前的知识回顾：

　　

1、类 具有相同属性、和方法的一类事物
对象（实例） 具体的某一个人事物
实例化 对象=类 的过程

2、类的的定义 ： class关键字  类名的首字母大写
3、而类有两种属性：静态属性和动态属性

  　　1.静态属性就是直接在类中定义的变量
　　
　　　2.动态属性就是定义在类中的方法

4、对象的属性：
    一开始的时候：通过init方法初始化来的
    在类内调用对象的属性：self.属性名
    在类外调用对象的属性：对象名.属性名
  调用方法的时候：
    对象.方法名
    不必传的参数：self
当类实例化的时候：自动的触发__init__方法。实例化的时候类名(参数),这个参数传给init方法

二、类的命名空间
　　1 对于类的静态属性：
　　　　　　类.属性：调用的解释类的属性
　　　　　　对象.属性：就是先从自己的命名空间寻找，如果有就用自己的，没有就到类里面去寻找，如果有就用类里面的，没有就会报错。

实例：

class A:
    ret=‘liu‘
a=A()
print(A.ret)
print(a.ret)
a.ret=‘liuduo‘
print(a.ret)
print(A.ret)

输出结果
liu
liu
liuduo
liu

　　　　2 关于类的动态属性（方法）：

　　　　　　　　　　这个方法本身就存在于类的空间，根本不会存在对象的内存中。

　　　　　　　　　　如果在对象调用类里面的方法，需要在类的内存中产生一个地址簿来对应类中的方法。

class A:
    def func(self):
        print(111)
a=A()
a.func()
a.func=666
print(a.func)
a.func()   #这个就报错了

　　　　3 关于对象的属性：

　　　　　　　　　　对象的属性只存在于对象的命名空间，　　　　　　　　　　

　　　　　　　　　　只能被对象来调用和修改，如果类来调用或修改就会报错。

 

class A:
    pass
a=A()
a.name=‘alex‘
print(a.name)
print(A.name)    #这个就会报错

三、 面向对象的组合

　1 什么叫组合：一个类的对象是另一个类的属性就叫做组合，组合表达的是什么和什么的关系。

　2 组合的好处：增强了代码的重用性。

　实例1 ：计算圆环的面积差和圆环面积总周长

 

import math
class Yuan:
    def __init__(self,ban):
        self.ban=ban
    def mian(self):
        return math.pi*self.ban**2
    def zhou(self):
        return math.pi*self.ban*2
class DaXiaoYuan:
    def __init__(self,daban,xiaoban):
        self.dayuan=Yuan(daban)
        self.xiaoyuan=Yuan(xiaoban)
    def mian(self):
        return self.dayuan.mian() - self.xiaoyuan.mian()
    def zhou(self):
        return self.dayuan.zhou() + self.xiaoyuan.zhou()
yuan=DaXiaoYuan(20,10)
print(yuan.mian())
print(yuan.zhou())

 实例2：课程和学生关联

class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

class Course:
    def __init__(self,name,period,teacher,price):
        self.name=name
        self.period=period
        self.teacher=teacher
        self.price=price

class Person:
    def __init__(self,name,birth_obj):
        self.name = name
        self.birthday = birth_obj

bith_hai = Birthday(1988,11,11)
py=Course(‘python‘,20,‘jingdao‘,20000)
haijiao = Person(‘海娇‘,bith_hai)
print(haijiao.name)
print(haijiao.birthday.year)

haijiao.kecheng = py
print(haijiao.kecheng.name)


输出结果
海娇
1988
python

实例3：人狗大战

class Person:#定义一个人
    role = ‘person‘
    def __init__(self,name,aggr,life_value,money):
        self.name = name
        self.aggr = aggr
        self.life_value = life_value
        self.money = money
    def attack(self,dog):
        dog.life_value -= self.aggr
class Dog: #定义一条狗
    def __init__(self,name,breed,aggr,life_value):
        self.name = name
        self.breed = breed
        self.aggr = aggr
        self.life_value = life_value
    def bite(self,person):
        person.life_value -= self.aggr
class Weapon:#定义一把武器
    def __init__(self,name,price,aggr,life_value):
        self.name = name
        self.price = price
        self.aggr = aggr
        self.life_value = life_value
    def update(self,obj):#obj就是要带这个装备的人
        obj.money -= self.price
        obj.aggr += self.aggr
        obj.life_value += self.life_value
    def prick(self,obj): #装备的主动技能,炸死对方
        obj.life_value -= self.aggr

lance = Weapon(‘长矛‘,200,10,100)
egg = Person(‘egon‘,10,1000,600)
ha2 = Dog(‘二愣子‘,‘哈士奇‘,10,1000)

if egg.money > lance.price:
    lance.update(egg)
    egg.weapon = lance
print(egg.money,egg.life_value,egg.aggr)
print(ha2.life_value)
egg.attack(ha2)
print(ha2.life_value)
egg.weapon.prick(ha2)
print(ha2.life_value)



输出结果

400 1100 20
1000
980
970