面向对象进阶之类和类之间的关系

                                                                   Python面向对象的特征

一、继承

 在现实角度：分析阶段 对象------->抽象---------->出类

 

在程序的角度: OOP阶段 先写出父类-------->派生类继承父类------------>实例化出对象；正好与分析阶段相反；

 

得出结论：继承是抽象的结果;

现实角度：对象 ----->抽象 ----->类------> 抽象-------> 父类 ----->程序角度：————>定义父类----->派生类继承父类-------->实例化出对象

继承的作用：

1、解决代码的重用性

二、派生：新类可以派生出新的特征 和技能

class course:                                 #课程类：老师类和学生类 都有课程 所以称为组合关系
    def __init__(self,name,price,time):
        self.name=name
        self.price=price
        self.time=time

class Person:                                #人类：老师和学生类 的父类  ，他们之间的关系称为 继承
    def __init__(self,name,age,course):
        self.name=name
        self.age=age
        self.course=course

class Teacher(Person):           #老师类人类的派生类：派生了level 职业等级，也继承了父类 人类的 姓名，年龄，课程 属性
    def __init__(self,name,age,course,level):
       Person.__init__(self,name,age,course )
       self.level=level

    # def __init__(self,name,age,course):   #继承了父类 减少了代码
    #     self.name=name
    #     self.age=age
    #     self.course=course

class Students():             #学生类：派生了ID属性 学生ID，同时也继承了父类人类的 姓名，年龄，课程 属性
    def __init__(self,name,age,course,id):
        Person.__init__(self,name,age,course)
        self.id=id

         # self.name = name

                                         #继承了父类 减少了代码

         #self.age = age
         #self.course=course

 #self.age = age #self.course=course  python_obj=course('python',15800,'7m') t=Teacher('egon',34,python_obj,'高级讲师') s=Students('张根',24,python_obj,8668) print('''%s正在学习%s课程 价格：%s 周期：%s 他的学生ID：%s %s正在教%s课程 价格：%s 周期：%s 他的教师职称：%s''' %(s.name,s.course.name,s.course.price,s.course.time,s.id,t.name,t.course.name,t.course.price,t.course.time,t.level))

 三、组合：和继承一样 都是为了 解决代码重用性；

    A类  B类 之间的关系为： 是 ----------》使用继承      例：梁山108条好汉都英雄

   A类  B类 之间的关系为： 有 -------------》使用组合   例：梁山108条好汉都有自己的 武器

四：

1、接口和归一化设计===python中的抽象类

 接口：把一些程序应该有的功能写到一个结合体里（父类），自己不实现，让其他子类去实现；

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
#一切皆文件
import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')

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

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

 2、作用：给继承自己的子类 规范功能，使不同子类的 调用方式统一；

不同的子类都 去实现父类定义的功能，这样不同子类实例化出来的对象 的调用方法就统一了；

五：多态和多态性：很多人喜欢将多态和多态性混为一谈，然后百思不得其解，其实只要分开看，就会很明朗；

1、多态：站在程序中类定义的角度：  指的是同一类事物的多种形态，（一个父类，一堆具有父类同性的子类继承他 就是多态的体现）；

 动物有多种形态：人，狗，猪

  

2、多态性：站在类实例化后，对象使用类的角度：人、猪、狗对象继承自一个动物类，他们继承了父类 相同的 走、说的方法；但是不同对象 调用相同的方法 就会有不同效果；

                                      人对象调用走方法：人在走

　　　　　　　　　　　　　  狗对象调用走方法：狗在走

                                      猪对象调用走方法：猪在走

 

class linux_all:
    def __init__(self,name):
        self.name=name
    def read(self):
        print("正在 读取 %s 文件"%self.name)
    def write(self):
        print('正在 写入 %s 文件'%self.name)

class txt(linux_all):               #子类txt 继承了 父类Linux_all的方法： 读、写
    def __init__(self,name):
        super().__init__(name)
        super().read
        super().write

class sata(linux_all):                #子类SATA继承了 父类Linux_all的方法： 读、写
    def __init__(self,name):      
        super().__init__(name)
        super().read
        super().write
class Process(linux_all):             #子类process继承了 父类Linux_all的方法： 读、写         
    def __init__(self,name):         
        super().__init__(name)         #在程序定义角度： 所有 子类 都继承了 父类相同的 方法
        super().read                  #----------------------------------------------------------------------------------------------------
        super().write

---------------------------------------------------------------------------------------------------------------------------------------

                                         #程序调用角度：不同对象调用 继承自 父类相 同方法，执行结果却 不相同

正在 读取 文本 文件
正在 写入 文本 文件
正在 读取 磁盘 文件
正在 写入 磁盘 文件
正在 读取 进程 文件
正在 写入 进程 文件