Let's walk through refactoring your composition-based setup into a clean inheritance hierarchy. First, we'll eliminate duplication between Class A and Class B by creating a shared base class, then build out the specialized child classes, and finally adjust Class C to leverage inheritance instead of instantiating separate objects.

Step 1: Extract a Base Class for Shared Members #

Since both Class A and Class B have var1, var2, and an Add method, we'll create a base class to hold these common elements. This reduces redundant code and makes future changes easier.

class BaseMath:
    def __init__(self, var1, var2):
        self.var1 = var1
        self.var2 = var2
    
    # Shared Add method—override this in child classes if their Add logic differs
    def Add(self):
        return self.var1 + self.var2

Step 2: Define Child Classes (Class A and Class B) #

Now we'll make Class A and Class B inherit from BaseMath, then add their unique methods. This keeps each class focused on its specific functionality.

Class A (Inherits from BaseMath) #

class ClassA(BaseMath):
    # Unique methods for Class A
    def Multiply(self):
        return self.var1 * self.var2
    
    def Power(self):
        return self.var1 ** self.var2
    
    # If Class A's Add logic is the same as BaseMath, no need to override
    # Uncomment below if you need a custom Add implementation:
    # def Add(self):
    #     return self.var1 + self.var2 + 5  # Example custom logic

Class B (Inherits from BaseMath) #

class ClassB(BaseMath):
    # Unique methods for Class B
    def Subtract(self):
        return self.var1 - self.var2
    
    def Divide(self):
        return self.var1 / self.var2 if self.var2 != 0 else 0
    
    # Override Add here if Class B's logic differs from BaseMath
    # def Add(self):
    #     return (self.var1 * 2) + self.var2  # Example custom logic

Step 3: Refactor Class C to Use Inheritance #

Instead of instantiating separate ClassA and ClassB objects, Class C can inherit from both (if your language supports multiple inheritance, like Python) to directly access their methods. We'll also handle the Add method conflict explicitly to avoid ambiguity.

class ClassC(ClassA, ClassB):
    def f1(self):
        # Call unique methods from Class A and Class B directly
        multiply_result = self.Multiply()
        subtract_result = self.Subtract()
        return f"Multiply Result: {multiply_result}, Subtract Result: {subtract_result}"
    
    # Resolve the Add method conflict—choose which parent class's implementation to use
    def Add(self):
        # Use Class A's Add implementation
        return ClassA.Add(self)
        # Or use Class B's: return ClassB.Add(self)

If Your Language Doesn't Support Multiple Inheritance #

If you're working with a single-inheritance language (like Java or C#), you can have Class C inherit from one parent (e.g., ClassA) and use composition for the other (e.g., hold a ClassB instance). This still leans into inheritance while working within language constraints:

// Example in Java
public class ClassC extends ClassA {
    private ClassB bInstance;
    
    public ClassC(int var1, int var2) {
        super(var1, var2);
        bInstance = new ClassB(var1, var2);
    }
    
    public String f1() {
        int multiplyResult = this.Multiply();
        int subtractResult = bInstance.Subtract();
        return "Multiply Result: " + multiplyResult + ", Subtract Result: " + subtractResult;
    }
}

Key Benefits of This Structure #

• Reduced Duplication: The base class eliminates repeated var1/var2 and shared method logic.
• Clear Hierarchy: Each class has a single responsibility—base class handles shared behavior, child classes handle specialized logic.
• Easy Maintenance: Changes to shared properties/methods only need to be made in the base class.

内容的提问来源于stack exchange，提问作者user32882