int multiRet() {
    if (!a) return 0;
    if (!b) return 1;
    return c ? 2 : 0;
  }

  int singleRet() {
    if (!a) return 0;
    return (b&&c) ? 2 : 1;
  }

(The other way to get a single return point here is to turn the code into a nest of ?: operators. I claim that will be less readable and more error-prone for most C programmers.)

I can't recall any instance I've ever seen where code became simpler or easier to follow as a result of turning multiple return points into a single return point.

WTF?? No it isn't. You have this magic initial value and have to figure out which code paths have mutated it and which haven't. Mutable variables make code far far more complex to read.

I'm all for single return but through the use of expressions, not variables; I would probably express the given function as:

    expression() {
      return
        a ?
          (b && c) ?
            2
          :
            1
        :
          0
      ;
    }

It's not only a "good standard". It helps with verification: you can verify that the truth table is correct, and then that the function correctly implements that truth table. At least the former can sometimes be done formally.

> Curious how MISRA works out in practice.

Like every other standard, it depends on who's implementing it and with what tools, but it generally works out pretty well.

Java has better much better code safety than C (no pointers, gc, etc.) is portable via a VM, and is not used in embedded systems. It's also not specifically ISO C. MISRA was built do address certain issues with a certain language, in a certain environment. You shouldn't apply everything it recommends blindly to another language just because they both have conditions and return statements.

If you can explain to me why java benefits from having a single return statement, I would consider it. Otherwise, I refuse to blindly follow guidelines that were designed for different problems.