Using Recursion to Reverse a String

You shouldn't call nextLine() because your input is all on one line. Your logic is much clearer if you begin by creating a simple helper method, it should take an array of words and a position; from there you can recursively build your desired output with something like

private static String reverse(String[] words, int p) {
    if (p + 1 < words.length) {
        return reverse(words, p + 1) + " " + words[p];
    } else if (p < words.length) {
        return words[p];
    }
    return "";
}

Then your public method is easy to implement, just split the original input on white space and call reverse starting at 0 (remembering to return the result). Like,

public static String reverse(String words) {
    return reverse(words.split("\\s+"), 0);
}

And then, I tested it like

public static void main(String[] args) {
    System.out.println(reverse("Hello my friend"));
}

Which outputs (as requested)

friend my Hello

Alternatively, you could make that helper take your Scanner instead like

private static String reverse(Scanner sc) {
    if (sc.hasNext()) {
        String currentWord = sc.next();
        if (sc.hasNext()) {
            return reverse(sc) + " " + currentWord;
        }
        return currentWord;
    }
    return "";
}

And then your public method is

public static String reverse(String words) {
    return reverse(new Scanner(words));
}

public static String reverseSentence(String sentence) {

    StringBuilder sb = new StringBuilder();

    int firstSpace = sentence.indexOf(' ');
    if (firstSpace == -1) {
        return sb.append(sentence.strip()).append(" ").toString();
    }
    String secondPart = sentence.substring(firstSpace + 1); 
    String firstPart = sentence.substring(0, firstSpace);//similar to merger sort 
    return sb.append(reverseSentence(secondPart)).append(reverseSentence(firstPart)).toString();
}

You throw away the recursion results:

 reverse(sc.nextLine());
 backwards = backwards + " " + currentWord;

Instead, use this:

 backwards = reverse(sc.nextLine());
 backwards = backwards + " " + currentWord;

Better yet:

 backwards = reverse(sc.nextLine()) + " " + currentWord;

As stated in the comments, you could use a StringBuilder instead of Scanner class.

This example sends the same words, splits them by spaces each time you enter the method and you send the index of the word to be added in the next iteration.

For example:

public class RecursiveReverse {

    static StringBuilder sb = new StringBuilder();

    public static void main(String[] args) {
        String stringToReverse = "Hello my friend!";
        System.out.println(reverse(stringToReverse, stringToReverse.split(" ").length - 1));
    }

    public static String reverse(String words, int i) {
        if (i >= 0) { //If the index of the words is greater or equals the first word
            sb.append(words.split(" ")[i]); //We split it and append it to our StringBuilder
            sb.append(" "); //We append a space
            reverse(words, --i); //We do this again
        }
        return sb.toString(); //When the above condition doesn't match we return the StringBuilder object as a String (which contains the words reversed)
    }
}

Which produces this output:

friend! my Hello 

A better method would be passing a String array as parameter so you split only once (when sending the words as an array to the method) the String.

public class RecursiveReverse {

    static StringBuilder sb = new StringBuilder();

    public static void main(String[] args) {
        String stringToReverse = "Hello my friend!";
        String words[] = stringToReverse.split(" ");
        System.out.println(reverse(words, words.length - 1));
    }

    public static String reverse(String words[], int i) {
        if (i >= 0) {
            sb.append(words[i]);
            sb.append(" ");
            reverse(words, --i);
        }
        return sb.toString();
    }
}

Do you must use recursion? You can do that without it.

public static String reverse(String words) {
    String[] list = words.split(" ");
    Collections.reverse(list);
    String reversed = String.join(" ", list);
    return reversed;
}

You must keep hold of the extracted words between calls in an accumulator. Here is an example.

public static String reverse(String words, String acc){
    Scanner sc = new Scanner(words);

    if(!sc.hasNext()){
        return acc;
    }

    return reverse(sc.nextLine(), acc) + " " + sc.next();
}

You would call it like this.

reverse("Hello my friend", "");

It's not the most efficient implementation in the world, but yeah... It must work!

If you want a more efficient one, use a StringBuilder as the accumulator.