Sintaxe Básica do Scala

Se você já foi um programador Java e conhece as bases do linguagem, você pode aprender rapidamente a sintaxe básica do Scala.

A maior diferença entre Scala e Java é que o ponto e vírgula ; no final das instruções Scala é opcional.

Podemos considerar que os programas Scala são conjuntos de objetos, que realizam a comunicação por meio de chamadas de métodos. Vamos entender os conceitos de classe, objeto, método e variável de exemplo a seguir:

• Objeto - O objeto tem propriedades e comportamentos. Por exemplo: as propriedades físicas de um cachorro incluem: cor, nome; os comportamentos incluem: latir, correr, comer, etc. O objeto é um exemplo da classe.

• Classe - A classe é a abstração do objeto, e o objeto é a exemplo específico da classe.

• Método - A descrição básica do comportamento dos métodos, uma classe pode conter vários métodos.

• Campo - Cada objeto tem uma coleção única de variáveis de exemplo, ou seja, campos. As propriedades do objeto são criadas atribuindo valores aos campos.

Primeiro programa Scala

Programação interativa

Programação interativa não requer a criação de arquivos de script, e pode ser chamada usando o seguinte comando:

$ scala
Bem-vindo à versão Scala　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

Também podemos executar o código criando um arquivo HelloWorld.scala, cujo código é o seguinte:

object HelloWorld {
　　　/*　Este é meu primeiro programa Scala
　　　　*　O seguinte programa imprimirá 'Hello World!'.　
　　　　*/
　　　def main(args: Array[String]) {
　　　　　　println("Hello, world!")　//　Saída Hello World
　　　}
}

A seguir, usaremos o comando scalac para compilar:

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

Após a compilação, podemos ver que foi gerado o arquivo HelloWorld.class no diretório, que pode ser executado no Java Virtual Machine (JVM).

Após a compilação, podemos usar o seguinte comando para executar o programa:

$ scala HelloWorld
Hello, world!

Exemplo online »

Gramática básica

A gramática básica do Scala deve ser levada em consideração nos seguintes pontos:

• Diferenciação de maiúsculas e minúsculas - 　O Scala é sensível a maiúsculas e minúsculas, o que significa que Hello e hello terão significados diferentes no Scala.

• Nome da classe -　Para todos os nomes das classes, a primeira letra deve ser maiúscula.
  Se precisar usar várias palavras para formar o nome de uma classe, a primeira letra de cada palavra deve ser maiúscula.
  
  Exemplo:class MyFirstScalaClass

• Nome do método - O primeiro caractere de todos os nomes dos métodos deve ser minúsculo.
  Se várias palavras forem usadas para constituir o nome do método, a primeira letra de cada palavra deve ser maiúscula.
  
  Exemplo:def myMethodName()

• Nome do arquivo do programa - O nome do arquivo do programa deve coincidir completamente com o nome do objeto (não é mais necessário na nova versão, mas é recomendado manter esse hábito).
  Ao salvar o arquivo, deve-se salvar o nome do objeto que ele usa (lembrar que Scala é case-sensitive), e adicionar ".scala" como extensão do arquivo. (Se o nome do arquivo e o nome do objeto não coincidirem, o programa não compilará).
  
  Exemplo: Suponha que "HelloWorld" seja o nome do objeto. Então, o arquivo deve ser salvo como 'HelloWorld.scala'

• def main(args: Array[String]) -　O programa Scala começa a ser processado pelo método main(), que é a parte de entrada obrigatória de qualquer programa Scala.

Identificador

O Scala pode usar dois tipos de identificadores, o identificador numérico e o identificador de símbolo.

O identificador numérico começa com uma letra ou sublinhado, seguido por letras ou números, o símbolo "$" também é considerado uma letra no Scala. No entanto, os identificadores que começam com "$" são identificadores reservados gerados pelo compilador Scala, os aplicativos devem evitar usar identificadores que começam com "$" para evitar conflitos.

As regras de nomeação do Scala adotam um estilo camel case semelhante ao Java, com a primeira letra em minúscula, por exemplo toString. A primeira letra do nome da classe ainda é maiúscula. Além disso, também deve evitar usar identificadores que terminam com um traço para evitar conflitos. O identificador de símbolo contém um ou mais símbolos, como+，:，? 等, por exemplo:

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

A implementação interna do Scala usará identificadores escapados, por exemplo:-Para representar esse símbolo, use $colon$minus$greater. Portanto, se precisar acessar em código Java:-Método, você precisa usar o nome interno $colon$minus$greater do Scala.

O identificador misto é composto por um identificador numérico seguido de um ou mais símbolos, por exemplo unary_+ Para Scala,+O nome interno da implementação do método. O identificador literal é uma string definida por "", por exemplo `x` `yield`.

Você pode usar qualquer identificador válido de Scala entre "", Scala os interpreta como um identificador de Scala. Uma utilização típica é o método yield da Thread, em Scala você não pode usar Thread.yield() porque yield é uma palavra-chave de Scala, você deve usar Thread.`yield`() para usar esse método.

Palavras-chave Scala

A tabela a seguir lista as palavras-chave reservadas do Scala, que não podem ser usadas como nomes de variáveis:

Comentários Scala

O Scala, como o Java, suporta comentários em linha e em múltiplas linhas. Os comentários em múltiplas linhas podem ser aninhados, mas devem ser aninhados corretamente, com um símbolo de início de comentário correspondendo a um símbolo de fim de comentário. Os comentários são ignorados durante a compilação Scala, como no exemplo a seguir:

object HelloWorld {
　　　/*　Este é um programa Scala
　　　　*　Este é um comentário em linha
　　　　*　Aqui está um exemplo de comentário em múltiplas linhas
　　　　*/
　　　def main(args: Array[String]) {
　　　　　　//　Saída Hello World
　　　　　　//　Este é um comentário em linha
　　　　　　println("Hello, world!")　
　　　}
}

Linhas em branco e espaços

Se uma linha contiver apenas espaços ou comentários, o Scala considera-a uma linha em branco e a ignora. Os marcadores podem ser separados por espaços ou comentários.

Caractere de nova linha

O Scala é uma linguagem orientada a linha, onde as declarações podem ser encerradas com um ponto-e-vírgula (;) ou com um caractere de nova linha. No programa Scala, o ponto-e-vírgula no final da declaração é opcional. Se você quiser, pode inserir um, mas se apenas Há uma declaração que pode não ser escrita. Por outro lado, se várias declarações forem escritas em uma linha, o ponto-e-vírgula é necessário. Por exemplo

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

Pacote Scala

Definição de pacote

O Scala usa a palavra-chave 'package' para definir pacotes, e há duas maneiras de definir códigos em um pacote no Scala:

O primeiro método é semelhante ao Java, onde o nome do pacote é definido no cabeçalho do arquivo, e todos os códigos subsequentes são colocados dentro desse pacote. Por exemplo:

package com.w3codebox
class HelloWorld

A segunda maneira é semelhante ao C#:

package com.w3codebox {
　　class HelloWorld　
}

Segunda maneira, você pode definir vários pacotes em um único arquivo.

Referência

O Scala usa a palavra-chave import para referenciar pacotes.

import java.awt.Color　　//　Importar Color
　
import java.awt._　　//　Importar todos os membros do pacote
　
def handler(evt: event.ActionEvent) {　//　java.awt.event.ActionEvent
　　...　　//　Porque foi importado java.awt, a parte anterior pode ser omitida
}

As instruções import podem aparecer em qualquer lugar, não apenas no topo do arquivo. O efeito do import se estende até o final do bloco de instruções. Isso pode reduzir significativamente a probabilidade de conflitos de nomes.

Se quiser importar alguns membros do pacote, você pode usar o selector (seletor):

import java.awt.{Color, Font}
　
//　Renomear Membro
import java.util.{HashMap => JavaHashMap}
　
//　Membro Oculto
import java.util.{HashMap => _, _}　//　Todos os membros do pacote util foram importados, mas o HashMap foi oculto

Atenção:Por padrão, o Scala sempre importa java.lang._, scala._ e Predef._, isso também explica por que os pacotes começando com scala. são omitidos no uso.