StrategyDesignPattern.java

package LLD;

//Strategy is a behavioral design pattern that lets you define a family of algorithms, 
//put each of them into a separate class, and make their objects interchangeable.

class Vehicle {
    //constructor injection        
    DriveStrategy driveStrategy;

    Vehicle(DriveStrategy driveStrategy) {
        this.driveStrategy = driveStrategy;
    }

    public void drive() {
        //calling drivestrategy of particular vehicle
        this.driveStrategy.drive();
    }

}

class OffRoadVehicle extends Vehicle {
    
    OffRoadVehicle(){
        super( new SportsDrive() );
    }
    
}

class NormalVehicle extends Vehicle {

    NormalVehicle() {
        super( new NormalDrive() );
    }

    
}

//stategy pattern- Family of algorithms
interface DriveStrategy {
    
    public void drive();
}
class SportsDrive implements DriveStrategy {

    @Override
    public void drive() {
        System.out.println("Sports Drive Capabilities!!!");
    }
        
}
class NormalDrive implements DriveStrategy {

    @Override
    public void drive() {
        System.out.println("Normal Drive Capabilities!!!");
    }
    
}




public class StrategyDesignPattern { 
    public static void main(String[] args) {
        Vehicle offROadVehicle = new OffRoadVehicle();
        offROadVehicle.drive();

        Vehicle normalVehicle = new NormalVehicle();
        normalVehicle.drive(); 
    }

}



// Applicability:
//  1. Use the Strategy pattern when you want to use different variants of an algorithm within an object and be 
//     able to switch from one algorithm to another during runtime.
//  2. Use the pattern to isolate the business logic of a class from the 
//     implementation details of algorithms that may not be as important in the context of that logic.
//  3. Use the pattern when your class has a massive conditional statement that switches between 
//     different variants of the same algorithm.

// Pros:
//     1. You can isolate the implementation details of an algorithm from the code that uses it.
//     2. Open/Closed Principle. You can introduce new strategies without having to change the context.

// Cons:
//     1. Clients must be aware of the differences between strategies to be able to select a proper one.
//     2. If you only have a couple of algorithms and they rarely change, there’s no real reason to 
//        overcomplicate the program with new classes and interfaces that come along with the pattern.