java.lang.StringBuilder

System.out.println(new StringBuilder("I like")
                   .append(cake)
                   .append(" and I eat ")
                   .append(cakeNumber)
                   .append(" blah blah     prolonging this string because ")
                   .append(whyNot)
                   .append(" and so on ")
                   .append(number)
                   .append(".")
                   .toString());

java.text.MessageFormat

System.out.println(MessageFormat.format("I like {0} and I eat {1} blah blah    prolonging this string because {2} and so on {3}.",
                   cake, cakeNumber, whyNot, number));

I kind of like it with a static import, like this:

import static java.text.MessageFormat.format;

System.out.println(format("I like {0} and I eat {1} blah blah    prolonging this string because {2} and so on {3}.",
                   cake, cakeNumber, whyNot, number));

java.util.Formatter (also known as String.format)

System.out.printf("I like %s and I eat %d blah blah    prolonging this string because %s and so on %f.%n",
                  cake, cakeNumber, whyNot, number);
                  

You have lots of syntactic choice at your disposal here (Just to list some, there is probably more):

System.out.format(...)
System.out.printf(...)
System.out.print(String.format(...)) // you will need to include the line break in the format
System.out.println(String.format(...)) // line break will be caused by println()
import static java.lang.String.format;
System.out.print(format(...))
System.out.println(format(...))
System.out.println(new Formatter().format(...))

%n represents the system's specific line break character. It is required because printf does not insert a line break after the operation automatically.

Multiline string concatenation

System.out.println("I like " + cake + " and I eat " +
                   cakeNumber + " blah blah    prolonging this string because" +
                   whyNot + " and so on " + number + ".");

I took hhafez's code and added a memory test:

private static void test() {
    Runtime runtime = Runtime.getRuntime();
    long memory;
    ...
    memory = runtime.freeMemory();
    // for loop code
    memory = memory-runtime.freeMemory();

I run this separately for each approach, the '+' operator, String.format and StringBuilder (calling toString()), so the memory used will not be affected by other approaches. I added more concatenations, making the string as "Blah" + i + "Blah"+ i +"Blah" + i + "Blah".

The result are as follows (average of 5 runs each):

We can see that String + and StringBuilder are practically identical time-wise, but StringBuilder is much more efficient in memory use. This is very important when we have many log calls (or any other statements involving strings) in a time interval short enough so the Garbage Collector won't get to clean the many string instances resulting of the + operator.

And a note, BTW, don't forget to check the logging level before constructing the message.

Conclusions:

1. I'll keep on using StringBuilder.
2. I have too much time or too little life.