OOP之类与对象

• 面向对象编程（OOP）

• 定义：面向对象编程的核心是对象本身，通过对象的特征，技能的结合来编写代码，借以达到所想要的功能。

• 优点：可拓展性强，修改任意一个对象，都能反映到整个程序的结果之中。

• 缺点：编程复杂度要高于面对过程编程，而且无法预测程序最后的结果，是一个对象与对象交互的不确定过程，可控性不高，就像掷骰子医一样，没有人能确定下一个的点数是多少。

• 面向过程编程与OOP的区别：

（1）面向过程是以过程为核心，程序的运行以一步步的过程的执行为支撑，类似于生产汽车的流水线，但是如果修改了其中一个过程，整个汽车的流水线就会出现不可避免的错误，因此其可拓展性不高。

（2）一步步过程的结果都是由代码决定的，解决一个需求只需要罗列代码即可，将复杂的问题简单化，流程化并且结果尽在程序员的掌握之中。

• 那么该从哪里开始着手OOP呢？？？

• 类和对象

• 什么叫做类：具有相同特征（变量）以及技能功能（函数）的对象全体的集合（注意这里的集合并不是说编程中的集合set容器类型，而是数学意义上的集合）

•  那么对象显而易见就是类中的其中一个任意元素，它具备类中的相同特征和功能，但是特征和功能的具体取值和作用结果却不一样，类似于同样都是身高，不同人的身高各有差异，都有乒乓球这个功能，但是打出来的技术水平也是参差不齐。

• 声明

• class Player:               # 定义一个类 我们常用的字典其实也是一个类，其调用方法和功能一样
      field = 'basketball'    # 类的属性名为field 其值为'basketball'
      def playoff(self):      # 类的技能或者功能名，他们都能够打playoff
          print('win championship')   

• 两种作用

1. 属性引用

• class Player:               # 定义一个类 我们常用的字典其实也是一个类，其调用方法和功能一样
      field = 'basketball'    # 类的属性名为field 其值为'basketball'
      def playoff(self):      # 类的技能或者功能名，他们都能够打playoff
          print('win championship')   

  print(Player.field)         # 引用球员的领域属性
  print(Player.playoff)       # 引用球员的季后赛技能   attention！！！！ 这里不是调用哦 输出的是函数名地址<function Player.playoff at 0x00000000024EA8C8>
  
  

   

2. 实例化引用

• class Player:               # 定义一个类 我们常用的字典其实也是一个类，其调用方法和功能一样
      field = 'basketball'    # 类的属性名为field 其值为'basketball'

  def __init__(self,name,team,position,number):      # 实例化函数 就是将类一步一步转化为一个个栩栩如生的对象，self必须写，其他的分别是将要赋值于对象的各种属性的具体的值
          self.name = name                        # 此name非彼name，跟在self.后面的name是一个内置方法，只不过给他取了一个名字叫name比较容易理解一点，其实取啥名字都可以，后面一个name才是对象的名字
          self.team = team                        # 同上
          self.position = position
          self.champion_number = number
  
      def playoff(self,name,num):      # 类的技能或者功能名，他们都能够打playoff
          print('%s win %s championship'%(name,num))
  
  kobe = Player('kobe bryant','lakers','SG','5')   # 相当于Player.__init__(self,'kobe bryant'......)
  james = Player('Lebron James','lakers','SF','5')
  print(kobe.name)                                 # 通过name属性来调用每个对象不同的属性的值(不同特征）
  print(kobe.field)                                # 统一声明的类的属性 对象都可以调用
  kobe.playoff(kobe.name,kobe.champion_number)     # 调用对象的方法或者技能名
  james.playoff(james.name,james.champion_number)

  实例化函数就好比女娲造人，给予了他们都是人的类别，而他们姓名身高体重眼睛的大小的属性都需要实例化函数这个（基因）来赋予，相应的他们的技能和方法也都需要基因来各自基于他们各自行业的天赋。

• 对象之间的交互

• import random
  import time
  
  
  class Hero:
  
      def __init__(self,name,level,blood,att,q_hurt,w_hurt,e_hurt):
          # 简便写法
          lcs = locals()
          lcs.pop("self")
          self.__dict__.update(lcs)
  
      def attack(self,enemy):
          enemy.blood -= self.att
          print("%s对%s释放了普通攻击 造成了%s的伤害 敌人剩余血量%s" % (self.name, enemy.name, self.att, enemy.blood))
          if enemy.blood <= 0:
              print("%s被%s使用普通攻击击杀了" % (enemy.name,self.name))
  
  
      def Q(self,enemy):
          enemy.blood -= self.q_hurt
          print("%s对%s释放了Q 造成了%s的伤害 敌人剩余血量%s" % (self.name, enemy.name, self.q_hurt, enemy.blood))
          if enemy.blood <= 0:
              print("%s被%s使用Q技能击杀了" % (enemy.name, self.name))
  
      def W(self,enemy):
          enemy.blood -= self.w_hurt
          print("%s对%s释放了W 造成了%s的伤害 敌人剩余血量%s" % (self.name, enemy.name, self.w_hurt, enemy.blood))
          if enemy.blood <= 0:
              print("%s被%s使用W技能击杀了" % (enemy.name, self.name))
  
      def E(self,enemy):
          enemy.blood -= self.e_hurt
          print("%s对%s释放了E 造成了%s的伤害 敌人剩余血量%s" % (self.name,enemy.name,self.e_hurt,enemy.blood))
  
          if enemy.blood <= 0:
              print("%s被%s使用E技能击杀了" % (enemy.name, self.name))
  
  
  h1 = Hero("亚索",20,2000,100,600,0,1000)
  h2 = Hero("妲己",20,2000,100,600,500,1000)
  h3 = Hero("鲁班",20,1500,700,100,200,300)
  h4 = Hero("蔡文姬",20,2000,10,0,0,10)
  
  
  #
  # h1.attack(h2)
  # h2.Q(h1)
  # h2.E(h1)
  # h2.W(h1)
  
  #从字典中随机拿出一个值
  
  def  random_hero(heros):
      hero_index = random.randint(1, len(heros))
      return heros[hero_index]
  
  
  while True:
      # # 把所有的攻击方法装到字典里  为了随机取出一个
      funcs = {1: Hero.Q, 2: Hero.W, 3: Hero.E, 4: Hero.attack}
      func_index = random.randint(1, 4)
      func = funcs[func_index]
  
  
      # 把所有的英雄方法装到字典里  为了随机取出一个
      heros = {1: h1, 2: h2, 3: h3, 4: h4}
      hero = random_hero(heros)
  
      # 剩余的英雄们
      other_heros = {}
      new_index = 1
      for k, v in heros.items():
          if v != hero:
              other_heros[new_index] = v
              new_index += 1
  
      # 从剩余的英雄中随机挑出一个英雄来挨打
      enemy = random_hero(other_heros)
      # 打他
      func(hero, enemy)
      if enemy.blood <= 0:
          break
      time.sleep(0.5)