Physics particle collisions I have a large file that I want to refactor.  My idea is to make helper classes with helper methods so that I can modularize methods.

Is that a good idea? For instance before refactoring:

public void collision(PhysicsCollisionEvent event) {
    if (event.getObjectA() instanceof BombControl) {
        final Spatial node = event.getNodeA();
        effect.killAllParticles();
        effect.setLocalTranslation(node.getLocalTranslation());
        BombControl bc = (BombControl) event.getObjectA();
        effect.emitAllParticles();
    } else if (event.getObjectB() instanceof BombControl) {
        final Spatial node = event.getNodeB();
        effect.killAllParticles();
        effect.setLocalTranslation(node.getLocalTranslation());
        effect.emitAllParticles();
    }
}


After refactoring:

public void collision(PhysicsCollisionEvent event) {
    CollisionHelper.collisionHelp(event, effect);
}


Is that a good idea or must I use a more elaborate recfactoring? I think it would work but I don't know of specific refactoring patterns.
A couple of simple things I notice right off the bat.


If you have a method which only calls another method, why bother having the first method at all?  I'm personally against these one-line wrapper methods and see them as unnecessary noise.
Your methods should be verb phrases, in general (e.g., CollisionHelper.helpCollision or even performCollision, in this case, since it's doing all of your processing).
I believe there's a standard for replacing instanceof usage with an actual method from the Class API, as follows: BombControl.class.isInstance(event.getObjectA()).  You can see more on this Stack Overflow Q&amp;A.  (Apparently you're using it correctly here, however.)


From the comments: you obviously should move the entire huge method body to the helper method, otherwise you have the same problem.  Just extract 'til you drop.