Statefull Strategy pattern I have a situation in a class tries to create a group of same type of components and if some component fails then it needs to decide whether it should continue or throw the exception. Now the behavior whether to continue or re-throw depends in the context in which that class is used.

So a obvious solution was to pass the behavior from outside in a constructor, which is effectively a strategy pattern. 
For now I had two implementations:


ContinuePolicy
AbortPolicy


These both policies were stateless so I created a single instance for them. Now I needed a strategy called SingleSuccessPolicy ( which ignores exception if atleast one of the components is successfully created). Now the problem is that to know whether all are failing or there is at least one success, the strategy needs to store some state (possibly count of components to be created). The side effect of it is that it makes creating a single instance infeasible.

Java Code:

class GroupComponent {
   private final ComponentExceptionPolicy exceptionPolicy;
   public GroupComponent(ComponentExceptionPolicy policy, GroupData data) {
      this.exceptionPolicy = policy;
   }

   public void createComponents() throws Exception {
      for(ComponentData compData : data.getComponentsData()) {
         try { 
           createComponent(compData)
         } catch (Exception e) {
           policy.apply(compData, e);
         }
      }
   }
}


Code for Strategies:

public interface ComponentExceptionPolicy {
    public void apply(ComponentData data, Exception e);
}

class ContinuePolicy extends ComponentExceptionPolicy {
    @Override
    public void apply(ComponentData data, Exception e) throws Exception {
      //just log it and continue
    }
}

class AbortPolicy extends ComponentExceptionPolicy {
    @Override
    public void apply(ComponentData data, Exception e) throws Exception {
       throw e;
    }
}

class MaximumFailuresPolicy extends ComponentExceptionPolicy {
   private int n; //the expected size of group component

   MaximumFailuresPolicy(int n) {
       this.n = n;
   }

   @Override
   public void apply(ComponentData data, Exception e) {
      //on each exception I decrement count
      if(--n == 0) { //check if exception threshold is reached
         //as soon as found that all have failed then exception is thrown,
         //if any of component succeeds, then n will not reach to 0 and it
         //will just continue
         throw e;
      } else {
         //just log
      }
   }
}


EDIT:

To clarify, MaximumFailuresPolicy is meant to check that atleast one of the component should be initialized successfully. Maybe I have named it incorrectly

Is it a proper way to achieve this? Any help is appreciated.
Policy Naming and Behaviour
Your SingleSuccessPolicy name is not a good one. What you actually have here is a MaximumFailuresPolicy.
To effectively create a &quot;real&quot; SingleSuccessPolicy, you'd need to evaluate the final result of your foreach loop. But that is simply impossible in the catch-block.
The problem I see with your code is, that your SingleSuccessPolicy is required to be correctly initialized with new SingleSuccessPolicy(compData.size()-1);. As soon as a differnt SingleSuccessPolicy is passed in, the behaviour is no more the desired one.
You might consider creating the policy inside the GroupComponent constructor. Then you can make sure that the MaximumFailuresPolicy will always behave as a SingleSuccessPolicy, but that would change a whole lot of your structure.
This assumes your compData are immutable after construction, which in turn would IMO warrant a factory / builder pattern instead of what you have here.
What you want to do is yours to decide, but the current way is IMO too unreliable, especially when the ExceptionPolicy depends on what data you are handling. That is not the point of an ExceptionPolicy.
Nitpicks:
Your indentation is not conform to java-standards. Oracle consistently uses an indentation of 4 spaces (or one tab) for blocks.
From method to for-loop, you have 3 spaces, from for-loop to try-catch the same, and from try-catch to statements, you have 2 spaces.
All three alternatives violate conventions, but above all, you're inconsistent!
Additionally I suggest you mark your arguments as final, whereever possible.