Python-06-面向对象（基础篇）

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。

而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。

面向对象编程和函数编程有什么区别？
函数编程与OOP的主要区别就是OOP可以使程序更加容易扩展和易更改，专业术语叫可读性好、易扩展。

一、封装

# 创建一个类：Person
class Person(object):   # (object)是新式类的写法，经典类不用写这个。
    def __init__(self, name, age):   # 类的构造方法，实例化时自动执行
        self.name = name
        self.age = age
        
    def show_info(self):
        print("Name:%s,Age:%s" % (self.name,self,age))
        
# 实例化一个Person类的对象，自动执行类中的__init__方法
# 将Jack和18封装到person1的name和age属性中
person1 = Person("Jack", 18)

# 直接调用Jack的封装（person1对象），会输出Jack的name（person1对象的name属性）
print(person1.name)    

# 通过self间接调用被封装的内容：Python默认会将person1传给self参数，即：person1.show_info(person1)，所以，此时方法内部的self = person1，即：self.name是Jack , self.age是18 
person1.show_info()    

# 所以，内容其实被封装到了对象 person1 中，每个对象中都有 name 和 age 属性。
# 注：self是一个形式参数，当执行person1 = Person("Jack", 18)时，self等于person1.

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

---

二、继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

对于面向对象来说，继承其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法,它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

• 通过继承创建的新类称为“子类”或“派生类”。
• 被继承的类称为“基类”、“父类”或“超类”。
• 继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

class People(object):   # 创建一个类：People
    def __init__(self,name,age):    # 父类的构造方法，实例化时自动执行。
        self.name = name
        self.age = age

    def show_info(self):   # 父类的方法
        print("%s is %s years old." % (self.name,self.age))

class Teacher(People):   # 创建一个类：Teacher，继承People类。
    def __init__(self,name,age,course):
        # People.__init__(self,name,age)   # 不推荐这么写
        super(Teacher,self).__init__(name,age)   # 推荐写法，在子类的构造方法里只出现子类的类名
        self.course = course

    def show_course(self):   # 定义一个方法
        print("Teacher:%s is teaching %s" % (self.name,self.course))   # 继承了父类的name属性

Jack = Teacher("Jack",33,"Python")   # 实例化一个老师：Jack
Jack.show_info()   # 调用父类的方法 output>> Jack is 33 years old.
Jack.show_course()   # 调用本类的方法 output>> Teacher:Jack is teaching Python

多继承

class D(object):
    def bar(self):
        print ('D.bar')

class C(D):
    def bar(self):
        print ('C.bar')

class B(D):
    def bar(self):
        print ('B.bar')

class A(B, C):
    def bar(self):
        print ('A.bar')

a = A()
a.bar()

# 执行a.bar方法时，首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
# 查找顺序：A --> B --> C --> D
# 这种查找顺序被称为：广度优先。

• 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
• 新式类包含了很多新的功能，推荐使用新式类。

Python3.x中多继承时不管是经典类还是新式类都是广度优先。

Python2.x中多继承时经典类（深度优先），新式类（广度优先）：

深度优先：（A > B > D > C）首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中没有，则继续去C类中找，如果还是未找到，则报错。

广度优先：（A > B > C > D）首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中没有，则继续去D类中找，如果还是未找到，则报错。

注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

三、多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的：接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。

通过Python模拟的多态：

class Animal:

    def __init__(self, name):    # Constructor of the class
        self.name = name
        
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Dog('Lassie')]

for animal in animals:
    print animal.name + ': ' + animal.talk()

---

总结

1. 面向对象（Object Oriented Programming，OOP）是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用。
2. 类 是一个模板，模板中包装了多个“函数”供使用（可以将多函数中公用的变量封装到对象中）。
3. 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数。
4. 面向对象三大特性：封装、继承和多态