Python设计模式 - 基础 - 类与类之间的六种关系
2021-07-12 16:05
标签：cme 静态 animal 派生类 info ane 实例化 复杂 end 在程序中需要把世间万物抽象成相应的类，现实世界中物与物之间的关系和程序中类与类之间的关系相对应，因为世间万物是普遍联系的，所以程序中类与类之间也不是孤立的。在系统分析和框架设计中，根据面向对象机制的三大特性：封装、继承、多态，归纳和扩展出类与类之间六种不同的关系： - 依赖关系Dependency： 在局部变量，方法的形参，或者对静态方法的调用中实现 - 关联关系Association： 在类的成员变量中实现，可以双向也可以单向 - 聚合关系Aggregation： 强关联，整体与部分的关系，但是可分离 - 组合关系Composition： 更强关联，整体与部分的关系，不可分离 - 继承关系Generalization：类与类，或接口与接口之间的父子关系 - 实现关系Implementation： 接口或抽象类定义好的操作集合，由实现类完成接口或抽象类的具体操作 其实从更宽泛的角度来说，类与类之间的关系其实只有三种：继承、实现、关联(依赖是一种弱关联，聚合和组合是关联中的特例)。继承和实现是类与类之间的纵向关系，比如A类继承了B类，C类实现了D接口；而关联是类与类之间的横向关系，类与类之间的关联关系从弱到强依次为：依赖
纵向的继承和实现关系很容易理解，横向的关联关系相对复杂些，尤其是对生命周期的不同处理，关联、聚合、组合只能结合上下文语义才好判断。下面就重点介绍下这些容易相互混淆的关联关系。 依赖关系(Dependency) 概念说明 可以简单地理解，依赖就是一个类A使用到了另一个类B，仅仅是“使用到”，类B本身并不属于类A，或者说类A并不拥有类B。依赖关系是偶然性的、临时性的，但是因为类B本身被类A引用到，所以B类的变化也会影响到类A。比较常见的场景就是人乘飞机从一地到另一地，飞机和人之间并没有所属关系，只是一种临时性的出行工具，此时人和飞机之间就是依赖关系。 代码实现 依赖关系在代码上体现为三种形式： - 类B作为类A方法的形参 - 类B作为类A方法的局部变量 - 类A调用类B的静态方法 UML类图 UML中使用带箭头的虚线表示，箭头指向表示调用关系，从类A指向类B 关联关系(Association) 概念说明 关联关系一般长期性的、拥有性的关系，而且双方的关系一般是平等的，如学校与学生之间、老师与学生之间。被关联类B以类的属性形式出现在关联类A中，关联可以是单向的，也可以是双向的。 依赖关系与关联关系的区别有动静之分，依赖关系的偶然性和临时性说明了动态性，关联关系的长期性、拥有性静态地展示了对被关联类的引用。 代码实现 关联关系在代码上体现为二种形式： - 单向关联：单向拥有关系，只有一个类知道另一个类的属性和方法 - 双向关联：双向拥有关系，双方都知道对方的属性和方法 - 自身关联：自己关联自己，这种情况比较少但也有用到，如链表 class UML类图 UML中使用直线箭头表示，箭头指向为被关联的类，从类A指向类B 单向关联 双向关联 自我关联 聚合关系(Aggregation) 概念说明 聚合关系是也是关联关系的特例。普通关联关系的两个类一般处于同一平等层次上，而聚合关系的两个类处于不同的层次，是整体与部分的关系。聚合关系中的整体和部分是可以分离的，生命周期也是相互独立的，如公司与员工之间。 代码实现 聚合关系在代码上体现为：类A由类B聚合而成，类A包含有类B的全局对象，但类B的对象可以不在类A创建的时刻创建。 UML类图 UML中使用空心菱形+实线箭头表示，空心菱形边指向类A(整体)，实现箭头边指向部分类B(部分) 组合关系(Composition) 概念说明 组合关系也是关联关系的特例，属于强聚合，本身也表示整体与部分的关系，但是组合关系中的整体和部分是不可分离的，整体生命周期的结束时也是部分的生命周期到头时。如人和大脑。 聚合和组合其实都是关联的特例，都是整体与部分的关系。它们的区别在于整体和部分是否可分离，聚合的两个对象之间是可分离的，且具有各自的生命周期，而组合的两个对象往往表现为一种同命相连的关系。 代码实现 组合关系在代码上体现为在整体类的构造方法中直接实例化成员类，因为类组合关系中整体与部分是共生的。 UML类图 UML中使用实心菱形+实线箭头表示，实心菱形边指向类A(整体)，实线箭头边指向类B(部分) 继承关系(Generalization) 概念说明 继承指的是子类继承父类、或子接口继承父接口的功能并增加自己新功能的过程，是两个类之间耦合度最大的关系之一。父类称为基类或超类，子类也称为派生类。子类可以继承自抽象类或普通类。 代码实现 继承关系在代码上体现为二种形式： - 子类继承自抽象类或普通类 - 子接口继承自父接口：适用于Java class class Animal(object):
def __init__(self):
self.name = "Animal"
def run(self):
print ("Animal is running.")
def play(self):
print ("Animal is playing.")
class Dog(Animal):
def __init__(self):
self.name = "Dog"
def run(self):
print ("Dog is running.")
def __bark(self):
print ("Dog is barking.")
class Cat(Animal):
def __init__(self):
self.name = "Cat"
def play(self):
print ("Cat is running.")
def __jump(self):
print ("Cat is jumping.")
>>> dog = Dog()
>>> cat = Cat()
>>> dog.run()
Dog is running.
>>> dog.play()
Animal is playing.>>> cat.run()
Animal is running.
>>> cat.play()
Cat is running.>>> UML类图 UML中使用实线+空心箭头表示，箭头由子类指向父类、或子接口指向父接口 实现关系(Implementation) 概念说明 实现关系是指一个类实现一个或多个接口功能的过程，这里的接口更多的是一种契约或规范。实现是两个类之间或类与接口之间耦合度最大的关系之一，在这种关系中，类实现了接口或接口类中所声明的操作。 代码实现 实现关系在代码上体现为二种形式： - 类具体实现接口中所声明的操作：如Java中支持原生interface，可以直接implement - 类具体实现接口类中所声明的操作：如python中无原生interface，这里的接口类更多的是逻辑上的契约或规范 UML类图 UML中使用虚线+空心箭头表示，箭头由实现类指向接口 Python设计模式 - 基础 - 类与类之间的六种关系 标签：cme 静态 animal 派生类 info ane 实例化 复杂 end 原文地址：https://www.cnblogs.com/coolstream/p/9499299.html# 类B作为类A方法的形参
class Person(object):
def flying(self, plane):
plane.fly()
class Plane(object):
def fly(self):
print ("The plane is flying.")
>>> person = Person()
>>> plane = Plane()
>>> person.flying(plane)
The plane is flying.
>>>
# 类B作为类A方法的局部变量
class Person(object):
def flying(self):
self.plane = Plane()
plane.fly()
class Plane(object):
def fly(self):
print ("The plane is flying")
>>> person = Person()
>>> person.flying()
The plane is flying.
>>>
# 类A调用类B的静态方法
class Person(object):
def flying(self):
Plane.fly()
class Plane(object):
@staticmethod
def fly():
print ("The plane is flying.")
>>> person = Person()
>>> person.flying()
The plane is flying.
>>>
# 单向关联
class Student(object):
def __init__(self):
self.title = "Seno"
def study(self):
print ("Studying...")
class School(object):
def __init__(self):
self.address = "ABC Street"
self.student = Student()
def act(self):
print (self.student.title)
self.student.study()
>>> school = School()
>>> school.act()
Seno
Studying...
>>> # 双向关联
# 自身关联
class Node(object):
def __init__(self):
self.next = Node()
class School(object):
def __init__(self):
self.__students = []
def add_student(self, student):
self.__students.append(student)
class Student(object):
pass
>>> student = Student()
>>> school = School()
>>> school.add_student(student)
>>>
class Person(object):
def __init__(self):
print ("Person Iinitialization Start")
self.__brain = Brain()
print ("Person Iinitialization End")
def run(self):
print ("Running...")
class Brain(object):
def __init__(self):
print ("Brain Initialization Start")
print ("Brain Initialization End")
>>> person = Person()
Person Iinitialization Start
Brain Initialization Start
Brain Initialization End
Person Iinitialization End
>>> person.run()
Running...
>>>
# 子类继承自抽象类，必须实现父类中@abstractmethod修饰的抽象方法
from abc import ABCMeta, abstractmethod# 子类继承自普通类，子类方法重写父类同名非私有方法
class Car(object):
def engine(self):
raise NotImplementedError
class Benz(Car):
def engine(self):
print ("Benz is running.")
class BMW(Car):
def engine(self):
print ("BMW is running.")
>>> benz = Benz()
>>> bmw = BMW()
>>> benz.engine()
Benz is running.
>>> bmw.engine()
BMW is running.
>>>
文章标题：Python设计模式 - 基础 - 类与类之间的六种关系
文章链接：http://soscw.com/essay/104226.html