python教程11-面向对象的编程

面向对象的编程
简介
: M( |* e: r& r5 z  Q到目前为止，在我们的程序中，我们都是根据操作数据的函数或语句块来设计程序的。这被称为 面向过程的 编程。还有一种把数据和功能结合起来，用称为对象的东西包裹起来组织程序的方法。这种方法称为 面向对象的 编程理念。在大多数时候你可以使用过程性编程，但是有些时候当你想要编写大型程序或是寻求一个更加合适的解决方案的时候，你就得使用面向对象的编程技术。
+ j# R% S- Z7 F6 i4 w0 l
类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象这个类的 实例 。这类似于你有一个 int 类型的变量，这存储整数的变量是 int 类的实例（对象）。
, Q  ^" _6 t8 S( o
给 C/C++/Java/C#程序员的注释
注意，即便是整数也被作为对象（属于 int 类）。这和 C++、Java（1.5 版之前）把整数纯粹作为类型是不同的。通过 help(int)了解更多这个类的详情。 C#和 Java 1.5 程序员会熟悉这个概念，因为它类似与 封装与解封装 的概念。
, e. s. Y) y1 p1 `7 ~
3 ^5 A3 b: d0 {2 u5 [6 R, K对象可以使用普通的 属于 对象的变量存储数据。属于一个对象或类的变量被称为域。对象也可以使用属于 类的函数来具有功能。这样的函数被称为类的方法。这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为类的属性。
8 Q$ a* Z+ _/ V' M0 d
5 d7 O. }5 {# i: ?4 X, [" M域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。

类使用 class 关键字创建。类的域和方法被列在一个缩进块中。
4 N5 s9 A) V- l! u" G; \3 R1 n: a
self
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python 会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是 self。
5 E( |4 z, G! _! h2 U2 g
虽然你可以给这个参数任何名称，但是 强烈建议 你使用 self 这个名称——其他名称都是不赞成你使用的。使用一个标准的名称有很多优点——你的程序读者可以迅速识别它，如果使用 self 的话，还有些 IDE（集成开发环境）也可以帮助你。

; a! r( ~) ~! k: a1 z给 C++/Java/C#程序员的注释
Python 中的 self 等价于 C++中的 self 指针和 Java、C#中的 this 参考。
5 [3 X5 g( r2 z" V3 N9 D0 J5 D3 n9 o
你一定很奇怪 Python 如何给 self 赋值以及为何你不需要给它赋值。举一个例子会使此变得清晰。假如你有一个类称为 MyClass 和这个类的一个实例 MyObject。当你调用这个对象的方法 MyObject.method(arg1, arg2)的时候，这会由 Python 自动转为 MyClass.method(MyObject, arg1, arg2)——这就是 self 的原理了。

这也意味着如果你有一个不需要参数的方法，你还是得给这个方法定义一个 self 参数。

. h+ M. P- N7 P7 D类
8 w  Q$ {& B4 V. \" q6 ?一个尽可能简单的类如下面这个例子所示。
) B' Q" B1 E5 E/ {1 m' _
创建一个类
例 11.1 创建一个类

1.     #!/usr/bin/python
   
2. 
   
3.     # Filename: simplestclass.py
   
4. 
   
5.     class Person:
   
6. 
   , R9 V4 m+ @- G
7.         pass # An empty block
   5 ]/ d" l# V- f; V" L5 r, N
8. 
   
9.     p = Person()
   
10. 
    
11.     print p
    / z7 ~2 `* T+ A8 a$ O/ {9 x4 s9 K
12. 
    1 h6 {3 F( C$ {0 _

复制代码

" I+ M7 Z- B4 i; c输出

1. $ python simplestclass.py
   
2.     <__main__.Person instance at 0xf6fcb18c>

复制代码

$ w( ?& M# V# F1 `( g% ~它如何工作
9 P) M! O! m; d) m" ~+ s* a: d
/ B3 M, y. J$ A我们使用 class 语句后跟类名，创建了一个新的类。这后面跟着一个缩进的语句块形成类体。在这个例子中，我们使用了一个空白块，它由 pass 语句表示。

) y" H, S& a- ?  H5 s; w6 \接下来，我们使用类名后跟一对圆括号来创建一个对象/实例。（我们将在下面的章节中学习更多的如何创建实例的方法）。为了验证，我们简单地打印了这个变量的类型。它告诉我们我们已经在main模块中有了一个 Person 类的实例。

- ~- ^! a9 j! D5 K, Z' h可以注意到存储对象的计算机内存地址也打印了出来。这个地址在你的计算机上会是另外一个值，因为 Python 可以在任何空位存储对象。
% g0 n, I. o4 t# C, n- h! M
对象的方法
我们已经讨论了类/对象可以拥有像函数一样的方法，这些方法与函数的区别只是一个额外的 self 变量。现在我们来学习一个例子。
" W3 I4 ?$ I. O* ~" p9 s) I# `
/ p  X& v9 ^! q  q3 U4 \使用对象的方法
例 11.2 使用对象的方法

1. #!/usr/bin/python
   % V3 Y# i- s2 w
2.     # Filename: method.py
   
3.     class Person:
   ; u' d# u- ?' k1 w# f
4.         def sayHi(self):
   " S' D% z. W, D+ }, F+ Y
5.             print 'Hello, how are you?'
   
6.     p = Person()
   
7.     p.sayHi()
   $ d* @! b* x  q0 a
8.     # This short example can also be written as Person().sayHi()

复制代码

" v5 P; P! j" d  Z3 {% ?输出
2 N' p' D9 ?1 E& o% I9 H1 F" q

1. $ python method.py
   / O5 L5 r; N& b, E% A* r
2.     Hello, how are you?

复制代码

' q1 J1 U9 f# a; Q! S它如何工作
/ Z: j% D) t* I* ?2 @
" R7 h% V; }7 J这里我们看到了 self 的用法。注意 sayHi 方法没有任何参数，但仍然在函数定义时有 self。
2 P# w/ H# v+ ]' T9 A3 r9 [4 G
8 g- c- @+ K, B5 R0 t, V5 N6 F* pinit 方法
* g5 P4 @) A2 j0 }3 n5 z2 [在 Python 的类中有很多方法的名字有特殊的重要意义。现在我们将学习 init 方法的意义。
6 z7 J. y+ Q# ~. q6 G
# i4 }- e( t2 @, ~2 O$ }; [+ U5 iinit 方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的 初始化 。注意，这个名称的开始和结尾都是双下划线。

使用 init 方法
例 11.3 使用 init 方法
2 a; D  ^# C- U  G& l2 x2 R& I

1. 
   
2.     #!/usr/bin/python
   
3.     # Filename: class_init.py
   
4.     class Person:
   ) l: E( r6 ?+ C! I' n7 }
5.         def __init__(self, name):
   
6.             self.name = name
   ) D& b* p- V" O
7.         def sayHi(self):
   4 e1 v, G# i( o1 k) \
8.             print 'Hello, my name is', self.name
   9 K( [5 ~/ {9 J1 h* j! E
9.     p = Person('Swaroop')
   . M( N; t5 Z6 l- ]0 w
10.     p.sayHi()
    0 p& u! g3 T2 P$ B" Y! t& L$ o
11.     # This short example can also be written as Person('Swaroop').sayHi()

复制代码

; t% t# P9 ?, s2 \) K9 k6 u5 X' S  J- W输出
) |& [7 o) O: q+ _

1. $ python class_init.py
   9 E8 w/ F7 Z2 o9 s
2.     Hello, my name is Swaroop

复制代码

2 ]- k" t* Z+ c8 ]它如何工作

这里，我们把 init 方法定义为取一个参数 name（以及普通的参数 self）。在这个 init 里，我们只是创建一个新的域，也称为 name。注意它们是两个不同的变量，尽管它们有相同的名字。点号使我们能够区分它们。

最重要的是，我们没有专门调用 init 方法，只是在创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给 init 方法。这是这种方法的重要之处。

" b4 U0 J1 ^$ O  ?; D, E现在，我们能够在我们的方法中使用 self.name 域。这在 sayHi 方法中得到了验证。

给 C++/Java/C#程序员的注释
init 方法类似于 C++、C#和 Java 中的 constructor 。

4 ?2 F* c4 Q3 m类与对象的变量
' r% l' p, W' ]我们已经讨论了类与对象的功能部分，现在我们来看一下它的数据部分。事实上，它们只是与类和对象的名称空间 绑定 的普通变量，即这些名称只在这些类与对象的前提下有效。
: @2 S, ]4 }/ @* v! a; C
" a) V! d- D9 Y9 ~( m有两种类型的 域 ——类的变量和对象的变量，它们根据是类还是对象 拥有 这个变量而区分。
2 ~0 U( o% |2 |( z8 G( H+ v$ i
类的变量 由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。
8 S3 C9 k& K! ?" z0 y
对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。通过一个例子会使这个易于理解。
' y% t0 S( Y# L: |! p
8 w* \  T) w6 Y, v' R6 r) v* f7 z# Z使用类与对象的变量
例 11.4 使用类与对象的变量

1. #!/usr/bin/python
   
2. 
   
3.     # Filename: objvar.py
   
4. 
   
5.     class Person:
   ) g  O( b: O, T+ E
6. 
   ( P( e5 V0 O3 i' o7 w
7.          '''Represents a person.'''
   " f$ X5 Y* v1 d* _8 \! {1 B! u
8. 
   
9.         population = 0
   * w! U3 u4 f2 }  `: F/ G
10. 
    
11. 
    8 `% _9 k( ]& \6 @- E/ G4 [
12.         def __init__(self, name):
    
13. 
    / ?) ?6 _' g. ]( x1 M" [
14.             '''Initializes the person's data.'''
    - i! d0 F7 M: p/ `. v" d
15. 
    ' m) c3 U/ ^3 h) t
16.             self.name = name
    4 ~' [4 ]/ M% D5 l$ o& b# U2 `# N5 F2 Y; N
17. 
    & H0 J3 Z7 S" R1 l6 y) C- \
18.             print '(Initializing %s)' % self.name
    # Q: W2 y/ P- N) M/ g  S( }
19. 
    ! M! f- k) f. H) f7 o, Y, |
20. 
    . c7 @: e5 V# Q9 d. K, z5 X7 \
21. 
    . Y, l' t* R2 e1 S" v5 J
22.             # When this person is created, he/she
    & r, p' z. y7 ?  Y6 C
23. 
    
24.             # adds to the population
    8 z+ K; c& y5 c7 C* n
25. 
    
26.             Person.population += 1
    
27. 
    
28. 
    
29. 
    0 K0 a7 Q& ]: B$ V% H" u
30.         def __del__(self):
    
31. 
    
32.             '''I am dying.'''
    
33. 
    5 _" }. L# x5 L
34.              print '%s says bye.' % self.name
    
35. 
    
36. 
    
37. 
    5 s; @7 X# _/ n* c6 F
38.             Person.population -= 1
    
39. 
    
40. 
    
41. 
    
42.             if Person.population == 0:
    7 J8 [' k$ A, l7 {7 K
43. 
    2 R. X+ [3 J" {  U! T
44.                 print 'I am the last one.'
    
45. 
    
46.             else:
    
47. 
    
48.                 print 'There are still %d people left.' % Person.population
    9 O" P; W$ v# F# z
49. 
    
50. 
    & U, i$ ]4 ]- J) t
51. 
    
52.         def sayHi(self):
    
53. 
    9 H1 @- C5 a0 P9 q
54.             '''Greeting by the person.
    : [5 s$ D/ _- n0 a
55. 
    / K. ~7 U, c) k/ G0 a
56. 
    / I$ F# U# d# d
57. 
    
58.             Really, that's all it does.'''
    + r- D& E; o2 v5 L. m- v4 {2 h
59. 
    " L4 r0 W( E* J7 |5 i0 b) g3 G6 B
60.             print 'Hi, my name is %s.' % self.name
    8 h; B( L+ t7 d* p) s5 t6 @2 ~
61. 
    8 l* A- I% h( u9 \
62. 
    
63. 
    
64.         def howMany(self):
    6 m6 J/ D2 z" m, {* g7 N# j
65. 
    ' V7 d, \% s, T5 b0 M% C* z; f! Z+ L
66.             '''Prints the current population.'''
    
67. 
    
68.              if Person.population == 1:
    * j/ K" L2 F6 V4 O$ M3 n
69. 
    2 R8 Q6 F7 e" S9 u; ~
70.                  print 'I am the only person here.'
    
71. 
    
72.             else:
    ' x5 S1 b  U7 E2 I
73. 
    + K$ J) H1 _% @1 J
74.                 print 'We have %d persons here.' % Person.population
    
75. 
    3 p  P, Y# h3 n; Q
76. 
    8 U+ t) P2 ^, L5 |' }2 W5 d) H& O
77. 
    
78.     swaroop = Person('Swaroop')
    3 S' i9 T5 e. U% v
79. 
    
80.     swaroop.sayHi()
    1 I" k( L+ I. ]% h3 y3 @& T
81. 
    
82.     swaroop.howMany()
    
83. 
    
84. 
    + W( Q  Y* H1 N+ K+ p0 p
85. 
    
86.     kalam = Person('Abdul Kalam')
    ! K! ^1 K9 K- _: t; X. `0 u% R
87. 
    % o; R2 S- O% C, s6 l) b% b: ]
88.     kalam.sayHi()
    - Y+ U& _- O6 T
89. 
    
90.     kalam.howMany()
    
91. 
    , W) z5 W) v0 O8 T, \# ]2 ?$ X
92. 
    
93. 
    
94.     swaroop.sayHi()
    0 m' L# i8 J, v
95. 
    
96.     swaroop.howMany()

复制代码

输出
: l. B: t2 V1 F6 o3 a
/ j6 s  E$ K3 w' j( b/ ?# H

1.    $ python objvar.py
   
2.     (Initializing Swaroop)
   # a/ j0 Q5 Z* T
3.     Hi, my name is Swaroop.
   
4.     I am the only person here.
   
5.     (Initializing Abdul Kalam)
   
6.     Hi, my name is Abdul Kalam.
   
7.     We have 2 persons here.
   
8.     Hi, my name is Swaroop.
   8 L6 i9 J6 ?* w
9.     We have 2 persons here.
   
10.     Abdul Kalam says bye.
    : q  W4 Z: v3 c$ S3 Q
11.     There are still 1 people left.
    
12.     Swaroop says bye.
    
13.     I am the last one.

复制代码

3 \7 v0 _" j% {! ?它如何工作

2 @4 ^2 z5 Z2 [这是一个很长的例子，但是它有助于说明类与对象的变量的本质。这里，population 属于 Person 类，因此是一个类的变量。name 变量属于对象（它使用 self 赋值）因此是对象的变量。
/ A* `! I: E# t7 q
观察可以发现 init 方法用一个名字来初始化 Person 实例。在这个方法中，我们让 population 增加 1，这是因为我们增加了一个人。同样可以发现，self.name 的值根据每个对象指定，这表明了它作为对象的变量的本质。

1 v) s8 K( T) h记住，你只能使用 self 变量来参考同一个对象的变量和方法。这被称为 属性参考 。
4 C+ H) q2 g; Y5 R2 I0 `
在这个程序中，我们还看到 docstring 对于类和方法同样有用。我们可以在运行时使用 Person.doc 和 Person.sayHi.doc 来分别访问类与方法的文档字符串。
- a) v1 c2 O" ?6 {
* H0 r# n3 Y  E& ]5 V) _9 c就如同 init 方法一样，还有一个特殊的方法del，它在对象消逝的时候被调用。对象消逝即对象不再被使用，它所占用的内存将返回给系统作它用。在这个方法里面，我们只是简单地把 Person.population 减 1。
" q: O- H) x( D9 B3 I
! N+ C1 |% @: O当对象不再被使用时， del 方法运行，但是很难保证这个方法究竟在 什么时候 运行。如果你想要指明它的运行，你就得使用 del 语句，就如同我们在以前的例子中使用的那样。

6 V2 t: R3 R( u; z) j给 C++/Java/C#程序员的注释
1 L3 x3 x2 g+ M7 tPython 中所有的类成员（包括数据成员）都是 公共的 ，所有的方法都是 有效的 。 只有一个例外：如果你使用的数据成员名称以 双下划线前缀 比如 privatevar，Python 的名称管理体系会有效地把它作为私有变量。 这样就有一个惯例，如果某个变量只想在类或对象中使用，就应该以单下划线前缀。而其他的名称都将作为公共的，可以被其他类/对象使用。记住这只是一个惯例，并不是 Python 所要求的（与双下划线前缀不同）。 同样，注意 del__ 方法与 destructor 的概念类似。

: n# @( a) u5 @/ h7 Q0 d6 r继承
0 A- y/ C0 e' L! E面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过 继承 机制。继承完全可以理解成类之间的 类型和子类型 关系。
. p. V7 e6 @- E# G
假设你想要写一个程序来记录学校之中的教师和学生情况。他们有一些共同属性，比如姓名、年龄和地址。他们也有专有的属性，比如教师的薪水、课程和假期，学生的成绩和学费。

3 z% |2 j2 D% l7 t1 V你可以为教师和学生建立两个独立的类来处理它们，但是这样做的话，如果要增加一个新的共有属性，就意味着要在这两个独立的类中都增加这个属性。这很快就会显得不实用。

一个比较好的方法是创建一个共同的类称为 SchoolMember 然后让教师和学生的类 继承 这个共同的类。即它们都是这个类型（类）的子类型，然后我们再为这些子类型添加专有的属性。
# x! v" ^8 b- P5 p" U3 B' l7 X  E
$ m$ U* g: X1 i使用这种方法有很多优点。如果我们增加/改变了 SchoolMember 中的任何功能，它会自动地反映到子类型之中。例如，你要为教师和学生都增加一个新的身份证域，那么你只需简单地把它加到 SchoolMember 类中。然而，在一个子类型之中做的改动不会影响到别的子类型。另外一个优点是你可以把教师和学生对象都作为 SchoolMember 对象来使用，这在某些场合特别有用，比如统计学校成员的人数。一个子类型在任何需要父类型的场合可以被替换成父类型，即对象可以被视作是父类的实例，这种现象被称为多态现象。

+ [1 U6 ]; Q7 h另外，我们会发现在 重用 父类的代码的时候，我们无需在不同的类中重复它。而如果我们使用独立的类的话，我们就不得不这么做了。
- ~  O3 p# P7 v. B
在上述的场合中，SchoolMember 类被称为 基本类 或 超类 。而 Teacher 和 Student 类被称为 导出类 或 子类 。

现在，我们将学习一个例子程序。

使用继承
例 11.5 使用继承

1. #!/usr/bin/python
   1 N% U! X4 U  G1 v$ L
2.     # Filename: inherit.py
   0 E0 A( E. g. a) ?0 W& g( H: Z
3. 
   $ {7 m: t0 {) f2 a' D
4.     class SchoolMember:
   ; N! u' Q' d) s- h8 o2 E
5.         '''Represents any school member.'''
   0 V/ Y+ Y$ |; D: w& ^
6.         def __init__(self, name, age):
   $ o( k, V, ]6 o5 _# {
7.             self.name = name
   
8.             self.age = age
   
9.             print '(Initialized SchoolMember: %s)' % self.name
   ; E. u: i2 Z) P, @& T
10. 
    ! |  a& o5 h+ t  @
11.         def tell(self):
    ! Q1 ~" X8 h2 r! w+ O
12.             '''Tell my details.'''
    ( u1 P7 {/ j1 p
13.             print 'Name:"%s" Age:"%s"' % (self.name, self.age),
    # l- Q& g" t5 N) Q/ b& P, K
14. 
    
15.     class Teacher(SchoolMember):
    " S. N$ g! A% N, P7 q
16.         '''Represents a teacher.'''
    * ~2 E9 [8 X8 C
17.         def __init__(self, name, age, salary):
    
18.             SchoolMember.__init__(self, name, age)
    
19.             self.salary = salary
    
20.             print '(Initialized Teacher: %s)' % self.name
    * ?( g. B% z2 M
21. 
    # ^. W$ M/ p: k( j
22.         def tell(self):
    $ Y+ Q5 l( r* q/ ~% b- \
23.             SchoolMember.tell(self)
    ' `# d6 s" e/ B, v- d0 H- g
24.             print 'Salary: "%d"' % self.salary
    " t8 G# _8 c* B3 T1 R; ?
25. 
    
26.     class Student(SchoolMember):
    
27.         '''Represents a student.'''
    
28.         def __init__(self, name, age, marks):
    6 X/ q; z3 x1 }, I  b4 Y% }
29.             SchoolMember.__init__(self, name, age)
    
30.             self.marks = marks
    
31.             print '(Initialized Student: %s)' % self.name
    
32. 
    
33.         def tell(self):
    9 P1 Y8 f% M. G) x8 p! M: z4 r
34.             SchoolMember.tell(self)
    
35.             print 'Marks: "%d"' % self.marks
    6 L. T0 e- E; S: u7 @
36. 
    
37.     t = Teacher('Mrs. Shrividya', 40, 30000)
    
38.     s = Student('Swaroop', 22, 75)
    
39. 
    ; a) \/ \! t* \  }+ v
40.     print # prints a blank line
    
41. 
    
42.     members = [t, s]
    
43.     for member in members:
    : d$ H7 f  g$ l+ ?, D0 W
44.         member.tell() # works for both Teachers and Students

复制代码

输出
: ?* m  Z6 i7 m9 Y7 @4 ?

1. <span style="background-color: rgb(255, 255, 255);">$</span> python inherit.py
   
2.     (Initialized SchoolMember: Mrs. Shrividya)
   
3.     (Initialized Teacher: Mrs. Shrividya)
   : }( Y3 [% X' J% }/ o& M# W% w
4.     (Initialized SchoolMember: Swaroop)
   $ a3 a4 Q+ a- v. c  @8 }+ K- I
5.     (Initialized Student: Swaroop)
   
6. 
   
7.     Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
   
8.     Name:"Swaroop" Age:"22" Marks: "75"

复制代码

它如何工作
4 x. _& Q+ z. s
+ N2 [! U/ ?9 U6 \% s为了使用继承，我们把基本类的名称作为一个元组跟在定义类时的类名称之后。然后，我们注意到基本类的 init 方法专门使用 self 变量调用，这样我们就可以初始化对象的基本类部分。这一点十分重要——Python 不会自动调用基本类的 constructor，你得亲自专门调用它。
9 z8 d0 t. A; y4 X& d5 H  ]
- U  L* |1 ~) L; L6 R% [我们还观察到我们在方法调用之前加上类名称前缀，然后把 self 变量及其他参数传递给它。

. R1 t  v, F7 \0 j' V注意，在我们使用 SchoolMember 类的 tell 方法的时候，我们把 Teacher 和 Student 的实例仅仅作为 SchoolMember 的实例。
3 x/ D; I. p5 V5 r; A) J1 u3 {* T
另外，在这个例子中，我们调用了子类型的 tell 方法，而不是 SchoolMember 类的 tell 方法。可以这样来理解，Python 总是首先查找对应类型的方法，在这个例子中就是如此。如果它不能在导出类中找到对应的方法，它才开始到基本类中逐个查找。基本类是在类定义的时候，在元组之中指明的。
. x( a& o: p2 k8 B% @! h, [
! O: A9 X; t+ F) O; I7 J一个术语的注释——如果在继承元组中列了一个以上的类，那么它就被称作 多重继承 。
% b5 H4 B. Z. x' e
# Q* \- F& e8 X/ o& F; L概括
我们已经研究了类和对象的多个内容以及与它们相关的多个术语。通过本章，你已经了解了面向对象的编程的优点和缺陷。Python 是一个高度面向对象的语言，理解这些概念会在将来有助于你进一步深入学习 Python。

接下来，我们将学习如何处理输入/输出已经如何用 Python 访问文件。
* ]1 \& r, P% i
! i- v9 w# ]% I+ S0 d. f

有空一起交流一下

无论是不是沙发都得回复下

高手云集 果断围观

顶起顶起顶起
& }1 X& V7 V6 l( V& C, K

一起学习呀！

看起来不错

支持支持再支持

啊啊啊啊啊啊啊啊啊啊啊

OMG！介是啥东东！！！
8 H$ o: E3 {" r