When writting Scala code, you always have the ability to use Java like exception control flows using try and catch.
However, you have the option of start using the Try type.

Why use Try vs try/catch?

Try was introduced in Scala 2.10 and behaves as a mappable Either without having to select right or left.

In the example below, taken from the Scala API:

def divide: Try[Int] = {  
  val dividend = Try(Console.readLine("Enter an Int that you'd like to divide:\n").toInt)
  val divisor = Try(Console.readLine("Enter an Int that you'd like to divide by:\n").toInt)
  val problem = dividend.flatMap(x => divisor.map(y => x/y))
  problem match {
    case Success(v) =>
      println("Result of " + dividend.get + "/"+ divisor.get +" is: " + v)
      Success(v)
    case Failure(e) =>
      println("You must've divided by zero or entered something that's not an Int. Try again!")
      println("Info from the exception: " + e.getMessage)
      divide
  }
}

You can see how, instead of using explicit try and catch to treat exceptions, Try is used to encapsulate the operation which is always an instance of either Success or Failure.

Benefits

You get, according again to the official documentation the:

[..] ability to pipeline, or chain, operations, catching exceptions along the way. You can map as you would a collection, an option or a right projection of an Either.

Furthermore, they encode exceptions in the Type system allowing for better documentation and clearer intention.
The Effective Scala[2] guide states:

using Option or com.twitter.util.Try are good, idiomatic choices, as they harness the type system to ensure that the user is properly considering error handling.

Start enforcing it today with Codacy

Login to your account and enable the pattern “Enforce usage of the Try object” to enforce it in your projects

1: Scala API http://www.scala-lang.org/api/current/index.html#scala.util.Try
2: Effective Scala http://twitter.github.io/effectivescala