Когда использовать ассоциацию, агрегацию, состав и наследование?
Я видел множество постов в Stackoverflow, объясняющих разницу между отношениями: ассоциации, агрегация, композиция и наследование, с примерами. Тем не менее, я более конкретно путаюсь больше о плюсах и минусах каждого из этих подходов, а также о том, когда один подход наиболее эффективен для поставленной задачи. Это то, что я не смог найти хорошего ответа.
Следуя рекомендациям форума, я не спрашиваю, почему люди могут лично предпочесть использование наследования, а не композиции. Я особенно заинтересован в любых объективных преимуществах / недостатках каждого подхода, какими бы сильными это ни звучало. То есть один подход создает более читаемый код, чем другой, или он имеет лучшую эффективность времени выполнения и т. д.
В идеале, если бы кто-то мог привести мне примеры из реальной жизни, где эти подходы могли быть успешными или неудачными и почему, это было бы чрезвычайно полезным для развития моих и, я надеюсь, других знаний.
В целях обеспечения прочной основы для работы я включил примеры каждого отношения в Python 2. Надеюсь, это позволит избежать путаницы, если мое понимание этих отношений не является на самом деле правильный.
Ассоциация
Класс B имеет недельное отношение ассоциации с классом A, так как он использует определенные атрибуты из A в методе addAllNums. Тем не менее, это степень отношений.
class A(object):
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def addNums():
self.b + self.c
class B(object):
def __init__(self, d, e):
self.d = d
self.e = e
def addAllNums(self, Ab, Ac):
x = self.d + self.e + Ab + Ac
return x
ting = A("yo", 2, 6)
ling = B(5, 9)
print ling.addAllNums(ting.b, ting.c)
Агрегация
Класс B формирует отношение агрегации с классом A, так как он ссылается на независимый объект A при инициализации в качестве одного из его атрибутов. В то время как объект B зависит от A, в случае разрушения B, A будет продолжать существовать, поскольку он не зависит от B.
class A(object):
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def addNums():
self.b + self.c
class B(object):
def __init__(self, d, e, A):
self.d = d
self.e = e
self.A = A
def addAllNums(self):
x = self.d + self.e + self.A.b + self.A.c
return x
ting = A("yo", 2, 6)
ling = B(5, 9, ting)
print ling.addAllNums()
Состав
Подобно агрегации, однако вместо того, чтобы ссылаться на независимый объект, B фактически инициализирует экземпляр A в своем собственном конструкторе как атрибут. Если объект B уничтожен, то и объект A тоже. Вот почему у композиции такие прочные отношения.
class A(object):
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def addNums():
self.b + self.c
class B(object):
def __init__(self, d, e):
self.d = d
self.e = e
self.A = A("yo", 2, 6)
def addAllNums(self):
x = self.d + self.e + self.A.b + self.A.c
return x
ling = B(5, 9)
print ling.addAllNums()
Я решил не включать пример наследования, так как я полностью доволен им, и я чувствую, что его включение может отбросить суть вопроса немного касательно.
Вне зависимости, опять же, каковы плюсы и минусы приведенных выше примеров и наследования (по сравнению друг с другом).
Спасибо.