python中类与对象之间的关系_面向对象进阶之类和类之间的关系

Python面向对象的特征

一、继承

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

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

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

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

继承的作用：

1、解决代码的重用性

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

class course: #课程类：老师类和学生类 都有课程 所以称为组合关系

def __init__(self,name,price,time):

self.name=name

self.price=price

self.time=timeclass Person: #人类：老师和学生类 的父类 ，他们之间的关系称为 继承

def __init__(self,name,age,course):

self.name=name

self.age=age

self.course=courseclass 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#定义抽象方法，无需实现功能

defread(self):'子类必须定义读功能'

pass@abc.abstractmethod#定义抽象方法，无需实现功能

defwrite(self):'子类必须定义写功能'

pass

#class Txt(All_file):#pass#

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

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法

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

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

defread(self):print('进程数据的读取方法')defwrite(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、多态性：站在类实例化后，对象使用类的角度：人、猪、狗对象继承自一个动物类，他们继承了父类 相同的 走、说的方法；但是不同对象 调用相同的方法 就会有不同效果；

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

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

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

classlinux_all:def __init__(self,name):

self.name=namedefread(self):print("正在 读取 %s 文件"%self.name)defwrite(self):print('正在 写入 %s 文件'%self.name)class txt(linux_all): #子类txt 继承了 父类Linux_all的方法： 读、写

def __init__(self,name):

super().__init__(name)

super().read

super().writeclass sata(linux_all): #子类SATA继承了 父类Linux_all的方法： 读、写

def __init__(self,name):

super().__init__(name)

super().read

super().writeclass Process(linux_all): #子类process继承了 父类Linux_all的方法： 读、写

def __init__(self,name):

super().__init__(name) #在程序定义角度：所有 子类 都继承了 父类相同的 方法

super().read #----------------------------------------------------------------------------------------------------

super().write

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

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

正在 读取 文本 文件

正在 写入 文本 文件

正在 读取 磁盘 文件

正在 写入 磁盘 文件

正在 读取 进程 文件

正在 写入 进程 文件