Methods within methods

That answer is esentially correct. Just instead of nested methods, they're piggyback methods. (They have an actual name, but I can't remember it at this moment).

Basically any methods that return a value, can have another method concatenated on the end of it. You can create an infinite loop of these if you wanted, but there wouldn't really be any point to that.

If you wanted to make your own you can either have the method return a primitive data type or the instance of the class.

class Example {
    public static void main(String[] args) {
        RandomWords rw = new RandomWords();

        String word = rw.changeWord().changeWord().getWord().toUpperCase().concat("-test");

        System.out.println(word);
    }
}

class RandomWords {
    private String randomWord;
    private String[] words;

    RandomWords () {
       words = new String[]{"Hello", "World", "Peter", "Monopoly"};
       changeWord();
    }

    public Example changeWord() {
        Random random = new Random();
        randomWord = words[random.nextInt(3)];

        return this;
    }

    public String getWord() {
        return randomWord;
    }
}

Sometimes this can be super handy! I'd definitely take a look into it.

Note: basically the string "jerk" has the String object's methods. When you use the toLowerCase method, it returns a String, so you can append another method from the String class. Then keep doing it to your hearts content. But as soon as you return a different type of variable you would have to use methods from that new type of variable. The contains method returns a Boolean, so you would no longer be able to append a method such as toUpperCase. Hopefully, this makes sense. (I wrote it very quickly)