面向对象-基础篇

一、面向对象与面向过程

​ 1.面向过程： 优点：复杂问题流程化，简单化。

​ 缺点：可扩展性差。

​ 1.面向过程： 优点：可扩展性强

​ 缺点：编程的复杂程度要高于面向过程

二、类和对象

对象：属性和方法的结合体
类： 一系列共同的属性和方法

显示生活中：先有对象再有类

程序中：先有类再有对象

定义类：

class OldboyStudent:
    # 变量表示属性
    school = 'oldboy'

    def choose(self):
        print('is choosing course')
   

class OldboyStudent:定义类名时尽量用驼峰体，约定俗成的
class关键字 + 类名:

print(OldboyStudent.__dict__)用__dict__查看类的属性和函数（方法），以字典的形式打印
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['choose'])
类来调用方法，需要传值给第一个参数：
OldboyStudent.choose(123)

print(OldboyStudent.choose_course)用类名点出函数，如果不加括号就是打印函数的内存地址。

如何生成对象？
类+括号—>生成对象
stu1 = OldboyStudent()

对象获取属性和方法 通过 点 . 来获取
print(stu1.school)
print(stu1.choose)

查看对象中的属性和函数
print(stu1.__dict__)

对象来调用方法，第一个参数不用传
stu1.choose()

对象自己独有的属性和方法：
stu1.name = "cxk sb"
print(stu1.__dict__)

属性的查找顺序：
先从对象自身找--->再到类中去找----->没有就报错
stu1.school = 'xxx'
print(stu1.xx) # 报错

向对象中放属性：
第一种方法：
stu1 = Student()
stu1.name = 'cxk sb'

第二种方法:

class Student:
    #变量表示属性
    school='oldboy'
    #__init__ 看好名字,不是__int__
    def __init__(self,name):
        self.name=name
    def choose(self):
        print("选课....")
    def study(self):
        print('学习')

产生对象：
stu1 = Student()
stu1 = Student('cxk')

当我们在实例化产生对象的时候， __init__在产生对象时会自动运行运行这个函数,完成对象的初始化
stu2 = Student()
stu2 = Student('pike')

三、绑定方法

定义在类内部的方法：

如果类来调用：就是一个普通函数，有几个参数就需要传几个参数

如果对象来调用：它叫对象的绑定方法，第一个参数不需要传，自动传递

class Student:
    #变量表示属性
    school='oldboy'
    #__init__ 看好名字,不是__int__
    def __init__(self,name):
        self.name=name
    def choose(self):
        print("选课....")
    def study(self):
        print('%s学会了python'%self.name)

stu1=Student('cxk')
stu1.study()
stu1=Student('李铁蛋')
stu1.study()

四、一切皆对象

在python中，字典、列表字符....都是对象

类即类型
l1 = [1,2,3]

类实例化产生对象
l1 = list([1,2,3])
l2 = list([5,6,7])

对象调用对象的绑定方法，修改对象自己
l1.append(5)
print(l1)

list.append(l1,9)
print(l1)

五、面向对象基础练习——设计一个对战游戏：

1.有英雄类，各个英雄都有自己方法和属性：名字、攻击力、生命值、金钱等，需要用到就添加

例如拿英雄联盟的两个英雄 锐雯和盖伦 做例子

class Riwen:    # 定义锐雯类

    def __init__(self,name,aggressivity=66,hp=520,money=618):   # 默认属性
        self.name = name
        self.aggressivity = aggressivity
        self.hp = hp
        self.money = money

    def attack(self,target):   # 攻击方法
        target.hp -= self.aggressivity  
        print(f'{self.name}攻击了{target.name},{target.name}的生命剩余{target.hp}')



class Garen:   # 定义盖伦类

    def __init__(self,name,aggressivity=55,hp=560,money=666): # 默认属性
        self.name = name
        self.aggressivity = aggressivity
        self.hp = hp
        self.money = money

    def attack(self,target):  #攻击方法
        target.hp -= self.aggressivity
        print(f'{self.name}攻击了{target.name},{target.name}的生命剩余{target.hp}')


class Dagger:  # 定义装备类

    def __init__(self,aggressivity=10,price=500,hp=100):  # 装备属性
        self.aggressivity = aggressivity
        self.price = price
        self.hp = hp

    def update(self,target):  # 装备方法
        target.money -= self.price   # 减钱
        target.aggressivity += self.aggressivity   # 加攻击力
        target.hp += self.hp  # 加生命值

    def fire(self,target): # 装备的主动技能
        target.hp -= 100   # 假设装备的攻击力为100

# 对战交互

r1 = Riwen('蔡徐坤')
r2 = Garen('耐克')
m1 = Dagger()

print(r1.hp,r1.aggressivity,r1.money)
if r1.money > m1.price:
    r1.m1 = m1
    m1.update(r1)

print(r1.hp,r1.aggressivity,r1.money)

r1.attack(r2)   # 普通攻击

r1.m1.fire(r2)   # 装备攻击

print(r2.hp) 

r2.attack(r1)   # 普通攻击