Python中组合（Has-A Relation）的实现

我们可以使用以下两个概念访问一个类中一个类的成员：

• 按组合（有关系）
• 通过继承（Is-A 关系）

这里我们将学习如何在Python中使用实现Has-A Relation 。

Python中组合的实现

通过使用类名或创建对象，我们可以在另一个类中访问一个类的成员。

例子：

class Engine:
   # engine specific functionality
   '''
   '''
   '''

class Car:
   e = Engine()
   e.method1()
   e.method2()
   '''
   '''

在上面的这些示例中，类 Car has-A Engine 类引用。在 Car 类中，我们也可以创建不同的变量和方法。使用 Car 类中 Engine 类的对象引用，我们可以轻松访问 Car 类中 Engine 类的每个成员。

示例 1：组合的可执行代码

Python3

class Employee:
 
    # constructor for initialization
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    # instance method
    def emp_data(self):
        print('Name of Employee : ', self.name)
        print('Age of Employee : ', self.age)
 
 
class Data:
    def __init__(self, address, salary, emp_obj):
        self.address = address
        self.salary = salary
 
        # creating object of Employee class
        self.emp_obj = emp_obj
 
    # instance method
    def display(self):
 
        # calling Employee class emp_data()
        # method
        self.emp_obj.emp_data()
        print('Address of Employee : ', self.address)
        print('Salary of Employee : ', self.salary)
 
# creating Employee class object
emp = Employee('Ronil', 20)
 
# passing obj. of Emp. class during creation
# of Data class object
data = Data('Indore', 25000, emp)
 
# call Data class instance method
data.display()

输出

Name of Employee :  Ronil
Age of Employee :  20
Address of Employee :  Indore
Salary of Employee :  25000

在上面的示例中，我们有 2 个类'Employee'和'Data' 。在“数据”类构造函数中，我们正在创建一个Employee类的对象，因此我们可以轻松访问Employee类的成员。在Data类内部， Employee类对象成为“Data”类的实例变量。我们在构造函数中创建对象，所以每当我们调用Employee类的任何方法或变量时，我们都必须使用self 关键字。我们可以将“self.emp_obj”替换为“Employee”，但是通过使用类名Employee ，我们只能访问Employee类的静态方法或变量。

示例 2：另一个使用组合的简单示例

Python3

class A:
    def __init__(self):
        print('Class - A Constructor')
 
    def m1(self):
        print('M1 method of Class - A.')
 
 
class B:
    def __init__(self):
        print('Class - B Constructor.')
 
    # instance method
    def m2(self):
 
        # creating object of class A inside
        # B class instance method
        obj = A()
 
        # calling m1() method of class-A
        obj.m1()
        print('M2 method of Class - B.')
 
 
# creating object of class-B
obj = B()
 
# calling B class m2() method
obj.m2()

输出

Class - B Constructor.
Class - A Constructor
M1 method of Class - A.
M2 method of Class - B.

在上面的例子中，我们在 B 类的实例方法中创建了一个 A 类的对象，即 m2() 方法。所以执行流程将是 最初，将创建 B 类的对象，因此 B 类的构造函数将被执行。现在 B 类的对象正在调用 m2() 方法，因此光标将转到 B 类的 m2() 方法。在 B 类的 m2() 方法内部创建了 A 类的对象，因此 A 类的构造函数将是执行 then 类 A 的 m1() 方法最终将被执行，它将打印 m2() 方法的最终语句和执行结束的这里。