Implementación de Composición (Relación Has-A) en Python

Podemos acceder al miembro de una clase dentro de una clase usando estos 2 conceptos: 

• Por Composición (Relación Tiene-A)
• Por herencia (Relación Is-A)

Aquí estudiaremos cómo implementar la relación Has-A en Python.

Al usar los nombres de las clases o al crear un objeto, podemos acceder al miembro de una clase dentro de otra clase. 

Ejemplo:

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

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

En estos ejemplos anteriores, la clase de automóvil tiene una referencia de clase de motor. Aquí dentro de la clase Car también podemos crear diferentes variables y métodos. Usando la referencia de objeto de la clase Engine dentro de la clase Car, podemos acceder fácilmente a todos y cada uno de los miembros de la clase Engine dentro de la clase Car.

Ejemplo 1: Código ejecutable para composición

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

Aquí, en el ejemplo anterior, tenemos 2 clases ‘Empleado’ y ‘Datos’ . Dentro del Constructor de la clase ‘Datos’ estamos creando un objeto de la clase Empleado debido al cual podemos acceder fácilmente a los miembros de la clase Empleado . Dentro de la clase de datos , el objeto de la clase de empleado se convierte en una variable de instancia de la clase «Datos» . Estamos creando objetos dentro del constructor, por lo que siempre que llamemos a cualquier método o variable de la clase Employee , debemos usar la palabra clave self . Podemos reemplazar «self.emp_obj» por «Empleado», pero usando el nombre de la claseEmpleado solo podemos acceder al método estático o variable de la clase Empleado .

Ejemplo 2: Otro ejemplo simple usando Composición

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()

Producción

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

Aquí, en el ejemplo anterior, estamos creando un objeto de clase A dentro del método de instancia de clase B que es el método m2(). Entonces, el flujo de ejecución será Inicialmente, se creará el objeto de la clase B para que se ejecute el constructor de la clase B. Ahora el objeto de la clase B está llamando al método m2(), por lo que el cursor irá al método m2() de la clase B. Dentro del método m2() de la clase B se crea el objeto de la clase A, por lo que el constructor de la clase A será ejecutado, luego se ejecutará el método m1() de la clase A. Finalmente, imprimirá la declaración final del método m2() y la ejecución terminará aquí.