Y en tal caso la linea 'nombre = "PACO"' no compilaría. Ya que los valores no pueden modificarse (son referencias inmutables)

A diferencia de java, varios elementos de la sintaxis son opcionales, de forma de escribir menos código, y que éste quede más conciso y legible (en teoría, ja!).

Al principio nos resulta dificil entender en qué casos es opcional escribir algo y en cuales otros no.

Lo mejor para eso, si uno viene del mundo java, es, en principio escribir todo, y de a poquito ir probando eliminar declaraciones, hasta hacerse una idea.

Siguiendo con el ejemplo anterior, los puntos y comas se pueden eliminar, si tenemos una expresión por linea:

Además, la variable "nombre" al estar siendo asignada a un string ("World"), el compilador puede concluir automáticamente que va a ser de tipo String, con lo cual no hace falta que declaremos el tipo.

En cuanto a llamados a métodos, es posible eliminar los paréntesis, en el caso en que método no reciba parámetros.

Sería:

Incluso, si encadenamos mensajes, se pueden eliminar los puntos. En este caso es un único mensaje, un único punto, pero quedaría:

Definición de una clase

En su forma más simple una clase se ve muy similar a su par en java

Cuando no se especifica una superclase (igual que en java con extends) automáticamente esto quiere decir que la clase hereda de AnyRef.

La forma de especificar variables de instancia es también similar a java, pero teniendo en cuenta lo que ya vimos de valores y variables (y la inferencia de tipos)

Métodos

Acá es donde más variantes tenemos y donde más vamos a ver diferencias de sintaxis con Java.
Los métodos siempre se definen con la palabra reservada def.

En este caso estamos definiendo un método que no recibe parámetros y que tampoco retorna ningún valor. Si no declaramos el tipo de retorno, y tampoco utilizamos el símbolo igual ("="), que ya vamos a ver a continuación, el compilador interpreta esto como un método void.

En scala el tipo para void  es Unit

Si necesitamos un parámetro, se definiría así:

Si en cambio queremos hacer un método que nos retorne el string

En este caso estamos especificando el tipo de retorno del método, luego de los parámetros (a diferencia de java y C donde se escriben antes del nombre).

Otro detalle es que al retornar algo, el método se debe declarar con el símbolo "igual"

Ahora veamos cómo reducir un poco de código.

Podemos eliminar la palabra return. El compilador asume que el retorno es la última expresión del cuerpo del método.

Como en este caso el cuerpo del método es una única expresión, podemos evitar los paréntesis, que sirven para agrupar más de una expresión.

Además, como dijimos en la introducción, Scala tiene inferencia de tipos. Puede "ver" que según el cuerpo del método, estamos retornando un String, con lo cual podría inferir el tipo de retorno del método (viendo también el símbolo "igual", se dá cuenta que es un método que retorna algo, así que debe tener un tipo).

Así infiere el tipo a String

 

Finalmente, si quisieramos que este método siempre se llame sin usar los paréntesis (ya que no recibe parámetros), podemos eliminarlos de la declaración:

Ojo al piojo que ahora este llamado no compilaría:

También ojo al piojo que ahora la declaración se parece mucho a la declaración de  una variable de instancia, pero no lo es ! Esto es un método que se va a estar ejecutando en cada llamado.

Constructores locos

Otro punto donde difiere bastante de java y un poco de xtend.
El caso más simple es cuando una clase tiene un único constructor. Éste se puede escribir como parámetros en el mismo nombre de la clase.
En nuestro caso del robo

Getters & Setters

En los ejemplos hasta ahora vimos como declarar variables de instancia dentro de una clase. Por la forma en la que lo hicimos serán accesibles desde afuera. Por ejemplo podríamos hacer esto:

Si bien parece que estamos accediendo diréctamente a las variables de instancia, en realidad Scala genera internamente métodos getters y setters. De hecho cambia el nombre de la variable de instancia a "_nombre".

Igualmente es un detalle interno, lo importante es, cómo podemos nosotros incluir código en los getters y setters ?

Acá un ejemplo pavo donde nosotros definimos una nueva propiedad "color".

A la variable le damos un nombre con guión bajo, para que no conflictúe con los métodos. Además la hacemos privada.

Luego definimos dos métodos, el getter y setter respectivamente. 

El getter es bien sencillo.

El setter tiene una particularidad, no es un nombre "común", en cuanto a tener solo caracteres como "setColor" sería en Java, sino que hace uso de la capacidad de Scala de definir métodos cuyos nombres sean símbolos (una especie de sobre de símbolos).

En este caso queremos que se invoque este método cuando alguien escribe "color = ...".

Entre "color" y el símbolo "=" habría un espacio. Para representar esto en el nombre del setter, se usa el guión bajo (underscore)

Entonces

color_=     representa a     color = ...

Luego, como cualquier otro método recibe un parámetro entre paréntesis en la declaración.

Todo esto lo podemos achicar bastante con las cosas que ya vimos:

Y quedaría:

Hay que acostrumbrarse a todos esos símbolos "igual" :P

Sobrescritura de métodos

Cuestiones de Estilo

1 archivo = N clases

Una diferencia con java, es que en un archivo .scala se puede definir más de una clase.
No es necesaria la restricción de 1 clase = 1 archivo.
Esto sumado a la capacidad de Scala para escribir lo mismo en menos lineas de código, hace posible que uno organize varias clases en un mismo archivo. Además de la categorización por paquetes.

Imports locos

Acá tenemos varias cositas.
Para empezar, el caracter para "importar todo", no es el asterisco, sino el guión bajo. O sea,

También se puede escribir la sentencia "import" una sola vez, y luego separar los valores por comas

Además podemos importar más de un elemento de un paquete en una sola linea

Y por otro lado, se pueden "renombrar" a dar un alias a una clase importada

Así, ahora en lugar de usar Collection, podemos usar JavaCollection con el mismo efecto.

Por otro lado, como dentro de un archivo podemos tener varias clases, al declarar un import al nivel de archivo (arriba), estaríamos acoplando todas las clases a esa que importamos. Incluso si solo se utiliza para una única clase del paquete.

Por eso es que los imports se pueden ubicar en varios otros lugares, además del encabezado del archivo.

Se puede importar dentro de una clase:

 class Rocket {
    import Rocket.fuel
    def canGoHomeAgain = fuel > 20
  }

Más información sobre packages e imports en éste enlace externo

Temas avanzados

Definición de Objetos (en lugar de clases)

A diferencia de Java, en Scala no existen los métodos de clase o estáticos (static). Sin embargo posee la idea de definir "objetos" además (en lugar de) clases.

Como se ve acá Pepita es una objeto y no una clase.
Algunas cuestiones extra sobre estos objetos:

Tipos estructurales (aka ducktyping)

Scala posee la idea de "tipos estructurales". Es decir que además de poder definir un tipo mediante un nombre (por ejemplo, codificando una clase con el nombre Golondrina), podemos definir un tipo mediante su estructura. Por ejemplo definimos un tipo como "todos los objetos que entienden el mensaje volar"
Luego, podemos aplicar los tipos estructurales a cualquier elemento que tengamos que tipar, como una variable local, o un parámetro, o una atributo, etc.
Por ejemplo, 

Si queremos usar tipos nominales, para que el método "comé" pueda recibir objetos de cualquier clase, definidos como "que entiendan el mensaje 'energia'", quedaría así:

Fíjense que reemplazamos "Comida", por "{ def energia : Int }".
Podríamos requerir que entienda más de un mensaje, especificándolos entre las llaves.
Ahora podemos llamar a come, pasándole cualquier objeto que entienda ese mensaje, no importa su clase.
Lo interesante es que el lenguaje sigue haciendo el checkeo en tiempo de compilación.

Cómo crear una aplicación

Al no tener métodos estáticos la forma de hacer un "main" es con objetos, como sigue:Una variante a esto es crear un objeto que extienda de AppAcá estamos creando una lista con 3 elementos, los números 1, 2 y 3.
La variable lista se infiere al tipo List[Int], es decir lista de Int's.
Con esto vemos que scala también tiene tipos paramétricos (lo que en java llamamos "generics"), pero el símbolo que se usa son los corchetes y no el menor/mayor.Podríamos tener en otro caso, un valor (referencia inmutable) pero que apunta a un objeto mutable

Algunos métodos de las colecciones

El foreach es un método similar al "do" de Smalltalk, que permite ejecutar una lógica con cada uno de los elementos de la colección.
Para esto recibe como parámetro un "bloque" que opera con un elemento