Implicit methods allows you, among other things, to extend an existing class with additional functionality without changing the class itself (which may be on a library you can't control).
In this example we're implicitly adding the method 'readToString()' to java.io.File:

class Main extends App {

  import java.io.File
  import scala.io.Source

  implicit class FileUtils(f: File) {
    // We are creating a method that can be used in any java.io.File:
    def readToString() =
      Source.fromFile(f).getLines().mkString(System.lineSeparator())
  }

  val myFile: File = new File("/some/location/my_file.txt")
  // java.io.File doesn't have this method, but it is defined implicitly (on top):
  val contents: String = myFile.readToString()

}

Traits are a great tool for modular, reusable design. They provide a kind of safe multiple inheritance and can contain both method implementations and state: (Java 8 introduced default methods in interfaces, but they are not nearly as powerful)

class Main extends App {

  trait Animal { var weight: Double; def move(): Unit }

  // Traits can have methods:
  trait FlyingAnimal extends Animal { def move() = println("I'm flying!") }
  trait WalkingAnimal extends Animal { def move() = println("I'm walking!") }

  // (Traits methods can be overriden):
  trait FlyingWalkingAnimal extends FlyingAnimal with WalkingAnimal {
    override def move() = println("I'm flying, or walking maybe!")
  }

  // Traits can have state:
  trait ColoredAnimal extends Animal { val color: String }
  trait LightColorAnimal extends ColoredAnimal { val color = "light" }
  trait DarkColorAnimal extends ColoredAnimal { val color = "dark" }

  trait HeavyAnimal extends Animal { var weight = 100d }
  trait LightAnimal extends Animal { var weight = 20d }

  trait AnimalInZoo

  // You can inherit multiple traits:
  class Lion    extends WalkingAnimal       with HeavyAnimal   with LightColorAnimal
  class Dog     extends WalkingAnimal       with LightAnimal   with DarkColorAnimal
  class Seagull extends FlyingWalkingAnimal with LightAnimal   with LightColorAnimal
  class Eagle   extends FlyingAnimal        with LightAnimal   with DarkColorAnimal

  val wildLion = new Lion()
  // This lion instance (only) is in the zoo!:
  val zooLion = new Seagull() with AnimalInZoo
}

Java 8 introduced default methods in interfaces, but they are not nearly as powerful - they cannot have, state for example. As Brian Goetz (Java Language Architect at Oracle) said on the lambda-dev mailing list: "The key goal of adding default methods to Java was “interface evolution”, not “poor man’s traits.".

There are lots of more small language features which are really useful. Bellow is an example of lazy vals, default argument values, named arguments, multiline strings, string interpolation, and the list could go on:

class Main extends App {
  var displayAge = false

  // This value is only computed if it is used:
  lazy val averageAgeInUSA = {
    Thread.sleep(1000) /* Long call to the database... */
    35
  }

  // Because displayAge is false, the value is never computed
  if (displayAge) {
    println("Average age is: " + averageAgeInUSA)
  }

  class Image(
               // Methods, and constructors,
               // can have default values:
               colorMode: String = "RGBA",
               width: Int = 800,
               height: Int = 600,
               autoScaling: Boolean = false
               )

  val img1 = new Image() /* <-- takes all default values */
  val img2 = new Image("CMYK") /* <-- colorMode different from default */
  // You can pass arguments by name:
  val img3 = new Image(autoScaling = true) /* <-- autoScaling different from default */

  println(s"""Scala allows you to have
             |multiline strings, and even
             |using variables directly in those
             |strings with string interpolation.
             |Like this: $displayAge.
             |""".stripMargin)
}