Python学习之路--面向对象

1.面向对象概述

  面向过程：根据业务逻辑从上到下写垒代码
  函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
  面向对象：对函数进行分类和封装，让开发“更快更好更强...”
  面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。

2.面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）

（1）面向对象编程主要有两个主题就是类和实例。

类与实例相互关联着：类是对象的定义，而实例是’真正的实物‘，它存放了类中所定义的对象的具体信息。

（2）创建类和对象

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

 

 1 #创建类
 2 class Foo: #class关键字，表示要创建类;Foo 类名称
 3     def __init__(self,name):
 4         self.name=name
 5     #创建类中的函数
 6     def Bar(self):#self为特殊函数，必填
 7         #do smoethong
 8 #根据类Foo创建对象obj
 9 obj=Foo()
10 obj.Bar() #执行Bar方法

View Code

 

例子： 
1 class Role(object):#object顶级位，如果是继承类则object改为被继承类名称
 2     ac=None #存在类的属性，公共的
 3     members = 0 #类变量，类属性
 4     def __init__(self,name,role,weapon,life_value):#初始化函数
 5         #self 谁调用这个类谁就是这个self，调用这个类的是实例，实例本身
 6         self.name = name
 7         self.role = role #实例属性，实例变量，成员变量
 8         self.weapon = weapon
 9         self.life_val = life_value
10         Role.members += 1
11         self.buy_weapon()
12     def buy_weapon(self,weapon):#类的方法
13         print('%s is buy [%s]'%(self.name,weapon))
14         self.weapon = weapon
15 #role 的实例
16 #把一个抽象的类变成一个具体的对象的过程，叫实例化
17 p1=Role("Sanjiang",'Police','B10',90)
18 #Role(p1,"Sanjiang",'Police','B10',90)相当于上面执行的步骤
19 t1=Role("ChunYun",'Terrorist','B11',100)
20 
21 p1.buy_weapon("AK47") #Role.buy_weapon(p1,'AK47')
22 t1.buy_weapon("B51")  #调用类中的方法
23 
24 Role.ac = 'Japan Brand'
25 print(Role.weapon) #此处会报错，
26 p1.ac = "China Brand"
27 t1.ac = "US Brand"
28 print('p1:',p1.weapon,p1.ac)
29 print('t2:',t2.ac)#先访问类变量，如果赋值则不访问类变量，直接将赋值写入内存

3.面向对象的三大特效

面向对象的三大特性是指：封装、继承和多态。

（1）封装

    封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

    所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

   第一步：将内容封装到某处

 1 #创建类
 2 class Foo:
 3     def __init__(self,name,age):#称为构造方法，根据类创建对象时自动执行
 4         self.name = name
 5         self.age =age
 6 #根据类Foo创建对象
 7 #自动执行Foo类的__inint__方法
 8 obj1=Foo('liu',22)#将liu和22分别封装到obj1 self的name和age属性里
 9 
10 #根据类Foo创建对象
11 #自动执行Foo类的__inint__方法
12 obj2=Foo('qq',23)

View Code

 self 是一个形式参数，当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1

                              当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性。

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

• 通过对象直接调用
• 通过self间接调用

  1）通过对象直接调用被封装的内容

  上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

1 class Foo:
2  
3     def __init__(self, name, age):
4         self.name = name
5         self.age = age
6  
7 obj1 = Foo('liu', 22)
8 print obj1.name    # 直接调用obj1对象的name属性
9 print obj1.age     # 直接调用obj1对象的age属性

View Code

 2)通过self间接调用被封装的内容

  执行类中的方法时，需要通过self间接调用被封装的内容

 1 class Foo: 
 2     def __init__(self, name, age):
 3         self.name = name
 4         self.age = age
 5     def detail(self):
 6         print self.name
 7         print self.age
 8   
 9 obj1 = Foo('liu', 22)
10 obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 liu ；self.age 是 22
11   
12 obj2 = Foo('qq', 23)
13 obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 qq ； self.age 是23

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

 （2）继承

   继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容，继承的过程，就是从一般到特殊的过程。

   通过继承创建的新类称为“子类”或“派生类”。

   被继承的类称为“基类”、“父类”或“超类”。

  对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

1 class  父类:
2    def 父类中的方法(self):
3        pass
4 
5 class 子类(父类):#子类继承父类，子类拥有父类的所有方法
6     pass
7 zi = 子类() #创建子类对象
8 zi.父类中的方法() #执行从父类中继承的方法