Sintaxis básica de Scala
Si antes eras programador de Java y conoces los fundamentos del lenguaje Java, podrás aprender rápidamente la sintaxis básica de Scala.
La mayor diferencia entre Scala y Java es que el punto y coma (;) al final de las sentencias en Scala es opcional.
Podemos considerar que un programa Scala es una colección de objetos que se comunican entre sí mediante la llamada a sus métodos. A continuación, entendamos los conceptos de clase, objeto, método y variable de instancia:
Objeto -Los objetos tienen atributos y comportamientos. Por ejemplo: los atributos de un perro son: color, nombre; los comportamientos son: ladrar, correr, comer, etc. Un objeto es una instancia de una clase.
Clase -Una clase es una abstracción de los objetos, mientras que un objeto es una instancia concreta de una clase.
Método -Un método describe comportamientos básicos; una clase puede contener múltiples métodos.
Campo -Cada objeto tiene su propio conjunto único de variables de instancia, es decir, los campos. Los atributos del objeto se crean asignando valores a los campos.
Primer programa en Scala
Programación interactiva
La programación interactiva no requiere crear archivos de script; se puede invocar mediante el siguiente comando:
$ scala
Welcome to Scala version 2.11.7 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_31).
Type in expressions to have them evaluated.
Type :help for more information.
scala> 1 + 1
res0: Int = 2
scala> println("Hello World!")
Hello World!
scala>
Forma de script
También podemos ejecutar código creando un archivo HelloWorld.scala. El código de HelloWorld.scala es el siguiente:
Código del archivo HelloWorld.scala:
/* Este es mi primer programa en Scala
* El siguiente programa imprimirá 'Hello World!'
*/
def main(args: Array[String]) = {
println("Hello, world!") // Imprime Hello World
}
}
A continuación, usamos el comando scalac para compilarlo:
$ scalac HelloWorld.scala $ ls HelloWorld$.class HelloWorld.scala HelloWorld.class
Después de compilar, podemos ver que se genera el archivo HelloWorld.class en el directorio; este archivo puede ejecutarse en la Máquina Virtual de Java (JVM).
Después de compilar, podemos usar el siguiente comando para ejecutar el programa:
$ scala HelloWorld Hello, world!
Sintaxis básica
Debes tener en cuenta los siguientes puntos sobre la sintaxis básica de Scala:
Sensibilidad a mayúsculas y minúsculas- Scala distingue entre mayúsculas y minúsculas, lo que significa que los identificadores Hello y hello tienen significados diferentes en Scala.
Nombre de clase- Para todos los nombres de clase, la primera letra debe estar en mayúscula.
Si se necesitan varias palabras para formar el nombre de una clase, la primera letra de cada palabra debe estar en mayúscula.
Ejemplo:class MyFirstScalaClassNombre del método- La primera letra de todos los nombres de método debe estar en minúscula.
Si se usan varias palabras para formar el nombre de un método, la primera letra de cada palabra debe estar en mayúscula.
Ejemplo:def myMethodName()Nombre del archivo del programa- El nombre del archivo del programa debe coincidir exactamente con el nombre del objeto (ya no es necesario en las versiones nuevas, pero se recomienda mantener este hábito).
Al guardar el archivo, debes guardarlo con el nombre del objeto que utiliza (recuerda que Scala distingue entre mayúsculas y minúsculas) y añadir ".scala" como extensión del archivo. (Si el nombre del archivo no coincide con el nombre del objeto, el programa no podrá compilarse).
Ejemplo: supongamos que "HelloWorld" es el nombre del objeto. Entonces el archivo debe guardarse como 'HelloWorld.scala".def main(args: Array[String]) - El programa Scala comienza a procesarse desde el método main(), que es la parte de entrada obligatoria de todo programa Scala.
Identificadores
Scala puede usar dos formas de identificadores: alfanuméricos y simbólicos.
Los identificadores alfanuméricos comienzan con una letra o un guion bajo, y pueden ir seguidos de letras o números. El símbolo "$" también se considera una letra en Scala. Sin embargo, los identificadores que comienzan con "$" están reservados para los identificadores generados por el compilador de Scala; las aplicaciones deben evitar usar identificadores que comiencen con "$" para evitar conflictos.
Las reglas de nomenclatura de Scala adoptan una convención de nombres camel similar a la de Java, con el primer carácter en minúscula, como toString. La primera letra de los nombres de clase se escribe en mayúscula. Además, se deben evitar los identificadores que terminen con guion bajo para evitar conflictos. Los identificadores simbólicos contienen uno o más símbolos, como +, :, ?, etc., por ejemplo:
+ ++ ::: < ?> :->
Internamente, Scala utiliza identificadores de escape, por ejemplo: -> se representa con $colon$minus$greater. Por lo tanto, si necesitas acceder al método :-> desde código Java, debes usar el nombre interno de Scala $colon$minus$greater.
Los identificadores mixtos se componen de un identificador alfanumérico seguido de uno o más símbolos, por ejemplo, unary_+ es el nombre que Scala usa internamente para el método +. Los identificadores literales son cadenas definidas con comillas invertidas, como `x` y `yield`.
Puedes usar cualquier identificador Scala válido entre comillas invertidas, y Scala lo interpretará como un identificador Scala. Un uso típico es el método yield de Thread. En Scala no puedes usar Thread.yield() porque yield es una palabra clave de Scala; debes usar Thread.`yield`() para utilizar este método.
Palabras clave de Scala
La siguiente tabla enumera las palabras clave reservadas de Scala; no podemos usar las siguientes palabras clave como variables:
| abstract | case | catch | class |
| def | do | else | extends |
| false | final | finally | for |
| forSome | if | implicit | import |
| lazy | match | new | null |
| object | override | package | private |
| protected | return | sealed | super |
| this | throw | trait | try |
| true | type | val | var |
| while | with | yield | |
| - | : | = | => |
| <- | <: | <% | >: |
| # | @ |
Comentarios en Scala
Scala, al igual que Java, admite comentarios de una sola línea y de varias líneas. Los comentarios de varias líneas pueden anidarse, pero deben anidarse correctamente: un símbolo de apertura de comentario corresponde a un símbolo de cierre. Los comentarios se ignoran durante la compilación en Scala. Ejemplo:
object HelloWorld {
/* 这是一个 Scala 程序
* 这是一行注释
* 这里演示了多行注释
*/
def main(args: Array[String]) {
// 输出 Hello World
// 这是一个单行注释
println("Hello, world!")
}
}
Líneas en blanco y espacios
Si una línea solo contiene espacios o comentarios, Scala la considera una línea en blanco y la ignora. Los tokens pueden separarse con espacios o comentarios.
Saltos de línea
Scala es un lenguaje orientado a líneas; las sentencias pueden terminar con un punto y coma (;) o con un salto de línea. En los programas Scala, el punto y coma al final de una sentencia suele ser opcional. Si lo deseas, puedes poner uno, pero si hay una sola sentencia en una línea, también puedes omitirlo. Por otro lado, si hay varias sentencias en una misma línea, entonces el punto y coma es necesario. Por ejemplo
val s = "Ejemplo"; println(s)
Paquetes en Scala
Definir paquetes
Scala usa la palabra clave package para definir paquetes. En Scala hay dos formas de definir código en un paquete:
El primer método es igual que en Java: definir el nombre del paquete en el encabezado del archivo; con este método, todo el código posterior se coloca en ese paquete. Por ejemplo:
package com.ejemplo class HelloWorld
El segundo método es algo similar a C#, como:
package com.ejemplo {
class HelloWorld
}
Con el segundo método, se pueden definir múltiples paquetes en un solo archivo.
Importación
Scala usa la palabra clave import para importar paquetes.
import java.awt.Color // 引入Color
import java.awt._ // 引入包内所有成员
def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent
... // 因为引入了java.awt,所以可以省去前面的部分
}
Las sentencias import pueden aparecer en cualquier lugar, no solo al principio del archivo. El efecto de import se extiende desde donde comienza hasta el final del bloque de sentencias. Esto puede reducir en gran medida la posibilidad de conflictos de nombres.
Si deseas importar varios miembros de un paquete, puedes usar un selector:
import java.awt.{Color, Font}
// 重命名成员
import java.util.{HashMap => JavaHashMap}
// 隐藏成员
import java.util.{HashMap => _, _} // 引入了util包的所有成员,但是HashMap被隐藏了
Otras extensionesNota:De forma predeterminada, Scala siempre importa java.lang._, scala._ y Predef._; esto también explica por qué los paquetes que comienzan con scala se usan omitiendo el prefijo scala.