Python_013(面向对象概念)

一.面向对象

1.面向对象几个概念问题:

a:类:具有相同属性和技能的一类事物.用代码表示就是,我类里面有一些静态变量和方法是大家共有的;

b:对象:具体的类的表现.在代码中就是,调用类的方法或变量传入了一些具体数值而创建的实例;

c:实例化:类-->对象这个过程,代码中的表示:类名+(),这个整体叫实例化对象;

2.类的定义:

 class Person:
     '''类体:两部分:变量部分,方法(函数)部分'''
     mind = '有思想'  #变量,静态变量,静态字段
     animal = '高级动物'

     def work(self):    #方法,函数,动态变量
         print('人类都会工作")
     def shop(self);
         print('人类都会购物')    

a:类的定义一般是class 类名:,由静态变量(静态字段)和方法构成;

b:从类的角度:

　　1)调用类中的静态变量:类名.__dict__查询类中的所有的内容;输出来的格式是字典格式;但不能进行增删改;

　　2)万能的.:类名.变量;可以增删改查;会直接修改在命名空间内

　3):调用类中的方法:类名.方法名(参数),要注意定义类的方法时,方法里有一个self,他就是一个位置参数,如果不传参数,会报错;

　　工作中基本不用这种方式

c:对象的角度:

　　1)在类中有一个特殊的函数

 class Person:
     '''类体:两部分:变量部分,方法(函数)部分'''
     mind = '有思想'  # 变量,静态变量,静态字段
     animal = '高级动物'
     faith = '有信仰'

     def __init__(self,name,age,hobby):
         self.name = name  #  Person.money = '运用货币'
         self.age = age
         self.hobby = hobby

这里面的__init__(self)函数是类的一个特殊函数,只要类名+()产生了一个对象,自动执行类中的__init__方法;

2)为什么不用传参?

　　这里面对self讲解一下:这个__init__方法中的self就是把类名+()这个对象本身传给了__init__()函数中的self;

　 对对象来说,这个是对象的独特的可以调用的函数;初始化对象的一些变量;后面可以方便调用其方法;

#说白了,你的属性可以在任何地方封装,可以在方法里,可以在类中,也可以用对象利用万能的.直接添加,为什么要用__init__

就是为了省代码,在你创建对象时,可以直接传入参数,你调用的所用方法都不用再传了;

3)用函数名+()创建出来对象之后,也可以用__dict__和万能的.对其操作;

二.对象创建示意图

1.

a:从上图我们可以看出:1)步先创建了一块(含有类对象指针的)空间;  2)步这创建的这块空间地址传给__init__中的self;

　　3)步将传入的参数赋值给__init__函数中self(也就是对象)的变量;

　b:需要注意的是,如果对象空间没有这个变量,那它将会通过类对象指针向类中查找,而反过来则不行;

　c;总结; 对象.属性:从对象空间找,如果找不到,再从类空间找,再找不到,再从父类找...

　　　　　类名.属性:先从本类空间找,如果找不到,再从父类找;

2.用计数器记录你的类被别人引用的多少次

 class Person:
     count = 0
     def __init__(self):
         Person.count = Person.count+1　　#因为每次创建对象,这个函数都会自动执行
     def func(self, a, b):
         self.a = a
         return a * b
     def func2(self):
         return self.a
 ret = Person()
 ret = Person()
 ret = Person()
 print(Person.count)
 #输出结果:3

三.类的组合

1.通过两段代码了解类的组合的运用

 # 版本一：添加武器：斧子，刀，枪，棍，棒...,
 # 代码不合理: 人物利用武器攻击别人,你的动作发起者是人,而不是武器.
 class GameRole:
     def __init__(self, name, ad, hp):
         self.name = name
         self.ad = ad
         self.hp = hp

     def attack(self,p):
         p.hp = p.hp - self.ad
         print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name,p.name,p.name,self.ad,p.hp))

 class Weapon:
     def __init__(self,name,ad):
         self.name = name
         self.ad = ad
     def fight(self,p1,p2):
         p2.hp = p2.hp - self.ad
         print('%s 用%s打了%s,%s 掉了%s血,还剩%s血'\
               % (p1.name,self.name,p2.name,p2.name,self.ad,p2.hp))

 p1 = GameRole('大阳哥',20,500)
 p2 = GameRole('印度阿宁',50,200)
 axe = Weapon('三板斧',60)
 broadsword = Weapon('屠龙宝刀',100)

 axe.fight(p1,p2)
 broadsword.fight(p2,p1)

 p1.attack(p2)

#代码不合理之处,谁带上装备发起攻击,调用者肯定是这个谁,而不是这个装备;所以在代码上它是不合理的;

#这里对象就是变量,可以作为参数,也可以进行赋值;

 # 版本二:
 class GameRole:
     def __init__(self, name, ad, hp):
         self.name = name
         self.ad = ad
         self.hp = hp
     def attack(self,p):
         p.hp = p.hp - self.ad
         print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name,p.name,p.name,self.ad,p.hp))
     def armament_weapon(self,wea):
         self.wea = wea

 class Weapon:
     def __init__(self,name,ad):
         self.name = name
         self.ad = ad
     def fight(self,p1,p2):
         p2.hp = p2.hp - self.ad
         print('%s 用%s打了%s,%s 掉了%s血,还剩%s血'\
               % (p1.name,self.name,p2.name,p2.name,self.ad,p2.hp))

 p1 = GameRole('大阳哥',20,500)
 p2 = GameRole('印度阿宁',50,200)
 axe = Weapon('三板斧',60)
 broadsword = Weapon('屠龙宝刀',100)
 p1.armament_weapon(axe)  # 给大阳哥 装备了三板斧这个对象.
 p1.wea.fight(p1,p2)

#所以类之间的组合就是,你想让谁调用,就给对象所在类创建一个方法,把用来调用其他类所创建的对象;

这里第26行就是把另一类的对象作为参数传给p1,p1再通过27行的形式调用;