day15

面向对象从结构上理解分为两部分：

　　1.静态属性，静态变量，静态字段

　　2.动态属性，方法，函数

class A:
    name = 'ake'   #静态属性
    def func1(self):
        pass       #动态属性，方法，函数　　

比如一个购物车，里面有一些功能可以好几个环节能用的，那就可以拿出来当成一个对象

class Shopping_Car:
    def __init__(self):
        pass            #特殊方法，这里面是具体对象的独特的功能，这里面可以有多个功能
    def register(self):
        pass           #每一个函数封装成一个独特的功能
    def login(self):
        pass

1.函数封装一个功能，而面向对象封装多个相关的功能

2.面向对象抽象，他是一种思想，站在上帝的角度去理解他，把想要创造的一类东西的通性放在类里，而这个类里面的独有的分支，以及个体独有的一些功能封装到对象里的一个个功能里

3.程序可扩展，对象都是一个个独立的，有偶合性，差异性

类与对象的区别：

类：是一类事物具有相同的属性

对象：对类的具体体现

我们可以比喻成一个公共的框架，一个公共的模型

class Person:
    animal = '高级动物'
    walk = '直立行走'
    language = '语言'

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

    def eat(self):
        print('吃饭')

    def work(self):
        print('工作')
obj = Person('ake',13,2)
print(obj)             #<__main__.Person object at 0x000001536F4F0940>
print(obj.name)        #ake

这个过程是一个实例化过程（它会在内存中实例化一个对象空间）

实例化过程内部进行了三个阶段：

1.在内存中开辟了一个对象空间

2.自动执行__init__方法，并将对象空间自动传给self参数，其他参数手动传入

3.执行__innit__方法中，给对象空间封装相应的属性

对象：

　　对象操作对象空间的所有属性  __dict__

print(obj.__dict__)

　　对操作对象的某个属性，增删改查，使用万能的点  ‘ .’ 

class Person:
    animal = '高级动物'
    walk = '直立行走'
    language = '语言'

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

    def eat(self):
        print('吃饭')

    def work(self):
        print('工作')
obj = Person('ake',13,2)
print(obj)             #<__main__.Person object at 0x000001536F4F0940>
print(obj.__dict__)    #{'name': 'ake', 'age': 13, 'eye': 2}
obj.sex = '男'
print(obj.__dict__)    #{'name': 'ake', 'age': 13, 'eye': 2, 'sex': '男'}   增加
obj.eye = '眼睛很大'
print(obj.__dict__)    #{'name': 'ake', 'age': 13, 'eye': '眼睛很大', 'sex': '男'}  改动
print(obj.name)        #ake   对对象空间的查

　　对象对类空间的属性，只能查

class Person:
    animal = '高级动物'
    walk = '直立行走'
    language = '语言'

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

    def eat(self):
        print('吃饭')

    def work(self):
        print('工作')
obj = Person('ake',13,2)
print(obj.animal)      #高级动物   查
obj.animal = '低级动物'
print(obj.animal)      #低级动物  虽然打印出低级动物，但是是增加到了对象空间
print(obj.__dict__)    #{'name': 'ake', 'age': 13, 'eye': '眼睛很大', 'sex': '男', 'animal': '低级动物'}
print(Person.__dict__)  #而类空间里的高级动物也依然在，并没有被修改

对象操作类空间的方法

obj.eat()

1,对象为什么能调用类中的属性与方法而且只能调用不能改变？　

class GameRole:
    rule = '游戏规则'
    def __init__(self,area,nickname,hp,ad):
        self.area = area
        self.nickanme = nickname
        self.hp = hp
        self.ad = ad
    def attack(self):
        print('谁施展了一个攻击')
    def pen(self):
        self.penzi = 1000
p1 = GameRole('德玛西亚','草丛伦',1000,75)

　　p1.属性名：先从自己属性空间里面找，没有此属性再通过类对象指针从类空间去找，类找不到，会从父类中找

print(p1.hp)                   #1000

p1.attack = 666
p1.attack()            #TypeError: 'int' object is not callable   ,显示数字类型不可以被调用，能被调用的只能是函数
print(p1.attack)         #666

先执行等号右边，将游戏规则赋值给等号左边，等号左边在p1的对象空间里面又添加了一个rule,此时打印p1.rule,打印的是对象空间里新增加的那个属性

p1.rule = p1.rule
print(p1.rule)           #游戏规则 

　对象可以修改对象空间的值

p1.nickanme = '盖伦'
print(p1.nickanme)

2.类不能调用对象的属性

print(GameRole.area) 

3.对象与对象之间可不可以互相调用？

同一个类实例化出来的对象之间不能互相访问

不同类型实例化的对象有可能互相访问

class Gamerole:
    rule = '游戏规则'
    def __init__(self, nickname, ad, hd):
        self.nickname = nickname
        self.ad = ad
        self .hd = hd

    def atterk(self,w):
        self.waepon = w
p1 = Gamerole('艾伦', 20, 100)
p2 = Gamerole('剑豪', 50, 200)
class Weapon:
    def __init__(self, w, ad):
        self.w = w
        self.ad = ad
    def fight(self,sole1, sole2):
        sole2.hd = sole2.hd - self.ad
        print('{}攻击了{}，{}受伤了，掉了{}血，还剩{}血'
              .format(sole1.nickname, sole2.nickname, sole2.nickname, self.ad, sole2.hd))
w1 = Weapon('刀', 20)
w2 = Weapon('剑', 50)
p2.atterk(w2)
p2.waepon.fight(p2, p1)

　Weapon类将w1传入Gamerole类里面的atterk方法里，这样p2就可以调用此类里面的方法此种方法的原理就是：给一个类的对象封装一个属性，而这个属性是另一个类的对象