The function takes the first character of a String - str.charAt(0) - puts it at the end and then calls itself - reverse() - on the remainder - str.substring(1), adding these two things together to get its result - reverse(str.substring(1)) + str.charAt(0)

When the passed in String is one character or less and so there will be no remainder left - when str.length() <= 1) - it stops calling itself recursively and just returns the String passed in.

So it runs as follows:

reverse("Hello")
(reverse("ello")) + "H"
((reverse("llo")) + "e") + "H"
(((reverse("lo")) + "l") + "e") + "H"
((((reverse("o")) + "l") + "l") + "e") + "H"
(((("o") + "l") + "l") + "e") + "H"
"olleH"

Recursive method, using same logic as linked "duplicate", without use of split():

private static String reverseWords(String text) {
    int idx = text.indexOf(' ');
    return (idx == -1 ? text : reverseWords(text.substring(idx + 1)) + ' ' + text.substring(0, idx));
}

The logic is:

1. Take first char/word
2. If that is last char/word, return with it
3. Perform recursive call with remaining text (excluding word-separating space).
4. Append space (if doing word)
5. Append first char/word from step 1
6. Return result

As you can see, when applied to reversing text (characters) instead of words, it's very similar:

private static String reverseText(String text) {
    return (text.length() <= 1 ? text : reverseText(text.substring(1)) + text.charAt(0));
}

For people who like things spelled out, and dislike the ternary operator, here are the long versions, with extra braces and support for null values:

private static String reverseWords(String text) {
    if (text == null) {
        return null;
    }
    int idx = text.indexOf(' ');
    if (idx == -1) {
        return text;
    }
    return reverseWords(text.substring(idx + 1)) + ' ' + text.substring(0, idx);
}
private static String reverseText(String text) {
    if (text == null || text.length() <= 1) {
        return text;
    }
    return reverseText(text.substring(1)) + text.charAt(0);
}

Notice how the long version of reverseText() is exactly like the version in the linked duplicate.

As asked, this solution 'reverses' a string word-by-word, where words are simply separated by a single space character.

public class TestClass {

    public static String wordReverse(String s) {
        int idx = s.indexOf(" ");
        if (idx < 0) {
            // no space char found, thus, s is just a single word, so return just s itself
            return s;
        } else {
            // return at first the recursively reversed rest, followed by a space char and the first extracted word
            return wordReverse(s.substring(idx + 1)) + " " + s.substring(0, idx); 
        }
    }

    public static void main(String[] args) {
        System.out.println(wordReverse("DATA STRUCTURES AND ALGORITHMS"));
    }
}

I am having trouble understanding how I would read the input data from multiple lines

I don't fully understand that point, but if you are asking for how to read user input from stdin then have a look at System.in

Do it as follows:

import java.util.Arrays;

public class Main {
    public static void printReverse(String str) {
        if (str == null || !str.contains(" ")) {
            System.out.print(str);
            return;
        }
        String[] words = str.split("\\s+");// Split str on space(s)
        System.out.print(words[words.length - 1] + " ");// Print the last element

        // Call the method recursively by passing a new string with all but last word
        printReverse(String.join(" ", Arrays.asList(words).subList(0, words.length - 1)));

    }

    public static void main(String[] args) {
        String str = "this function reverse";
        printReverse(str);
    }
}

Output:

reverse function this