面向对象初始

面向对象思想

面向对象的程序设计语言必须有描述对象及其相互之间关系的语言成分。这些程序设计语言可以归纳为以下几类：系统中一切事物皆为对象；对象是属性及其操作的封装体；对象可按其性质划分为类，对象成为类的实例；实例关系和继承关系是对象之间的静态关系；消息传递是对象之间动态联系的唯一形式，也是计算的唯一形式；方法是消息的序列。

类：具有相同特征(属性和行为)事物的抽象

例:狗是一类

对象：某个类的具象

例:我家的大白(大白是一只狗)

类体:两部分:变量部分,方法(函数)部分

class Person:
    mind="有思想的"           # 变量部分,静态变量,静态字段
    work="会工作的"
    money="会赚钱,也会花钱的"
    def like(self):           # 方法部分,函数,动态变量
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")

class Person:
    mind="有思想的"          
    work="会工作的"
    money="会赚钱,也会花钱的"
    def like(self):         
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
print(Person.__dict__)

{'__module__': '__main__', 'mind': '有思想的', 'work': '会工作的', 'money': '会赚钱,也会花钱的', 'like': <function Person.like at 0x0000018F46368D90>, 'dream': <function Person.dream at 0x0000018F46368E18>, 'die': <function Person.die at 0x0000018F46368EA0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

class Person:
    mind="有思想的"           # 变量部分,静态变量,静态字段
    work="会工作的"
    money="会赚钱,也会花钱的"
    def like(self):           # 方法部分,函数,动态变量
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
print(Person.__dict__["work"])

会工作的

class Person:
    mind="有思想的"           # 变量部分,静态变量,静态字段
    work="会工作的"
    money="会赚钱,也会花钱的"
    def like(self):           # 方法部分,函数,动态变量
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
print(Person.mind)
有思想的

注意:变量部分不可以增删改查

 

class Person:
    mind="有思想的"           # 变量部分,静态变量,静态字段
    work="会工作的"
    money="会赚钱,也会花钱的"
    def like(self):           # 方法部分,函数,动态变量
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
Person.__dict__["money"]="百万先生"
print(Person.__dict__["money"])

结果:报错

class Person:
    mind="有思想的"           # 变量部分,静态变量,静态字段
    work="会工作的"
    money="会赚钱,也会花钱的"
    def like(self):           # 方法部分,函数,动态变量
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
Person.love="有爱的"
Person.work="不会工作的"
del Person.mind
print(Person.__dict__)
print(Person.mind)

综上:

语法

• 定义类需要使用关键字：class

• 类名：原则上只要符合标识符的命名规范即可，但是我们通常每个单词首字母大写命名.例如:Person

• 不要忘记类名后面的冒号"  :  "

self:

class Person:
    mind="有思想的"           # 变量部分,静态变量,静态字段
    work="会工作的"
    money="会赚钱,也会花钱的"
    def like(self):           # 方法部分,函数,动态变量
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
Person.dream(11)  #()中必须有一个值

操作类中的方法 :增,删,改,查

class Person:
    mind="有思想的"           # 变量部分,静态变量,静态字段
    work="会工作的"
    money="会赚钱,也会花钱的"
    def like(self):           # 方法部分,函数,动态变量
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
Person.age="18"
print(Person.__dict__)           #增

del Person.like
print(Person.__dict__)           #删

Person.like="美女"
print(Person.__dict__)           #改

Person.dream(11)                 #查

类名的角度
操作类中的静态变量
 1, Person.__dict__ 查询类中的所有的内容 (不能进行增删改操作)
 2, 万能的  .  对类中的单个的变量进行增删改查,用 万能的 点

类名+()的这个过程:实例化的过程(创建一个对象的过程),
Person() 实例化对象,实例,对象

class Person:
    mind="有思想的"
    work="会工作的"
    money="会赚钱,也会花钱的"
    def __init__(self):
        print(self)
        print(666)
    def like(self):
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
ret=Person()
print(ret)

1, 类名+()产生一个实例(对象,对象空间.)
2, 自动执行类中的__init__方法,将对象空间传给__init__的self参数,
3, 给对象封装相应的属性.
print(ret.__dict__)

对象的角度:

class Person:
    mind="有思想的"
    work="会工作的"
    money="会赚钱,也会花钱的"
    def __init__(self,name,age,hobby):
        self.name=name
        self.age=age
        self.hobby=hobby
    def like(self):
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
ret=Person("xiaomin",18,"打篮球")
print(ret)
print(ret.__dict__)

<__main__.Person object at 0x000001ADFFCE13C8>
{'name': 'xiaomin', 'age': 18, 'hobby': '打篮球'}

操作对象中的静态变量(增删改查)

class Person:
    mind="有思想的"
    work="会工作的"
    money="会赚钱,也会花钱的"
    def __init__(self,name,age,hobby):
        self.name=name
        self.age=age
        self.hobby=hobby
    def like(self):
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
ret=Person("xiaomin",18,"打篮球")

print(ret.name)            #查

ret.high=175        
print(ret.__dict__)        #增 

del ret.name
print(ret.__dict__)        #删

ret.age=28
print(ret.__dict__)        #改  

对象操作类中的静态变量 : 只能查询

# class Person:
#     mind="有思想的"
#     work="会工作的"
#     money="会赚钱,也会花钱的"
#     def __init__(self,name,age,hobby):
#         self.name=name
#         self.age=age
#         self.hobby=hobby
#     def like(self):
#         print("喜欢台球")
#     def dream(self):
#         print("有理想的")
#     def die(self):
#         print("会死亡的")
# ret=Person("xiaomin",18,"打篮球")
# print(ret.mind)

对象调用类中的方法  (工作中 通过对象执行类中的方法,而不是通过类名)

class Person:
    mind="有思想的"
    work="会工作的"
    money="会赚钱,也会花钱的"
    def __init__(self,name,age,hobby):
        self.name=name
        self.age=age
        self.hobby=hobby
    def like(self):
        print(self)
        print("喜欢台球")
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
ret=Person("xiaomin",18,"打篮球")
ret.like()
print(ret)

<__main__.Person object at 0x0000014CB4D81400>
喜欢台球
<__main__.Person object at 0x0000014CB4D81400>

class Person:
    mind="有思想的"
    work="会工作的"
    money="会赚钱,也会花钱的"
    def __init__(self,name,age,hobby):
        self.name=name
        self.age=age
        self.hobby=hobby
    def like(self):
        print("%s喜欢台球" % self.name)
    def dream(self):
        print("有理想的")
    def die(self):
        print("会死亡的")
ret=Person("xiaomin",18,"打篮球")
ret.like()

xiaomin喜欢台球