Same method in two irrelevant classes - reduce repetition

Question

Say I have two classes

class Driver{
    //attributes of driver ,ex: driving licence number
    // methods related to driving ,ex: drive(Car) , stop(Car)
    changeTyre(Car,Tyre);   // sometimes the driver can change the tyres right?
}
class Mechanic{
    // Hard mechanical stuff , ex: repairEngine(Car)
    changeTyre(Car,Tyre);  // Simple.hence sometimes the driver also does
}

Now the implementations of the two changeTyre() methods will be the same.

Now I have two issues,

1. There is a repetition (duplication) of code
2. It doesn't seem meaningful to have a Super class containing the changeTyre(Car,Tyre) method

How these kind of situations handled?

Answer 1

To expand on using composition over inheritance (Willie's answer), I think you were on the right track in your comment about using ChangeTyre like car.ChangeTyre(Tyre).

Each mechanic or driver will be associated to a car, so they can have a Car property -

class Driver{

    Car driverCar;

    //constructor
    Driver(Car car)
    {
        driverCar = car;
    }

    //attributes of driver ,ex: driving licence number
    // methods related to driving ,ex: drive(Car) , stop(Car)
    changeTyre(Tyre) 
    {
        driverCar.changeTyre(Tyre);
    }
}

They changeTyre method of Driver and Mechanic might be the same, but the actual logic to change the tyre will live in one place. I don't think inheritance works because a mechanic is not a driver, and inheritance supports an "is-a" relationship. It may not make sense to force changeTyre to a superclass (say Person), because not every class that inherits from Person would need to have a changeTyre method. See this question for more information about composition over inheritance.

Answer 2

class Driver
{
    //attributes of driver ,ex: driving licence number
    // methods related to driving ,ex: drive(Car) , stop(Car)
    public TyreFunction TyreFunctions { get; set; }
}

class Mechanic {
    // Hard mechanical stuff , ex: repairEngine(Car)
    // Simple.hence sometimes the driver also does
    public TyreFunction TyreFunction { get; set; }
}

class TyreFunction
{
    change(Car,Tyre)
} 

Do This !

Then you have no duplicated code and control in one class. Also you can create al list of functions to add specific functions to the classes.

Answer 3

I would suggest that Mechanic should actually inherit from Driver, as I am presuming that in your context anything a driver can do a mechanic will be able to do (i.e drive the car for testing).

The changeTyre method should be virtual so that it can be overriden by Mechanic as the implementation may well be different (different tools etc).

I would also suggest that some of the elements should be seperated into interfaces (methods for driving, car maintanence methods etc).