前言

任何一个的编程语言，它的面向对象的知识都是相同的，只是语法格式不同而已

一、面向过程 VS 面向对象

面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

1. 导入各种外部库
2. 设计各种全局变量
3. 写一个函数完成某个功能
4. 写一个函数完成某个功能
5. 写一个函数完成某个功能
6. 写一个函数完成某个功能
7. 写一个函数完成某个功能
8. ......
9. 写一个main函数作为程序入口

面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的属性和方法），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙互相缠斗着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。

1. 导入各种外部库
2. 设计各种全局变量
3. 决定你要的类
4. 给每个类提供完整的一组操作
5. 明确地使用继承来表现不同类之间的共同点
6. 根据需要，决定是否写一个main函数作为程序入口

秃头小贴士：在python 中面向对象的程序设计并不是全部。

面向对象编程可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

了解一些名词：类、对象、实例、实例化

类：具有相同特征的一类事物(人、狗、老虎)

对象／实例：具体的某一个事物（隔壁阿花、楼下旺财）

实例化：类——>对象的过程

二、干货

类

基本用法

面向对象是通过定义class类来定义，也就说面向对象编程就是通过使用class类，在class类中有封装，继承的功能，并且还可以构造要传入的参数，方便控制。

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用。

如果你学过Java的话，就可以直接理解这个为 init() 的特殊方法是与Java的构造方法是同一个意思

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self，self 代表的是类的实例，代表当前对象的地址。

一些专业术语概念，既然有面向对象编程这个高大上的定义了，自然要搭配一些高大上的概念。

类(Class): 用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。其中的对象被称作类的实例。

实例：也称对象。通过类定义的初始化方法，赋予具体的值，成为一个”有血有肉的实体”。

实例化：创建类的实例的过程或操作。

实例变量：定义在实例中的变量，只作用于当前实例。

类变量：类变量是所有实例公有的变量。类变量定义在类中，但在方法体之外。

数据成员：类变量、实例变量、方法、类方法、静态方法和属性等的统称。

方法：类中定义的函数。

静态方法：不需要实例化就可以由类执行的方法

类方法：类方法是将类本身作为对象进行操作的方法。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对父类的方法进行改写，这个过程也称override。

封装：将内部实现包裹起来，对外透明，提供api接口进行调用的机制

继承：即一个派生类（derived class）继承父类（base class）的变量和方法。

多态：根据对象类型的不同以不同的方式进行处理。

类方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

继承

 #类定义
 class people:
     #定义基本属性
     name = ''
     age = 0
     #定义私有属性,私有属性在类外部无法直接进行访问
     __weight = 0
     #定义构造方法
     def __init__(self,n,a,w):
         self.name = n
         self.age = a
         self.__weight = w
     def speak(self):
         print("%s 说: 我 %d 岁。" %(self.name,self.age))
  
 #单继承示例
 class student(people):
     grade = ''
     def __init__(self,n,a,w,g):
         #调用父类的构函
         people.__init__(self,n,a,w)
         self.grade = g
     #覆写父类的方法
     def speak(self):
         print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
  
 #另一个类，多重继承之前的准备
 class speaker():
     topic = ''
     name = ''
     def __init__(self,n,t):
         self.name = n
         self.topic = t
     def speak(self):
         print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
  
 #多重继承
 class sample(speaker,student):
     a =''
     def __init__(self,n,a,w,g,t):
         student.__init__(self,n,a,w,g)
         speaker.__init__(self,n,t)
  
 test = sample("Tim",25,80,4,"Python")
 test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法

方法重写

 class Parent:        # 定义父类
  def myMethod(self):
       print ('调用父类方法')
       
 class Child(Parent): # 定义子类
 
 	def myMethod(self):
 	      print ('调用子类方法')
 	      
 c = Child()          # 子类实例
 c.myMethod()         # 子类调用重写方法
 super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

类属性与方法

 #类的私有属性实例如下：
 
 class JustCounter:
     __secretCount = 0  # 私有变量
     publicCount = 0    # 公开变量
  
     def count(self):
         self.__secretCount += 1
         self.publicCount += 1
         print (self.__secretCount)
  
 counter = JustCounter()
 counter.count()
 counter.count()
 print (counter.publicCount)
 print (counter.__secretCount)  # 报错，实例不能访问私有变量

 #类的私有方法实例如下：
 
 class Site:
     def __init__(self, name, url):
         self.name = name       # public
         self.__url = url   # private
  
     def who(self):
         print('name  : ', self.name)
         print('url : ', self.__url)
  
     def __foo(self):          # 私有方法
         print('这是私有方法')
  
     def foo(self):            # 公共方法
         print('这是公共方法')
         self.__foo()
  
 x = Site('菜鸟教程', 'www.runoob.com')
 x.who()        # 正常输出
 x.foo()        # 正常输出
 x.__foo()      # 报错