Catching exceptions in Scala has a slightly different syntax.

The syntax for catch clauses was chosen for its consistency with
an important part of Scala - pattern matching.

The behavior of this try-catch expression is the same as in other
languages with exceptions. The body is executed, and if it throws
an exception, each catch clause is tried in turn.

In this examle, if the exception is of type FileNotFoundException,
the first clause will excecute. If it is of type IOException, the
second clause will execute. If the exception is of neither type,
the try-catch will terminate and the exception will propogate
further.

Unlike java, Scala doesn't require you to catch checked exceptions,
or declare them in a throws clause. You can declare a throws
clause if you wish with the @throws annotation, but it is not
required.
Add an example of the Try-finally clause in Scala.

This is the idiomatic way to ensure a non-memory resource, such as
a file, socket, or database connection is closed.

First you acquire the resource. Then you start a try block in
which you use the resource. Lastly, you close the resource in a
finally block.
Catch clauses can also yield a value.

If the path provided results in a MalformedURLException, then the
default url will be used instead.
Add an example of the match expression.

Here the match expression looks and feels like the switch
statement from other languages. The default case is matched by an
underscore, a wildcard symbol frequently used in Scala as a
placeholder for a completely unknown value.

Any kind of constant, as well as other things, can be used in cases
in Scala, not just integer types and enum constants as in Java.
Also, there are no breaks, as the breaks are implicit; fallthrough
from one alternative to the next is not possible. The common case -
not falling through - becomes shorter, and a source of errors is
avoided because programmers can no longer fall through by accident.

Finally, match expressions result in a value.

This particular match expression has side effects.
Remove the side-effects from the match expression.

The two concerns (choosing a food, then printing it) have been
disentangled and separated.
Add an example showing how life is possible in Scala after break and continue.

The Scala code is doing exactly the same thing as the Java code,
but without break or continue.  Oh, look; it's shorter too.