精心总结的python面向对象

一、面向对象的基本概念

• 类：描述具有相同属性和方法的对象集合。它定义了该集合中每个对象所共有的属性和方法。对象是类实例。
• 类变量：类变量是整个实例化的对象中是公共的。类变量是定义在类中，且在函数体外的。类变量不做实例变量使用。
• 局部变量：定义在方法中的变量，只能被类的当前实例使用。
• 数据成员：类变量或者实例变量，用于处理类或实例对象的相关数据。
• 方法重写：子类继承的父类的方法，如果不能满足子类的需求则需要进行方法的重写，覆盖父类的方法，这个过程叫override
• 继承：一个派生类继承基类的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中创建的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

二、Python的私有方法、私有属性的理解

• _xxx ：保护变量，只有类的实例和子类实例才可以访问这些变量，需要类提供的接口才可方位
• __xxx ：类中的私有变量/私有方法，意思是：只有类对象自己才能进行访问，连子类的对象也不能访问。

class Dog:
    # 私有方法，只有类对象自己才可进行方位
    def __sit_down(self):
        print('坐下了')
        
    def sit_down(self,host_name):
        if host_name == '主人':
            self.__sit_down()  # 只能在这里使用


if __name__ == '__main__':
    w = Dog()
    w.sit_down('主人')
    w.__sit_down()   # 这里调用会报错

• __xxx()__：表示Python类中的特殊方法标识，其中内置方法表示一个类被创建之后，其自然就包含这些方法。查看方法：

'_Dog__sit_down', 
'__class__',
'__delattr__',
'__dict__', 
'__dir__', 
'__doc__', 
'__eq__', 
'__format__', 
'__ge__', 
'__getattribute__', 
'__gt__', 
'__hash__', 
'__init__', 
'__init_subclass__', 
'__le__', '__lt__', 
'__module__', 
'__ne__', 
'__new__', 
'__reduce__', 
'__reduce_ex__', 
'__repr__', 
'__setattr__', 
'__sizeof__', 
'__str__', 
'__subclasshook__', 
'__weakref__', 
'sit_down'

---

归纳总结如下：

• 类的私有属性，不能通过类的实例直接访问，但是可以类的方法访问；
• 类的私有方法，不能通过对象直接访问，但是能通过类的方法方位；
• 类的私有属性、私有方法，不会被子类继承，也不能被访问；
• 一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用；
• 可以通过调用继承的父类的共有方法，间接的访问父类的私有方法、属性；

三、类的继承

1.类的简单继承：直接继承父类所有方法和属性，不做任何改动。

class Animal:    
    def __init__(self,name,sex,type):
        self.name = name
        self.sex = sex
        self.type = type
    
    def eat(self):
        print("{} eat".format(self.name))

    def run(self):
        print("{} run".format(self.name))

class Cat(Animal):
    pass

if __name__ == '__main__':
    tom = Cat('tom','1','猫')
    tom.run()
    tom.eat()

2.类继承中的重写：重写是对父类中的某些方法进行重新编写，因为有些继承过来的方法，功能不能满足要求。

class Cat(Animal):
    def eat(self):
        print('{} eat fish'.format(self.name))

3.类继承中的拓展：子类除了从父类中继承得到的方法之外，一定还有自己的特有属性和方法，因此要对子类进行拓展，增加新的属性和方法。

class Cat(Animal):
    def eat(self):
        print('{} eat fish'.format(self.name))

    # 子类方法的拓展
    def method(self):
        print('{} can catch mouse'.format(self.name))

小结：通过类的重写和拓展，有如下操作:

• 对父类方法进行重写之后，子类调用的是子类重写的方法；
• 子类可以直接调用父类中的属性值；
• 子类可以对父类进行一些拓展，丰富自己的方法数量；
• 子类中的方法可以调用父类中的方法和属性，直接通过子类的实例进行调用即可。在子类中，通过self可调用，在类外可通过子类的实例进行调用。
• 父类不能调用子类的方法和属性；

4.类的多重继承

class A:
    def add(self,a,b):
        self.a = a
        self.b = b
        print('类A中的加法:',self.a + self.b)

class B:
    def add(self,a,b):
        self.a = a
        self.b = b
        print('类B中的加法:',self.a + self.b)

    def add(self,a,b):
        self.a = a
        self.b = b
        print('类B中的减法:',self.a - self.b)

class C(A,B):
    pass 

class D(B,A):
    pass

当类存在多继承时，一般是按照深度优先进行遍历的。

5.类的超继承：即要拥有父类的特征，又要有子类的新特征。

class Animal:
    def __init__(self,name,sex,type):
        self.name = name
        self.sex = sex
        self.type = type

    def eat(self):
        print("{} eat".format(self.name))

    def run(self):
        print("{} run".format(self.name))

# 子类中进行超继承
class Dog(Animal):
    def __init__(self):
        super(Dog, self).__init__('jerry','dog','中华田园犬') # 超继承
        print('this is a dog')

    def suck(self,food):
        super(Dog,self).eat()    # 超继承
        print('{} eat {}'.format(self.name,food))

if __name__ == '__main__':
    dog_a = Dog()
    dog_a.suck('XXX')

super类是子类的类名，顺着子类的类名找到对应的父类，并调用父类的方法，实现超继承。

<完>