初识面向对象

函数与面向对象的区别

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

2，面向对象是一种思维，站在上帝的角度

3，程序可扩展，对象是一个个独立的。耦合性，差异性

类与对象

类：具有相同属性或者功能的一类事物

对象：对象是类的具体表现

类名，对象的使用

一个公共的框架，模型

 

类名

1，查看类中的所有属性和方法

2，查看，增删改类中的属性，     （万能的.）

3,操作方法，一般不通过类名操作

class Role:
    rule="游戏规则"
    ditu="召唤师峡谷"
    tianqi="晴"
    def __init__(self,area,name,hp,ad):
        self.area=area
        self.name=name
        self.hp=hp
        self.ad=ad
    def attack(self,name):
        name.hp=name.hp-self.ad
        print(name.hp)
print(Role.__dict__)
print(Role.tianqi)   #晴
Role.tianqi="下雪"  
print(Role.tianqi)  #下雪

 

对象

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

1，在内存中产生一个对象空间，里面有类对象指针

2，自动调用__init__方法，并且把对象空间传给self

3，在类对象空间中封装属性

 

a，对象操作对象空间

对象查看对象空间的属性

对象操作对象的某个属性，（增删改查）

class Role:
    rule="游戏规则"
    ditu="召唤师峡谷"
    tianqi="晴"
    def __init__(self,area,name,hp,ad):
        self.area=area
        self.name=name
        self.hp=hp
        self.ad=ad
    def attack(self,name):
        name.hp=name.hp-self.ad
        print(name.hp)
gailun = Role("德玛西亚","草丛伦",1000,75)
yasuo = Role("艾欧里亚","托儿索",500,150)
print(gailun.name)    #对象查看对象空间的属性
gailun.hp=1200
gailun.wuqi="剑"
del gailun.ad
print(gailun.__dict__)  #{'area': '德玛西亚', 'name': '草丛伦', 'hp':1200, 'wuqi': '剑'}

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

对象只能调用类中的属性和方法，不能改变

class Role:
    rule="游戏规则"
    ditu="召唤师峡谷"
    tianqi="晴"
    def __init__(self,area,name,hp,ad):
        self.area=area
        self.name=name
        self.hp=hp
        self.ad=ad
    def attack(self,name):
        name.hp=name.hp-self.ad
        print(name.hp)
gailun.rule="新rule"
print(gailun.__dict__)  #{'area': '德玛西亚', 'name': '草丛伦', 'hp': 1000, 'ad': 75, 'rule': '新rule'}

先从自己空间去找，没有此属性，他会通过类对象指针去找，类中找不到，会去父类中找

类不能调用对象的属性

对象与对象之间的属性不能相互调用

 对象/实例，一个实实在在的实体

 

__dict__

类中：查看所有的属性和方法

对象：所有对象的属性，类对象指针

对象去修改类的静态属性，在对象空间又创建了一个静态属性，不能去修改类的属性

操作类的静态属性要用类名

 

写一个类，统计实例化了多少个对象

class A:
    count=0
    def __init__(self):
        A.count += 1
a=A()
print(a.count)  #1
b=A()
print(A.count)  #2
print(b.count)  #2

类的静态变量为可变数据类型时

class Foo:
    l=[0]
a=Foo()
a.l[0] += 1
print(a.l)  #[1]
print(Foo.l)  #[1]
a.l=[3]
print(a.l)    #[3]
print(Foo.l)  #[1]

当类中的属性发生改变的时候，若对象中没有同名的属性或者方法的时候，对象在引用该属性的时候，属性会跟着类中的属性走

如果对象的某个属性被直接赋值，一定是对象空间发生改变