类/封框

开发的思想-面向过程
面向过程：根据业务逻辑从上到下写垒代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强”

类：用来描述具有 相同 的属性与方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
类变量：类变量在整个实例化的对象中是公用。类变量定义在类中，函数数之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其中实例对象的相关的数据
方法重复：从父类继承的方法不能够满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖，也称为方法的重写。
实例变量：定义在方法中的变量，只用作于当前实例的类
继承：即一个派生类，继承父类的子段与方法
实例化：创建类的实例，类的具体对象
方法：类中定义的函数
对象：通过类定义的数据结构。对象包括数据成员（类变量与实例变量） 和 方法

 

类和对象在内存中是如何保存？
类以及类中的方法在内存中只有一份，而根据类创建的每一个对象都在内存中需 要存一份

方法：
方法包括：普通方法、静态方法和类方法三种方法在内存中都归属于类，区别在于调用方式不同。

类方法：由类调用；至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；

静态方法：由类调用；无默认参数

方法示例
class Foo:
def __init__(self,n):
self.name=n
def ord_func(self):
"""定义普通方法，至少一个self参数"""
print("普通方法")
@classmethod
def class_func(cls):
"""定义类方法，至少一个cls参数"""
print("类方法")
@staticmethod
def static_func():
"""定义静态方法，无默认参数"""
print("静态方法！")

#调用普通方法
f=Foo("gloryroad")
f.ord_func()

#调用类方法
Foo.class_func()

#调用静态方法
Foo.static_func()

执行结果：
...
>>> #调用普通方法
... f=Foo("gloryroad")
>>> f.ord_func()
普通方法
>>>
>>> #调用类方法
... Foo.class_func()
类方法
>>>
>>> #调用静态方法
... Foo.static_func()
静态方法！
>>>

 

 

类的创建
class Employee(object):
#所有员工 的基类
empCount=0
def __init__(self,name,salary):
#类的构造函数
self.name=name
self.salary=salary
Employee.empCount+=1

def displayCount(self):#类方法
print("total employe:",Employee.empCount)

def displayEmployee(self):
print("name:",self.name,"salary:",self.salary)

执行结果：
>>> test1=Employee("zhangshuqin",100)
>>> test2=Employee("sq",500)
>>> test1.displayCount()#实例调用方法
total employe: 8
>>> test1.displayEmployee()#实例调用方法
name: zhangshuqin salary: 100
>>> test2.displayCount()#实例调用方法
total employe: 8
>>> test2.displayEmployee()#实例调用方法
name: sq salary: 500
>>>

函数式编程（面向对象）
练习1：在终端下输出如下信息
小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健
老张...

class Foo:
def __init__(self,name,age,gender):
self.name=name
self.age=age
self.gender=gender
def kanchai(self):
print("%s,%s岁,%s,上山去砍柴"%(self.name,self.age,self.gender))
def qudongbei(self):
print("%s,%s岁,%s,开车去东北"%(self.name,self.age,self.gender))
def dabaojian(self):
print("%s,%s岁,%s,最爱大保健"%(self.name,self.age,self.gender))

xm=Foo("小明",10,"男")
xm.kanchai()
xm.qudongbei()
xm.dabaojian()

laoli=Foo("小明",10,"男")
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()

执行结果：
>>> xm=Foo("小明",10,"男")
>>> xm.kanchai()
小明,10岁,男,上山去砍柴
>>> xm.qudongbei()
小明,10岁,男,开车去东北
>>> xm.dabaojian()
小明,10岁,男,最爱大保健
>>>
>>> laoli=Foo("小明",10,"男")
>>> laoli.kanchai()
小明,10岁,男,上山去砍柴
>>> laoli.qudongbei()
小明,10岁,男,开车去东北
>>> laoli.dabaojian()
小明,10岁,男,最爱大保健
>>>
>>>

练习二：游戏人生程序
1、创建三个游戏人物，分别是：
苍井井，女，18，初始战斗力1000
东尼木木，男，20，初始战斗力1800
波多多，女，19，初始战斗力2500
2、游戏场景，分别：
草丛战斗，消耗200战斗力
自我修炼，增长100战斗力
多人游戏，消耗500战斗力
class Person:
def __init__(self,name,sex,age,flg):
self.name=name
self.sex=sex
self.age=age
self.flight=flg
def grassFlight(self):#草丛战斗
self.flight=self.flight-200
print(self.flight)
def selfExcise(self):#自我修炼
self.flight=self.flight+100
print(self.flight)
def MorePersonFlight(self):#多人游戏
self.flight=self.flight-500
print(self.flight)
def detail(self):
print("姓名:%s,性别:%s,年龄:%s,战斗力:%s"%(self.name,self.sex,self.age,self.flight))

p1=Person("苍井井","女",18,300)
p2=Person("东尼木木","男",20,500)
p3=Person("波多多","女",19,600)

p1.grassFlight()
p2.selfExcise()
p3.MorePersonFlight()

p1.detail()
p2.detail()
p3.detail()

执行结果：
>>> p1.grassFlight()
100
>>> p2.selfExcise()
600
>>> p3.MorePersonFlight()
100
>>>
>>> p1.detail()
姓名:苍井井,性别:女,年龄:18,战斗力:100
>>> p2.detail()
姓名:东尼木木,性别:男,年龄:20,战斗力:600
>>> p3.detail()
姓名:波多多,性别:女,年龄:19,战斗力:100
>>>