面向对象基础

1、面向过程的程序设计
优点:复杂的问题流程化，进而简单化
缺点:可扩展性差

2、面向对象程序设计
优点:可扩展性强
缺点:编程的复杂性高

3、类与对象
在现实世界中:肯定是先有对象，后又类
在程序中:务必保证先定义类，后产生对象


对象:特征与技能的结合体
类:一系列对象相似的特征与相似的技能的结合体

定义类:

class Luffystudent:
    school = "luffycity" # 数据属性

    def learn(self):     # 函数属性
        print("is learning")

    def eat(self):       # 函数属性
        print("is eatting")

    def sleep(self):     # 函数属性
        print("is sleepping")

注意:
1、类中可以有任意python代码，这些代码在类定义阶段便会执行，因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过OldboyStudent.__dict__查看
2、类中定义的名字，都是类的属性，点是访问属性的语法。
3、对于经典类来说我们可以通过该字典操作类名称空间的名字，但新式类有限制

类的使用:
Luffystudent.school #查
Luffystudent.school='luffy' #改
Luffystudent.x=1 #增
del Luffystudent.x #删

类的调用(实例化，得到程序中的对象)
stu1 = Luffystudent()
stu2 = Luffystudent()
stu2 = Luffystudent()

stu1、stu2、stu3被称为对象


__init__方法:
此方法是在产生对象之后才会执行，只用来为对象进行初始化操作，可以有任意的代码，但是不能拥有返回值。

class Luffystudent:
    school = "luffycity" # 数据属性

    def __init__(self, name, age, sex)
        self.Name = name
        self.Age = age
        self.Sex = sex

    def learn(self):     # 函数属性
        print("is learning")

    def eat(self):       # 函数属性
        print("is eatting")

    def sleep(self):     # 函数属性
        print("is sleepping")

stu1 = Luffystudent("xu", 18, "man")
stu2 = Luffystudent("chong", 20, "man")
stu3 = Luffystudent("guang", 21, "man")

当对象产生后，stu1就会被赋给self

对象的调用:
对象的名称空间可以用stu1.__dict__查看，查询结果为{'name': 'xu', 'age': 18, 'sex': 'man'}

stu1.name 查，与stu1.__dict__['name']相同
stu1.name = 'dashuaige' 改与stu1.__dict__['name']='dashuaige'相同
stu1.course = 'Python' #增，等同于s2.__dict__['course']='Python'
del s2.course #删，等同于s2.__dict__.pop('course')

注意:
1、站的角度不同，定义出的类是截然不同的；
2、现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类等；
3、有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类

属性查找:
类有两种属性:1、数据属性 2、函数属性
数据属性是所有对象共享的
print(id(Luffystudent.school))

print(id(stu1.school)) #4377347328
print(id(stu2.school)) #4377347328
print(id(stu3.school)) #4377347328

类的函数属性是绑定给对象使用的,称为绑定到对象的方法
在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

绑定方法:

class Luffystudent:
    school = "luffycity" # 数据属性

    def __init__(self, name, age, sex)
        self.Name = name
        self.Age = age
        self.Sex = sex

    def learn(self):     # 函数属性
        print("%s is learning" %self.Name)

    def eat(self):       # 函数属性
        print("%s is eatting" %self.Name)

    def sleep(self):     # 函数属性
        print("%s is sleepping" %self.Name)

stu1 = Luffystudent("xu", 18, "man")
stu2 = Luffystudent("chong", 20, "man")
stu3 = Luffystudent("guang", 21, "man")

对绑定方法进行调用:
Luffystudent.learn(stu1) #xu is learning
Luffystudent.learn(stu2) #chong is learning
Luffystudent.learn(stu3) #guang is learning

类中定义的函数（没有被任何装饰器装饰的）是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数

stu1.learn()  等同于Luffystudent.learn(stu1)
stu2.learn()  等同于Luffystudent.learn(stu2)
stu3.learn()  等同于Luffystudent.learn(stu3)

1、绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当做第一个参数传给方法，即自动传值（方法__init__也是一样的道理）
2、绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self

最后在Python中，一切皆为对象。

练习1：编写一个学生类，产生一堆学生对象。
要求：
    有一个计数器（属性），统计总共实例了多少个对象

class Student:
    school = "luffycity"
    count = 0
    def __init__(self, name, age, sex):
        self.Name = name
        self.Age = age
        self.Sex = sex
        Student.count += 1

    def learn(self):
        print('%s is learning' %self.Name)

stu1 = Student('xu', 17, 'man')
stu2 = Student('chong', 15, 'man')
stu3 = Student('guang', 22, 'man')
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)

print(stu1.count)
print(stu2.count)
print(stu3.count)

练习2：模仿王者荣耀定义两个英雄类， (10分钟)
要求：
1、英雄需要有昵称、攻击力、生命值等属性；
2、实例化出两个英雄对象；
3、英雄之间可以互殴，被殴打的一方掉血，血量小于0则判定为死亡。

class Gailun:
    def __init__(self, name, aggresivity, life_value):
        self.Aggresivity = aggresivity
        self.Name = name
        self.Life_value = life_value

    def attack(self, obj):
        obj.Life_value -= self.Aggresivity
        if obj.Life_value <= 0:
            print('%s 死亡' %obj.Name)
            return True
        else:
            print("%s被攻击, 生命值为:%s" %(obj.Name, obj.Life_value))
            return False

class Ruiwen:
    def __init__(self, name, aggresivity, life_value):
        self.Aggresivity = aggresivity
        self.Name = name
        self.Life_value = life_value

    def attack(self, obj):
        if obj == self:
            print("不能攻击自身")

        obj.Life_value -= self.Aggresivity

        if obj.Life_value <= 0:
            print('%s 死亡' %obj.Name)
            return True
        else:
            print("%s被攻击,生命值为:%s" %(obj.Name, obj.Life_value))
            return False

            
gailun = Gailun("盖伦", 20, 100)
ruiwen = Ruiwen("锐雯", 10, 150)

gailun.attack(ruiwen)