面向对象OOP

面向对象OOP

标签（空格分隔）： 未分类

---

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

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

面向对象：

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

面向对象的抽象程度又比函数要高，因为一个Class既包含数据，又包含操作数据的方法。

类与实例

类是抽象的模板，实例是一个个具体的由类创造出来的‘对象’。
例如Student类：

class Student(object):
    pass

class后面是类名Student，常用大写字母开头，然后是(object)，表示继承自(object)。所有类都会继承自object。
之后就可以用Student类创建实例。

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

>>> a = Student('a', 87)

实例在初始化是会先调用__init__方法（类似构造器），其中第一个参数固定为self，之后为构造实例时需要传入的参数。实例的self在构造时就指向了其本身。

数据封装

在上面的Student类中，每个实例就拥有各自的name和score属性这些数据。我们可以通过函数来访问这些数据，比如打印一个学生的成绩：

def print_std(std)；
    print('%s: %s' % (std.name, std.score))

>>> print_std(a)
a: 87

但是，既然Student类中本身就拥有这些属性，那么就不需要外部函数对其进行访问，就可以定义Student类内部方法，这样就讲类中的属性封装起来。

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
         print('%s: %s' % (self.name, self.score))

这样只需要调用类中的方法就可以按规则打印内容：

>>>a.print_score()
a: 87

封装还可以给类中增加新的方法，从外部可以调用方法的到需要的内容，而且不用考虑类的内部是如何实现的。

注意：
和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同:

>>> bart = Student('Bart Simpson', 59)
>>> lisa = Student('Lisa Simpson', 87)
>>> bart.age = 8
>>> bart.age
8
>>> lisa.age
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'

访问限制

在class内部，可以有属性和方法。
上面的Student类中的name和score属性仍然可以在外部被修改，这就造成了困扰。
如果要让内部属性不被外部访问，可以再属性前加双下划线__，python中就可以使属性变为私有变量(private)，只有class内部可以访问。即有:

class Student(object):
    def __init__(self, name, score)：
        self.__name = name
        self.__score = score
    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

这样从外部使用实例.name和实例.__name都不能调取类内部的name属性。而print_score方法可以成功打印。

如果外部需要对这两个属性进行获取或者修改，就需要在类中增加方法进行处理，比如

class ...
...
    def set_score(self, score):
        self.__score = score

注意：Python中，类似__xxx__的变量名，以__开头并以__结尾的是特殊变量，可以在外部被访问，不是private变量。所以不能使用这种变量名作为私有变量。

另：如果以单下划线_开头的变量，在外部也可以访问，但是按照约定（不是必须）这样的变量也视为private尽管可以修改。

继承和多态

从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。

比如

class Animal(object):
    def run(self):
        print('running......')

class Pig(Animal):
    pass
class Cat(Animal)；
    pass

>>> pig = Pig()
>>> pig.run()
'running......'

虽然classPig()没有做任何事，但是仍然继承了父类Animal()的方法。
在子类中，仍然可以增加自己的方法和属性。例如：

class Dog(Animal):
    def run(self):
        print('dog is running...')

当子类和父类都有run()方法时，子类的方法覆盖了父类的方法。这也就是多态。
多态：

当我们定义一个class的时候，实际上就定义了一种数据类型，这种数据类型和str，list等没什么区别。

a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型

多态的好处就是，当我们需要传入Dog、Cat、Tortoise……时，我们只需要接收Animal类型就可以了，因为Dog、Cat、Tortoise……都是Animal类型，然后，按照Animal类型进行操作即可。由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思：

对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：

对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

def run_twice(animal)；
    animal.run()
    animal.run()

静态语言 vs 动态语言

对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。

对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证run_twice(animal)传入的对象有一个run()方法就可以了：
问题：动态语言中的“鸭子类型”，不必向JAVA一样如果传入Animal类型就必须传入该类型的对象，或者子类的对象，否则就无法调用。Python中只要传入有run()方法的类就可以调用。

获取对象信息

type()

可以查看实例类型。
使用isinstance(h, Dog)，如果h是Dog类的实例则返回True，否则返回False。
type()对类的实例的判断不如isinstance()。

dir()

如果要获得一个对象的所有属性和方法，可以使用dir()，可以返回一个包含字符串的list。

实例属性和类属性

class Student(object):
    count = 0
    def __init__(self, name):
        self.name = name
        Student.count +=1

>>>a = Student('a')
>>>a.name
a
>>>a.count
1
>>>Student.count
1
>>>b = Student('b')
>>>Student.count
2
>>>b.count
2

Student.count就是类的属性，a.count 是实例的属性。
a.name也是实例的属性，但是name属性不是类的属性。
Student.count可以随着__init__()方法在每次生成实例的时候调用一次count +1。类的属性随之改变。