Actually you should break the function down first:

A loop has a few parts:

1. the header, and processing before the loop. May declare some new variables

2. the condition, when to stop the loop.

3. the actual loop body. It changes some of the header's variables and/or the parameters passed in.

4. the tail; what happens after the loop and return result.

Or to write it out:

foo_iterative(params){
    header
    while(condition){
        loop_body
    }
    return tail
}

Using these blocks to make a recursive call is pretty straightforward:

foo_recursive(params){
    header
    return foo_recursion(params, header_vars)
}

foo_recursion(params, header_vars){
    if(!condition){
        return tail
    }

    loop_body
    return foo_recursion(params, modified_header_vars)
}

Et voilà; a tail recursive version of any loop. breaks and continues in the loop body will still have to be replaced with return tail and return foo_recursion(params, modified_header_vars) as needed but that is simple enough.

Going the other way is more complicated; in part because there can be multiple recursive calls. This means that each time we pop a stack frame there can be multiple places where we need to continue. Also there may be variables that we need to save across the recursive call and the original parameters of the call.

We can use a switch to work around that:

bar_recurse(params){
    if(baseCase){
        finalize
        return
    }
    body1
    bar_recurse(mod_params)
    body2
    bar_recurse(mod_params)
    body3
}


bar_iterative(params){
    stack.push({init, params})

    while(!stack.empty){
        stackFrame = stack.pop()

        switch(stackFrame.resumPoint){
        case init:
            if(baseCase){
                finalize
                break;
            }
            body1
            stack.push({resum1, params, variables})
            stack.push({init, modified_params})
            break;
        case resum1:
            body2
            stack.push({resum2, params, variables})
            stack.push({init, modified_params})
            break;
        case resum2:
            body3
            break;
        }
    }
}

Think of a for loop as a little anonymous function that takes the loop index value as a parameter. In order to start the next iteration of the loop, the function can return a call to itself with a new value for the loop index parameter.

Like this:

Object loop(int i, Object data) {
    if (i > 0) {
        return loop(i - 1, evolve(data));
    } else {
        return data;
    }
}

That's the same as this:

for ( ; i > 0; i--) {
    data = evolve(data);
}

In some languages, particularly Scheme, and who knows maybe Java 8 or 9, the compiler is guaranteed to compile a recursive function such as the function loop above just the same as it compiles the for loop above.

In other languages, including the current and past versions of Java, nearly all compilers will make an executable that builds a big call stack. When the call stack is large it may even overflow the permitted size and crash the program.

Your condition in the recursive function is to add an enemy only when enemy_count is equal to 1, meaning you will only add one enemy.

public void AddEnemyToScreen(int enemy_count)
{

    // As long as enemy count is positive, keep adding enemies.
    if ( enemy_count > 0) {
             // Add new enemy to screen
            AddEnemey(new Enemy(r.nextInt(640), -10, textures,this,game));
            AddEnemyToScreen(enemy_count-1); // Add one more            
    }

}

This looks like a simple recursion:

public int GPA(double[] gpas, int index){
    if(index >= gpas.length) return 0;

    if(0 < gpas[index] && gpas[index] < 2) return 1 + GPA(gpas, index + 1);
    else return GPA(gpas, index + 1);
}

Just call it GPA(gpa, 1).

There is a lot of unnecessary comparisons in your method. Look at your uses of 10, L and start.

For example, suppose start = 0. No one of your ifs will enter. Better to start with 1. Look:

if (start > 0 && start != L)     //start is 0 so this won't enter

else if (start == L)             //start is 0 so this won't enter

else if (start < 0 && start > L) //start is 0 so this won't enter

Googling "how to convert for loop to recursion," there's a similar answer here, and an article with an example here.

This is a pretty big hint but the basic idea is that your arguments store the current loop state.

for (int i = 1; i <= n; i++)
{
    // ....
}

is equivalent to:

private static void PerformAction(int n)
    {
        if (n > 0)
        {
            // Do something
            PerformAction(n - 1);
        }
    }

So this is not pretty, but it works without recursion. Also i changed the return type from double to int because of reasons:

public static int sum(int z, int x, int y)
{
    // Compute number of calls
    int[][] calls = new int[x+1][x*y+1];
    calls[0][0] = 1;
    for (int i = 0; i < x; i++) {
        for (int j = 0; j <= x*y; j++) {
            for (int target = j+1; target <= j+y && target <= x*y; target++) {
                calls[i+1][target] += calls[i][j];
            }
        }
    }

    // Return count of last column where z <= 0
    int result = 0;
    for (int j = x*y; z-j <= 0; j--) {
        result += calls[x][j];
    }
    return result;
}

To understand, have a look at this high-tech Excel sheet:

This chart illustrates a call of sum(3, 3, 3). Horizontally you see x and vertically you see z both get smaller. y is 3 and not changed.

The top left 1 means one call to sum(3, 3, 3). This call then spawns three child calls (because of y=3): sum(2, 2, 3), sum(1, 2, 3) and sum(0, 2, 3). These three calls are found in the next column (where x=2).

Each of those three calls then spawns again three calls, shown in the row of x=1. These nine calls overlap a bit regarding z. Each of those nine calls then spawns again three calls, resulting in 27 calls in the x=0 column.

To get the result, you simply count all calls in the x=0 column, where z <= 0. In this example this is every call, so you get a result of 27. For a larger z the result would be smaller.

Like so:

public class Recursive {
    public void r(int i) {
        if (i < 1024) {
            i *= 2;
            System.out.println("Count is: " + i);
            r(i);
        }
    }

    public static void main(String[] args) {
        Recursive r = new Recursive();
        r.r(1);
    }
}

BASIC PROBLEM

They don't "go back to their old state" -- those variables are destroyed (released back to the memory heap) when you exit the method instance.

Those are local variables -- allocated when you enter the method, released on exit; some are input parameters, and receive their initial values from the arguments to the call. Thus, they don't "go back to their old state". What you're seeing is the unchanged states from the previous instance of the method.

Each time you call the routine, you add another instance to the stack. Each instance has its own version of the variables, which happen to share names. They do not share values.

SOLUTION

You work around this by keeping to basic principles of modular programming: you pass values into a method with the parameter list; you get values back with the return list. For instance, your final else clause might look something like this:

child_result = recurs(j1, index1, index2, indexTab1,
                      tab1, tab2, tab3, nZeros,
                      cost, i, tab1Index, b);
tools.add(child_result);
return tools;

I have not read your code for functionality; you may well need something other than tools.add(child_result) to accumulate the proper values. However, I believe that I've given you the basic principle that's currently giving you trouble.

If you don't want to change the contract you do it by making a helper.

private static void permutationFor(int i, int n, String prefix, String str) {
    if( i < n ) {
        permutation(prefix + str.charAt(i), 
                    str.substring(0, i) + str.substring(i+1, n));
        permutationFor(i+1, n, prefix, str);
    }
}

Thus you change the for loop with a call to permututaionFor

private static void permutation(String prefix, String str) {
    int n = str.length();
    if (n == 0) {
        System.out.println(prefix);
    } else {
        premutationFor(0, n, prefix, str);
    }
}

You do it by actually using the i parameter.

private static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
public static void binary(int n, String str, int i) {
    if (i == ALPHABET.length())
        return;
    if (n == 0) {
        System.out.println(str);
        return;
    }
    binary(n - 1, str + ALPHABET.charAt(i), 0); // next letter starts at beginning of alphabet
    binary(n, str, i + 1); // do it again using next letter of alphabet
}

TEST

binary(2, "", 0);

OUTPUT

aa
ab
ac
...
az
ba
bb
...
zy
zz