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

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

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

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

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

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

相关推荐