Sintaxis básica de Scala

Si anteriormente eras un programador Java y conoces los fundamentos del lenguaje Java, entonces aprenderás rápidamente la sintaxis básica de Scala.

La principal diferencia entre Scala y Java es que el punto y coma ; al final de las instrucciones Scala es opcional.

Podemos considerar que los programas Scala son conjuntos de objetos, que realizan la comunicación de mensajes mediante la invocación de métodos entre sí. A continuación, intentemos entender los conceptos de clase, objeto, método y variable de ejemplo:

• Objeto - Los objetos tienen propiedades y comportamientos. Por ejemplo: las propiedades del estado de un perro son: color, nombre, los comportamientos son: ladrar, correr, comer, etc. El objeto es un ejemplo de una clase.

• Clase - La clase es una abstracción del objeto, y el objeto es un ejemplo específico de la clase.

• Método - La descripción básica del comportamiento de un método, una clase puede contener varios métodos.

• Campo - Cada objeto tiene una colección única de variables de ejemplo, es decir, campos. Las propiedades del objeto se crean asignando valores a los campos.

El primer programa Scala

Programación interactiva

La programación interactiva no requiere crear un archivo de script, se puede llamar con el siguiente comando:

$ scala
Bienvenido a la versión Scala　2.11.7　(Java HotSpot(TM)　64-Bit Server VM, Java　1.8.0_31.
Escribe expresiones para que se evalúen.
Tipo: ayuda para obtener más información.
scala>　1　+　1
res0: Int =　2
scala> println("Hello World!")
Hello World!
scala>

Forma de script

También podemos ejecutar el código creando un archivo HelloWorld.scala, el código HelloWorld.scala es el siguiente:

object HelloWorld {
　　　/*　Este es mi primer programa Scala
　　　　*　El siguiente programa mostrará 'Hello World!'　
　　　　*/
　　　def main(args: Array[String]) {
　　　　　　println("Hello, world!")　//　Imprimir Hello World
　　　}
}

A continuación, usaremos el comando scalac para compilarlo:

$ scalac HelloWorld.scala　
$ ls
HelloWorld$.class　　　　HelloWorld.scala
HelloWorld.class

Después de la compilación, podemos ver que se ha generado el archivo HelloWorld.class en el directorio, que se puede ejecutar en el Java Virtual Machine (JVM).

Después de la compilación, podemos usar el siguiente comando para ejecutar el programa:

$ scala HelloWorld
Hello, mundo!

Ejemplo en línea »

Sintaxis básica

Al escribir la sintaxis básica de Scala, hay varios puntos que deben tenerse en cuenta:

• Diferenciación de mayúsculas y minúsculas - 　Scala es sensible a mayúsculas y minúsculas, lo que significa que Hello y hello tienen significados diferentes en Scala.

• Nombre de la clase -　La primera letra de todos los nombres de clase debe estar en mayúscula.
  Si se necesita usar varias palabras para formar el nombre de una clase, la primera letra de cada palabra debe estar en mayúscula.
  
  Ejemplo:class MyFirstScalaClass

• Nombre del método - El primer carácter de todos los nombres de métodos debe estar en minúscula.
  Si varias palabras se utilizan para formar el nombre del método, cada palabra debe comenzar con una letra mayúscula.
  
  Ejemplo:def myMethodName()

• Nombre del archivo del programa - El nombre del archivo del programa debe coincidir completamente con el nombre del objeto (ya no es necesario en las versiones más recientes, pero se recomienda mantener este hábito).
  Al guardar el archivo, debe guardarlo con el nombre del objeto que utiliza (recuerda que Scala es sensible a mayúsculas y minúsculas), y agregar ".scala" como extensión de archivo. (Si el nombre del archivo y el nombre del objeto no coinciden, el programa no se puede compilar).
  
  Ejemplo: Supongamos que "HelloWorld" es el nombre del objeto. Entonces, este 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 obligatoria de entrada de cada programa Scala.

Identificador

Scala puede usar dos formas de identificadores, los identificadores de carácter numérico y los identificadores de símbolo.

Los identificadores de carácter numérico comienzan con una letra o guión bajo, pueden estar seguidos de letras o números, el símbolo "$" también se considera una letra en Scala. Sin embargo, los identificadores que comienzan con "$" son identificadores reservados generados por el compilador de Scala, las aplicaciones deben evitar usar identificadores que comienzan con "$" para evitar conflictos.

Las reglas de nombres de Scala adoptan un estilo de nomenclatura camel similar a Java, con la primera letra en minúscula, por ejemplo toString. La primera letra del nombre de la clase sigue siendo mayúscula. Además, también se debe evitar usar identificadores que terminan con guiones bajos para evitar conflictos. Los identificadores de símbolo contienen uno o más símbolos, como+，:，? y otros, por ejemplo:

+　++　:::　<　?>　:->

Scala utiliza identificadores escapados en su implementación interna, por ejemplo:-Usa $colon$minus$greater para representar este símbolo. Por lo tanto, si necesitas acceder en código Java:-Método, necesitas usar el nombre interno de Scala $colon$minus$greater.

Los identificadores compuestos consisten en un identificador de carácter numérico seguido de uno o más símbolos, por ejemplo unary_+ Para Scala,+El nombre dentro de la implementación del método. Los identificadores literales son cadenas definidas por "", como `x` `yield`.

Puedes usar cualquier identificador válido de Scala entre "", Scala los interpreta como un identificador de 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 usar este método.

Palabras clave Scala

La siguiente tabla enumera las palabras clave reservadas de scala, no podemos usar las siguientes palabras clave como variables:

Comentarios Scala

Scala, al igual que Java, admite comentarios en una sola línea y multilinea. Los comentarios multilinea pueden anidarse, pero deben anidarse correctamente, un símbolo de inicio de comentario debe coincidir con un símbolo de finalización. Los comentarios se ignoran en la compilación de Scala, ejemplo a continuación:

object HelloWorld {
　　　/*　Este es un programa Scala
　　　　*　Este es un comentario en una línea
　　　　*　Aquí se muestra un comentario multilinea
　　　　*/
　　　def main(args: Array[String]) {
　　　　　　//　Imprimir Hello World
　　　　　　//　Este es un comentario en una sola línea
　　　　　　println("Hello, world!")　
　　　}
}

Líneas en blanco y espacios

Si una línea solo contiene espacios o comentarios, Scala lo considera una línea en blanco y la ignora. Los comentarios pueden ser separados por espacios o comentarios.

Salto de línea

Scala es un lenguaje orientado a la línea, las declaraciones pueden terminar con un punto y coma (;) o con un salto de línea. En el programa Scala, el punto y coma al final de la declaración es opcional. Si lo deseas, puedes introducir uno, pero si hay solo Hay una declaración que también se puede omitir. Por otro lado, si se escriben múltiples declaraciones en una línea, se necesita un punto y coma. Por ejemplo

val s = "基础教程网"; println(s)

Paquete Scala

Definir el paquete

Scala utiliza la palabra clave package para definir el paquete, en Scala hay dos formas de definir el código en un paquete:

El primer método es igual que Java, define el nombre del paquete en la cabeza del archivo, y todos los códigos posteriores se colocan en este paquete. Por ejemplo:

package com.w3codebox
class HelloWorld

El segundo método es similar a C#, como:

package com.w3codebox {
　　class HelloWorld　
}

El segundo método es definir múltiples paquetes en un archivo.

Referencia

Scala utiliza la palabra clave import para referirse a los paquetes.

import java.awt.Color　　//　Importar Color
　
import java.awt._　　//　Importar todos los miembros del paquete
　
def handler(evt: event.ActionEvent) {　//　java.awt.event.ActionEvent
　　...　　//　Porque se importó java.awt, se puede omitir la parte anterior
}

Las declaraciones import pueden aparecer en cualquier lugar, no solo en la parte superior del archivo. El efecto de import se extiende desde el principio hasta el final del bloque de instrucciones. Esto puede reducir significativamente la posibilidad de conflictos de nombres.

Si desea importar varios miembros del paquete, puede usar selector (seleccionador):

import java.awt.{Color, Font}
　
//　Renombrar miembros
import java.util.{HashMap => JavaHashMap}
　
//　Miembros ocultos
import java.util.{HashMap => _, _}　//　Se importaron todos los miembros del paquete util, pero HashMap se ocultó

Nota:Por defecto, Scala siempre importa java.lang._, scala._ y Predef._, aquí también se explica por qué los paquetes que comienzan con scala. siempre dejan fuera scala. al usarlos.