python 面向对象 继承 派生 组合

具体参考博客：http://www.cnblogs.com/linhaifeng/articles/6182264.html#_label12

一.面向对象

面向对象：对象与对象之间的相互交互，不可预测最终的结果

　　对象是特征 <变量> 与技能 <函数> 的结合体。

　　类是一系列对象的共同特征与技能的结合体。

　　程序中，先有类再有对象，类是抽象的<模板>，而对象是真实存在的。

class Teacher(object):       #class 定义类，类的首字母大写
    school='偶的博爱'             #变量 <数据属性>
    def __init__(self,name,age):   #初始化，以便对象的各自属性
        self.name=name
        self.age=age
    def teach(self):                      #函数属性
        print('is teaching ')
            
p1=Teacher('egon',18)             #对象

　　Tips：__init__方法只能干初始化的活，可以加任何可执行的代码，但不能有返回值。　

　　　　　__dict__查看名称空间<名称空间存放着名字与值的绑定关系>

　　　　在python3中类型就是类，比如我们常说的列表/元组/集合/字典 都是类。

　　　　创建类的过程，如果不添加父类，则默认基类(object).

　1.1实例化

　　实例化产生对象.比如p1=Teacher()，Teacher() 就是实例化,也就是说创建实例是通过类名+()实现的，而p1是实例化对象.

类的作用:

　　1.实例化对象

　　　　p1=Teacher()

　　2.类的属性引用：数据属性与函数属性

　　　　Teacher.school   #数据属性

　　　　Teacher.teach  #函数属性

　　　　Teacher.teach()  #类调用函数属性的时候，必须传值

对象的作用：

　　1.属性引用

　　　　p1.school       #数据属性

　　　　p1.teach()      #函数属性，对象在引用函数属性的时候会默认传值，将对象p1传值到self中。

　　对象修改不了类的属性，我们看到的修改其实只是在对象里面创建了一个名称空间，如果你再在类里面创建新的对象2，对象2调用该属性会以类的属性为准。

二：继承与派生

　　继承是类与类之间的关系，一种什么“是”什么的关系.子类继承父类，会拥有父类的所有属性。

class People:
    pass

class Animal:
    pass

class Student(People,Animal): #people称为基类或父类
    pass



print(Student.__bases__)
print(People.__bases__)
print(Animal.__bases__)
#在python3中，所有类默认继承object，
#但凡是继承了object类的子类，以及该子类的子类，都称为新式类（在python3中所有的类都是新式类）
#没有继承object类的子类成为经典类（在python2中，没有继承object的类，以及它的子类，都是经典类）

　　继承举例：

class People:
    def __init__(self, name, age)
        self.name = name
        self.age = age
    def walk(self):
        print('%s is walking' %self.name)


class Teacher(People):     #在括号里里面加父类，表示继承父类
    pass                            #此时Teacher类具备People的所有属性

　　派生：子类在继承父类的所有属性后，自身又具备一些特有的属性，我们在__init__()后面为其添加新的属性，称为派生　　

　　派生举例：

class People:
    def __init__(self, name, age)
        self.name = name
        self.age = age
    def walk(self):
        print('%s is walking' %self.name)

class Student(People):          #调用的父类为People
    def __init__(self, name, age,sex,group):
        People.__init__(self, name, age, sex)  
        self.group=group       #group是学生特有的属性，即为派生
    def study(self):
            print('%s is studying' %self.name)

三：组合

　　　#组合：是一种什么 “有” 什么的关系，也是为了减少重复代码。  区别于继承，它并不是继承其所有属性。而是我应该有什么属性，避免重复代码，我去引用这个组合。

class People:                       #人类
    def __init__(self, name, age, year, mon, day):
        self.name = name
        self.age = age
        self.birth = Date(year, mon, day)   ------>人类并不是时间，而只是人有生日这个属性，所有去引用时间类，目的是为了减少代码冗余。而我们创建的老师类，学生类，则是继承，因为老师 学生属于人类.

    def walk(self):
        print('%s is walking' % self.name)

class Date:                                    #时间类
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day

    def tell_birth(self):
        print('出生于<%s>年 <%s>月 <%s>日' % (self.year,self.mon,self.day))

　　Tips：1.  . 后面接的都是属性

　　　　　2..___bases__    查看其父类，默认为object类。

　　　　　　凡是集成了object类的子类，以及该子类的子类，都是新式类<在python3中所有的类都是新式类<默认>>

　　　　　　没有object的类的子类都是经典类，(在python2中，没有继承object的类，以及它的子类都是经典类)

四：接口

　　python中压根没有interface关键词来定义一个接口,但可以定义Interface来模仿接口的概念。

父类要限制：

　　#1：子类必须要有父类的方法
　　#2：子类实现的方法必须跟父类的方法的名字一样

class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
    def read(self): #定接口函数read
        pass

    def write(self): #定义接口函数write
        pass


class Txt(Interface): #文本，具体实现read和write
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

抽象类：
　　　python中抽象类需要借助模块来实现，抽象类是一种特殊的类，它的特殊之处是只能被继承不能别实例化.

import abc                         ##引入abc模块
class File(metaclass=abc.ABCMeta):
    @abc.abstractmethod        ##
    def read(self):
        pass

    @abc.abstractmethod
    def write(self):
        pass


class Txt(File): #文本，具体实现read和write
    def read(self):
        pass
    def write(self):
        pass
t=Txt()