Which design pattern to use when multiple inheritance is needed in java [duplicate]

Question

I have a vehicle class, and nice implmented Ship and Plane to check for safety, each class implementing its own safetycheck. World was good.

interface Vehicle {
    public void safetyCheck();
}


class Ship implements Vehicle {
    @Override
    public void safetyCheck() {
        //check if number of lifeboats >= number of passengers
    }
}

class Plane implements Vehicle {
    @Override
    public void safetyCheck() {
        //check if oxygen mask is in place.
    }
}

But soon a hybrid called seaplane was needed which duplicated safety checks of Ship and Plane

class SeaPlane implements Vehicle {
    @Override
    public void safetyCheck() {
        //check if oxygen mask is in place.
        // && 
       //check if number of lifeboats >= number of passengers
    }
}

Which design patterns help in such particular scenarios to reduce code redundancy and make implementation cleaner ?

Answer 1

Without establishing a new interface or class for this case you could use the Composition over Inheritance principle.

So your SeaPlane could look like this:

class SeaPlane implements Vehicle {
    private Vehicle plane,
                    ship;
    @Override
    public void safetyCheck() {
       plane.safetyCheck();
       ship.safetyCheck()
    }
}

With a constructor taking a Plane and a Ship object.

Answer 2

You could apply the strategy pattern to separate some behavior of a component from the components definition. Then you could use these behaviors in multiple classes in order to avoid redundancy.