类和OOP
1.类是在Python实现支持继承的新种类对象的部件。类是Python面向对象程序设计（OOP）的主要工具。
2.通过代码建立连接对象树，而每次使用object.attribute表达式时，Python会在运行期间去“爬树”，来搜索属性。
3.类提供了所有子类共享的行为，但是因为搜索是由下而上，子类可能会在树中较低位置重新定义超类的变量名，从而覆盖超类定义的行为。
4.基类（base class）= 超类，派生类（derived class）= 子类
5.类连接至超类的方式是，将超类列在类头部的括号内。其从左至右的顺序会决定树中的次序。
6.当def出现在类的内部时，通常称为方法，而且会自动接收第一个特殊参数（通常称为self）,这个参数提供了被处理实例的参照值。
7.OOP就是在查找连接对象树中的属性。我们将这样的查找称为继承搜索。
8.类方法函数中的第一个参数之所以特殊，是因为它总是接受将方法调用视为隐含主体的实例对象。按惯例，通常称为self。
9.类名称总是存在于模块中。
10.类名称应该以一个大写字母开头。
11.模块反应了整个文件，而类只是文件内的语句。
12.类和模块的第三个主要差别：运算符重载。运算符重载就是让用类写成的对象，可截获并响应用在内置类型上的运算：加法、切片、打印和点号运算等。
13.以双下划线命名的方法（__X__）是特殊钩子
14.当实例出现在内置运算时，这类方法会自动调用。
15.类可覆盖多数内置类型运算
16.运算符覆盖方法没有默认值，而且也不需要。提供了一致性，以及与预期接口的兼容性。
17.除非类需要模仿内置类型接口，不然应该使用更简单的命名方法。
18.__add__返回的内容为+表达式的结果。对于Print，Python把要打印的对象传递给__str__中的self
19.几乎每个实际的类似乎都会出现的一个重载方法是：__init__构造函数
20.每个实例都连接至其类以便于继承，可以使用__class__查看
21.类的__bases__属性，它是其超类的元组。
22.方法函数中的特殊self参加__init__构造函数是Python中OOP的两个基石。
更多实例
在Python中，模块名使用小写字母开头，而类名使用一个大写字母开头，这是通用的惯例。
赋给实例属性第一个值的通常方法是：在__init__构造函数方法中将它们赋给self，构造函数方法包含了每次创建一个实例的时候Python会自动运行的代码。
一个函数定义中，在第一个拥有默认值的参数之后的任何参数，都必须拥有默认值。
步骤1.创建实例
class Person(AttrDisplay):
def __init__(self,name,job=None,pay=0):
self.name=name
self.job=job
self.pay=pay
def lastName(self):
return self.name.split()[-1]
def giveRaise(self,percent):
self.pay = int(self.pay *(1+percent))
class Manager(Person):
def __init__(self,name,pay):
Person.__init__(self,name,'mgr',pay)
def giveRaise(self,percent,bonus=.10):
Person.giveRaise(self,percent + bonus)
if __name__ == '__main__':
bob = Person('Bob Smith')
sue = Person('Sue Jones',job='dev',pay=100000)
print(bob)
print(sue)
print(bob.lastName(),sue.lastName())
sue.giveRaise(.10)
print(sue)
tom = Manager('Tom Jones',50000)
tom.giveRaise(.10)
print(tom.lastName())
print(tom)步骤2.添加行为方法
在类之外的硬编码操作可能会导致未来的维护问题。
分币操作：内置函数round(N,2)来舍入并保留分币、使用decimal类型来修改精度，或者把货币值存储为一个完整的浮点数并且使用一个%.2f或{0:2f}格式化字符串来显示它们从而显出分币。
步骤3.运算符重载
__repr__提供对象的一种代码低层级显示。
类提供了一个__str__以便实现用户友好的显示，同时也提供了一个__repr__以便让开发者看到额外的细节。
步骤4.通过子类定制行为
好的方法调用：常规方法instance.method(args...)
python自动地转换为如下形式：class.method(instance,args..)
如果直接通过类来调用，必须手动的传递实例。方法需要一个主体实例，python只是对通过实例调用的方式自动提供实例。通过类名调用的方式，需要自己给self发送一个实例。
步骤5.定制构造函数
OOP机制中重要的概念：
实例创建--填充实例属性。
行为方法--在类方法中封装逻辑。
运算符重载--为打印这样的内置操作提供行为。
定制行为--重新定义子类中方法以使其特殊化。
定制构造函数--为超类步骤添加初始化逻辑。
组合类其他方式：内置函数getattr来拦截未定义属性的访问，并将它们委托给嵌入的对象。
步骤6.使用内省工具
内置的instance.__class__属性提供了一个从实例到创建它的类的链接。类反过来有一个__name__(就像模块一样），还有一个__bases__序列，提供了超类的访问。
内置的object.__dict__属性提供了一个字典，带有一个键/值对
工具类命名考虑：为了减少名称冲突，python程序员常常对于不想做其他用途的方法添加一个单个下划线的前缀。
一种更好的但不太常用的方法是，只在方法名前面使用两个下划线符号：对我们的例子来说就是__gatherAttrs。Python自动扩展这样的名称，以包含类的名称，从而使它们变得真正唯一。这一功能通常叫做伪私有类属性。
class AttrDisplay:
def gatherAttrs(self):
attrs=[]
for key in sorted(self.__dict__):
attrs.append('%s=%s' %(key,getattr(self,key)))
return ','.join(attrs)
def __str__(self):
return '[%s:%s]' %(self.__class__.__name__,self.gatherAttrs())
# if __name__=='__main__':
# class TopTest(AttrDisplay):
# count=0
# def __init__(self):
# self.attr1 = TopTest.count
# self.attr2 = TopTest.count+1
# TopTest.count += 2
# class SubTest(TopTest):
# pass步骤7.把对象存储到数据库中
pickle模块是一种非常通用的对象格式化和解格式化工具：对于内存中机会任何的Python对象，它都能聪明地把对象转换为字节串，这个字节串可以随后用来在内存中重新构建最初的对象。
Shelve使用pickle把一个对象转换为其pickle化的字符串，并将其存储在一个dbm文件中的键之下；随后载入的时候，shelve通过键获取pickle化的字符串，并用pickle在内存中重新创建最初的对象。
import shelve
db = shelve.open('persondb')
for object in (bob,sue,tom):
db[object.name] =object
db.close()在shelve中，键可以是任何字符串，包括我们使用诸多处理ID和时间戳（可以在os中和time标准库模块中使用）的工具所创建的唯一字符串。键必须是字符串并且应该是唯一的。
交互式地探索shelve
当前目录下的文件
import shelve
db = shelve.open('persondb')
print(len(db))
print(list(db.keys()))
bob =db['Bob Smith']
print(bob)
print(bob.lastName())
for key in db:
print(key,'==>',db[key])
for key in sorted(db):
print(key,'==>',db[key])可以自由调用方法是因为python对一个类实例进行pickle操作，它记录了其self实例属性，以及实例所创建于的类的名字和类的位置。
更新shelve中的对象
import shelve
db = shelve.open('persondb')
for key in sorted(db):
print(key,'\t=>',db[key])
sue = db['Sue Jones']
sue.giveRaise(.10)
db['Sue Jones']=sue
db.close()需要多执行几次，可看到改变。
GUI：Tkinter、WxPython和PyQt
Web站点：可以用python自带的基本CGI脚本编程工具来构建，也可以用像Django、TurboGears、Pylons、web2Py、Zope或Google's App Engine这样的全功能第三方web开发框架来完成。
在web上，数据仍然可以存储在shelve、pickle文件或其他基于python的媒介中；处理它的脚本直接自动在服务器上运行，以相应来自Web浏览器和其他客户端的请求，并且它们生产HTML来与一个用户交互，而不是直接或通过框架API与用户交互。
Web服务：尽管web客户端可以屏幕抓取（解析来自web站点的回复中的信息），还是要提供更直接的方法从web获取记录：通过像SOAP或XML-RPC这样一个web服务器接口来调用python自身或第三方开源域所支持的API。
数据库：可从shelve转移到像开源的ZODB面向对象数据库系统（OODB）中，或者像MySQL、Oracle、PostgreSQL或SQLite这样基SQL的数据库系统中。
ORM：如果要迁移到关系数据库中存储，不一定要牺牲python的OOP工具。像SQLObject和SQLAlchemy这样的对象关系映射器（ORM），可以自动实现关系表和行与python的类和实例之间的映射，就可以使用常规的python类语法来处理存储的数据。
注意：复制代码会产生冗余性，当代码改进的时候这是一个主要问题。通用性工具可以避免硬编码解决方案，而后者必须随着时间推移和类的改进保持与类的其他部分同步。
类代码编写细节
1.python的class不是声明式的。就像def一样，class语句是对象的创建者并且是一个隐含的赋值运算--执行时，它会产生类对象，并把其引用值存储在前面所使用的变量名。
class NextClass:
def printer(self,text):
self.message = text
print(self.message)
#实例调用
x = NextClass()
x.printer('abc')
#类调用
NextClass.printer(x,'abc')2.调用超类构造函数
class Super:
def __init__(self,x):
...default code...
class Sub(Super):
def __init__(self,x,y):
Super.__init__(self,x)
...custom code...
I = Sub(1,2)3.类接口技术
Super：定义一个method函数以及在子类中期待一个动作的delegate
Inheritor：没有提供任何新的变量名，因此会获得Super中定义的一切内容
Replacer：用自己的版本覆盖Super的method
Extender：覆盖并回调默认method，从而定制Super的method
Provider：实现Super的delegate方法预期的action方法
class Super:
def method(self):
print('in Super.method')
def delegate(self):
self.action()
class Inheritor(Super):
pass
class Replacer(Super):
def method(self):
print('in Replacer.method')
class Extender(Super):
def method(self):
print('starting Extender.method')
Super.method(self)
print('ending Extender.method')
class Provider(Super):
def action(self):
print('in Provider.action')
if __name__ == '__main__':
for klass in (Inheritor,Replacer,Extender):
print('\n'+klass.__name__+'...')
klass().method()运行结果：
Inheritor...
in Super.method
Replacer...
in Replacer.method
Extender...
starting Extender.method
in Super.method
ending Extender.method4.python2.6和python3.0的抽象超类
在class头部使用一个关键字参数，以及特殊的@装饰器语法(py3.0)
from abc import ABCMeta,abstractmethod
class Super(metaclass=ABCMeta):
@abstractmethod
def method(self,...):
passpy2.0
class Super:
__metaclass__ = ABCMeta
@abstractmethod
def method(self,...):
pass带有一个抽象方法的类是不能继承的（不能调用它来创建一个实例），除非所有抽象方法都已经在子类中定义了。
5.实例和类的特殊属性__class__和__bases__
这些属性可以在程序代码内查看继承层次。例如：显示类树
def classtree(cls,indent):
print('.'*indent + cls.__name__)
for supercls in cls.__bases__:
classtree(supercls,indent+3)
def instancetree(inst):
print('Tree of %s' %inst)
classtree(inst.__class__,3)
def selftest():
class A: pass
class B(A): pass
class C(A): pass
class D(B,C):pass
class E: pass
class F(D,E):pass
instancetree(B())
instancetree(F())
if __name__ =='__main__':
selftest()Tree of <__main__.selftest.<locals>.B object at 0x0000024B0C6AF3C8>
...B
......A
.........object
Tree of <__main__.selftest.<locals>.F object at 0x0000024B0C6AF3C8>
...F
......D
.........B
............A
...............object
.........C
............A
...............object
......E
.........object6.文档字符串
出现在各种结构的顶部的字符串常量，由python在相对应对象的__doc__属性自动保存。它适用于模块文件、函数定义，以及类和方法。
docstr.py
"I am:docstr.__doc__"
def func(args):
"I am:docstr.func.__doc__"
pass
class spam:
"I am:spam.__doc__ or docstr.spam.__doc__"
def method(self,arg):
"I am spam.method.__doc__ or self.method.__doc__"
pass
>>> docstr.__doc__
'I am:docstr.__doc__'
>>> docstr.func.__doc__
'I am:docstr.func.__doc__'
>>> docstr.spam.__doc__
'I am:spam.__doc__ or docstr.spam.__doc__'
>>> docstr.spam.method.__doc__
'I am spam.method.__doc__ or self.method.__doc__'比#缺乏灵活性
运算符重载
构造函数和表达式：__init__和__sub__
class Number:
def __init__(self,start):
self.data = start
def __sub__(self,other):
return Number(self.data - other)很多重载方法有好几个版本（例如，加法有__add__、__radd__、__iadd__）
常见的运算符重载方法：
__init__（构造函数）：对象建立,X = Class(args)
__del__（析构函数）：X对象收回
__add__（运算符+）:如果没有__iadd__，X + Y，X += Y
__or__（运算符|，位OR）：如果没有__ior__，X | Y ，X |= Y
__repr__，__str__（打印、转换）：print(X)、repr(X)、str(X)
__call__（函数调用）：X（*args,**kargs）
__getattr__（点号运算）：X.underfined
__setattr__（属性赋值语句）：X.any = value
__delattr__（属性删除）：del X.any
__getattribute__（属性获取）：X.any
__getitem__（索引运算）：X[key],X[i:j]，没__iter__时的for循环和其他迭代器
__setitem__（索引赋值语句）：X[key] = value,X[i:j] = sequence
__delitem__（索引和分片删除）：del X[key],del X[i:j]
__len__（长度）：len(X)，如果没有__bool__，真值测试
__bool__（布尔测试）：bool(X)，真测试（py2.6中为__nonzero__）
__lt__,__gt__,__le__,__ge__,__eq__,__ne__：特定值比较（py2.6只有__cmp__）
__radd__（右侧加法）：Other + X
__iadd__（实地（增强的）加法）：X += Y（or else __add__）
__iter__,__netx__（迭代环境），I=iter(X),next(I);for loops,in if no __contains__,all comprehensions,manp(F,X),其他（__next__在py2.6中称为next）
__contains__（成员关系测试）：item in X（任何可迭代的）
__index__（整数值）：hex(X），bin(X),oct(X),O[x],O[X:]（替代py2.6中的__oct__、__hex__）
__enter__,__exit__（环境管理器）：with obj as var:
__get__,__set__，__delete__（描述符属性）：X.attr,X.attr = value,del X.attr
__new__(创建):在__init__之前创建对象
1.一般来讲，只有在对象不支持迭代器对象协议的时候（__iter__和__next__）才会尝试索引运算（__getitem__）
迭代器是用来迭代，不是随机的索引运算。迭代器根本没有重载索引表达式。迭代器只循环一次，循环之后就变为空。每次新的循环，都得创建一个新的迭代器对象。
__contains__方法优于__iter__方法，__iter__方法优于__getitem__方法
class Iters:
def __init__(self,value):
self.data = value
def __getitem__(self, i):
print('get[%s]:'%i,end=' ')
return self.data[i]
def __iter__(self):
print('iter=>',end=' ')
self.ix = 0
return self
def __next__(self):
print('next：',end=' ')
if self.ix == len(self.data):raise StopIteration
item = self.data[self.ix]
self.ix += 1
return item
def __contains__(self, x):
print('contains:',end=' ')
return x in self.data
X = Iters([1,2,3,4,5])
print(3 in X)
for i in X:
print(i,end='|')
print()
print([i **2 for i in X])
print(list(map(bin,X)))
I = iter(X)
while True:
try:
print(next(I),end='@')
except StopIteration:
break
2. __setattr__会拦截所有属性的赋值语句。可能会导致无穷的递归循环（最后就是堆栈溢出异常）。所以要通过对属性字典做索引运算来赋值任何势力属性。使用self.__dict__['name']=x，而不是self.name=x
模拟实例属性的私有性
class PrivateExc(Exception):pass
class Privacy:
def __setattr__(self, attrname, value):
if attrname in self.privates:
raise PrivateExc(attrname,self)
else:
self.__dict__[attrname] = value
class Test1(Privacy):
privates = ['age']
class Test2(Privacy):
privates = ['name','pay']
def __init__(self):
self.__dict__['name'] = 'Tom'
x =Test1()
y=Test2()
x.name = 'Bob'
y.name = 'Sue' #fails
y.age = 30
x.age =40 #fails模拟private 声明。不准在类外对属性名进行修改。
可以使用类装饰器来更加通用的拦截和验证属性。
3.如果没有定义__str__，打印还是使用__repr__。但反之不成立，交互式相应模式，只是使用__repr__，并且根本不要尝试__str__。
str和repr都必须返回字符串。str可能只有当对象出现在一个打印操作顶层的时候才应用，嵌套到较大的对象中的对象可能用其repr或默认方法打印。
>>> class Printer:
def __init__(self,val):
self.val = val
def __str__(self):
return str(self.val)
>>> objs =[Printer(2),Printer(3)]
>>> for x in objs :print(x)
2
3
>>> print(objs)
[<__main__.Printer object at 0x0000014877FA1198>, <__main__.Printer object at 0x000001487801ED30>]
>>> objs
[<__main__.Printer object at 0x0000014877FA1198>, <__main__.Printer object at 0x000001487801ED30>]
>>> class Printer:
def __init__(self,val):
self.val = val
def __repr__(self):
return str(self.val)
>>> objs =[Printer(2),Printer(3)]
>>> for x in objs :print(x)
2
3
>>> print(objs)
[2, 3]
>>> objs
[2, 3]4.右侧加法和原处加法__radd__和__iadd__
当不同实例混合出现在表达式时，python优先选择左侧那个类。
>>> class Number:
def __init__(self,val):
self.val = val
def __iadd__(self,other):
self.val += other
return self
>>> x = Number(5)
>>> x += 1
>>> x += 1
>>> x.val
7
>>> class Number:
def __init__(self,val):
self.val = val
def __add__(self,other):
return Number(self.val + other)
>>> x = Number(5)
>>> x += 1
>>> x += 1
>>> x.val
75.__call__
>>> class Callee:
def __call__(self,*pargs,**kargs):
print('Called:',pargs,kargs)
>>> C = Callee()
>>> C(1,2,3)
Called: (1, 2, 3) {}
>>> C(1,2,3,x=4,y=5)
Called: (1, 2, 3) {'x': 4, 'y': 5}当需要为函数的API编写接口时，__call__可以编写遵循所需要的函数来调用接口对象，同时又能保留状态信息。
注：tkinter GUI工具箱（在py2.6中是Tkinter）可以把函数注册成事件处理器（也就是回调函数call back）。当事件发生时，tkinter会调用已注册的对象。如果想让事件处理器保存事件之间的状态，可以注册类的绑定方法（bound method）或者遵循所需接口的实例（使用__call__）。
import tkinter
top = tkinter.Tk()
class Callback:
def __init__(self,color):
self.color = color
def __call__(self):
print('turn',self.color)
cb1 = Callback('blue')
cb2 = Callback('green')
B1 = tkinter.Button(top,text='点我变蓝',command=cb1)
B2 = tkinter.Button(top,text='点我变绿',command=cb2)
B1.pack()
B2.pack()
top.mainloop()6.比较：__lt__、__gt__
比较方法没有右端形式。
7.真值测试：__bool__、__len__
python3中 喜欢__bool__胜过__len__，因为它更具体。
8.对象析构函数：__del__
实例产生时，会调用__init__。实例空间被收回时，__del__会自动执行。
类的设计
1.类的OOP实现概括为：继承、多态、封装
python中的多态是基于对象接口的，而不是类型。
2.重访流处理器
编写类，使用组合机制工作，来提供更强大的结构并支持继承。
streams.py定义了一个转换器方法。
class Processor:
def __init__(self,reader,writer):
self.reader = reader
self.writer = writer
def process(self):
while 1:
data =self.reader.readline()
if not data:break
data = self.converter(data)
self.writer.write(data)
def converter(self,data):
assert False,'converter must be defined'converters.py在子类提供转换器逻辑。
from streams import Processor
class Uppercase(Processor):
def converter(self,data):
return data.upper()
if __name__=='__main__':
import sys
obj = Uppercase(open('spam.txt'),sys.stdout)
obj.process()3.pickle机制把内存中的对象转换成序列化的字节流，可以保存在文件中，也可以通过网络发送出去。解除pickle状态则是从字节流转换回同一个内存中的对象，Shelve也类似。但是它会自动把对象pickle生成按键读取的数据库，而此数据库会导出类似于字典的接口。
4.OOP和委托：‘包装’对象
委托（delegation），通常就是指控制器对象内嵌其他对象，而把运算请求传给那些对象。常以__getattr__钩子方法实现，因为这个方法会拦截对不存在属性的读取，包装类（有时称为代理类）可以使用__getattr__把任意读取转发给被包装的对象。包装类包有被包装对象的接口，而且自己也可以增加其他运算。
class wrapper:
def __init__(self,object):
self.wrapped = object
def __getattr__(self, attrname):
print('Trace:',attrname)
return getattr(self.wrapped,attrname)
getattr(X,N)就像X.N,只不过N是表达式，可在运行时计算出字符串，而不是变量。
getattr（X,N）类似于X.__dict__[N],但前者也会执行继承搜索，就像X.N,，而getattr(X,N)则不会。
5.类的伪私有属性
变量名压缩（mangling，相当于扩张），让类内某些变量局部化。主要是为了避免实例内的命名空间的冲突，而不是限制变量名的读取。所以是伪私有。编写内部名称（_X）。
变量名压缩只发生在class语句内，而且只针对开头有两个下划线的变量名。（self.__X会变成self._Spam(类名)__X）
6.方法是对象：绑定或无绑定
class Spam:
def doit(self,message):
print(message)
#绑定
object1 = Spam()
x = object1.doit
x('hello world')
#无绑定
object2 =Spam()
t = Spam.doit
t(object2,'howdy')py2.6中无绑定方法默认的需要传递一个实例，3.0这样的方法会当作一个简单的函数，不需要一个实例
7.用__dict__列出实例属性
class ListInstance:
def __str__(self):
return '<Instance of %s,address %s:\n%s>'%(self.__class__.__name__,
id(self),self.__attrnames())
#通过id内置函数显示了实例的内存地址。
def __attrnames(self):
result = ''
for attr in sorted(self.__dict__):
result += '\tname %s=%s\n'%(attr,self.__dict__[attr])
return result
#使用伪私有命名模式：__attrnames
class Spam(ListInstance):
def __init__(self):
self.data1 = 'food'
x =Spam()
print(x)8.用dir列出继承的属性
class ListInstance:
def __str__(self):
return '<Instance of %s,address %s:\n%s>'%(self.__class__.__name__,
id(self),self.__attrnames())
def __attrnames(self):
result = ''
for attr in dir(self):
if attr[:2] == '__' and attr[-2:] =='__':
result += '\tname %s=<>\n'%attr
else:
result += '\tname %s=%s\n'%(attr,getattr(self,attr))
return result
#使用getattr内置函数来获取属性9.钻石继承变动
对经典类而言，继承搜索程序是绝对深度优先，然后才是由左至右。
在新式类中，搜索相对来说是宽度优先的。python先寻找第一个搜索的右侧的所有超类，然后才一路往上搜索至顶端共同的超类。
10.新式类的扩展
将字符串属性名称顺序赋值给特殊的__slots__类属性，新式类就有可能既限制类的实例将有的合法属性集，又能优化内存和速度性能。
Slot对于python动态特性来说是一种违背，而动态特性要求任何名称都可以通过赋值来创建。
11.类特性
特性（property）机制，提供另一种方式让新式类定义自动调用的方法，来读取或赋值实例属性。
特性一般都是在class语句顶层赋值[例如：name=property(...)]。这样赋值时，对类属性本身的读取(例如,obj.name)，就会自动传给property的一个读取方法。
12.__getattribute__方法只适用于新式类，可以让类拦截所有属性的引用，而不局限于未定义的引用(如果__getattr__)
13.静态方法大致与一个类中的简单的无实例函数类似地工作，类方法传递一个类而不是一个实例。
python现在支持三种类相关方法：实例、静态和类。
类方法可能更适合处理对层级中的每个类不同的 数据。
14.函数装饰器(function decorator)提供了一种方式，替函数明确了特定的运算模式，也就是将函数包裹了另一层，在另一函数的逻辑内实现。
类装饰器类似于函数装饰器，但是在一条class语句的末尾运行，并且把一个类名重新绑定到一个可调用对象。
元类是一种类似于基于类的高级工具，其用途往往与类装饰器有所重合。它们提供了一个可选的模式，会把一个类对象的创建导向到顶级type类的一个子类，在一条class语句的最后。
元类通常重新定义type类的__new__或__init__方法，以实现对一个新的类对象的创建初始化的控制。
15.类（和类实例）是可改变的对象。就像内置列表和字典一样，可以给类属性赋值，冰洁进行再原处的修改，同时意味着修改类或实例对象，也会影响对它的多处引用。
由于类属性由所有实例共享，所以如果一个类属性引用一个可变对象，那么从任何实例来原处修改该对象都会立刻影响到所有实例。
16.正常（实例）方法会接受第一个self参数（隐含的实例），但是静态方法不是这样。静态方法只是嵌套在类对象中的简单函数。