English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Se prima eri un programmatore Java e conosci le basi del linguaggio, imparerai rapidamente la sintassi di base di Scala.
La differenza più grande tra Scala e Java è che il punto e virgola ';' alla fine delle istruzioni Scala è opzionale.
Possiamo considerare un programma Scala come una raccolta di oggetti, che si comunicano tra loro chiamando i loro metodi. Procediamo a comprendere i concetti di classe, oggetto, metodo e variabile di esempio:
Oggetto - Gli oggetti hanno attributi e comportamenti. Ad esempio: le caratteristiche di stato di un cane sono: colore, nome, i comportamenti includono: abbaire, correre, mangiare ecc. Un oggetto è un esempio di una classe.
Classe - La classe è l'astrazione dell'oggetto, mentre l'oggetto è l'esempio concreto della classe.
Metodo - Il comportamento base descritto dal metodo, una classe può contenere più metodi.
Campo - Ogni oggetto ha una sua unica raccolta di variabili di esempio, ovvero campi. Le proprietà dell'oggetto vengono create assegnando valori ai campi.
La programmazione interattiva non richiede la creazione di file di script e può essere chiamata con il seguente 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>Possiamo anche eseguire il codice creando un file HelloWorld.scala, il codice HelloWorld.scala è il seguente:
object HelloWorld {
/* Questo è il mio primo programma Scala
* Il seguente programma esibirà 'Hello World!'
*/
def main(args: Array[String]) {
println("Hello, mondo!") // Output: Hello World
}
}Successivamente, utilizziamo il comando scalac per compilare il file:
$ scalac HelloWorld.scala $ ls HelloWorld$.class HelloWorld.scala HelloWorld.class
Dopo la compilazione, possiamo vedere che nel directory è stato generato il file HelloWorld.class, che può essere eseguito sul Java Virtual Machine (JVM).
Dopo la compilazione, possiamo eseguire il programma con il seguente comando:
$ scala HelloWorld Hello, mondo!
Attenzione a questi punti fondamentali della sintassi di Scala:
Distinguere tra maiuscole e minuscole - Scala è sensibile alle maiuscole e minuscole, il che significa che Hello e hello hanno significati diversi in Scala.
Nome della classe - Tutti i nomi delle classi devono iniziare con una lettera maiuscola.
Se si desidera utilizzare più parole per formare il nome di una classe, la prima lettera di ogni parola deve essere maiuscola.
Esempio:class MyFirstScalaClass
Nome del metodo - Tutti i nomi dei metodi devono iniziare con una lettera minuscola.
Se più parole vengono utilizzate per costituire il nome del metodo, la lettera iniziale di ogni parola deve essere maiuscola.
Esempio:def myMethodName()
Nome del file del programma - Il nome del file del programma dovrebbe corrispondere esattamente al nome dell'oggetto (non è più obbligatorio nel nuovo versione, ma è consigliabile mantenere questa abitudine).
Quando si salva il file, dovrebbe essere salvato con il nome dell'oggetto utilizzato (ricorda che Scala è sensibile alle maiuscole e minuscole), e aggiungere '.scala' come estensione del file. (Se il nome del file e il nome dell'oggetto non corrispondono, il programma non può essere compilato).
Esempio: supponiamo che "HelloWorld" sia il nome dell'oggetto. Quindi il file dovrebbe essere salvato come 'HelloWorld.scala'
def main(args: Array[String]) - Il programma Scala inizia con il metodo main(), che è la parte obbligatoria di ingresso del programma per ogni programma Scala.
Scala può utilizzare due forme di simboli, numerici di carattere e simbolo.
Un simbolo numerico di carattere deve iniziare con una lettera o un underscore, può essere seguito da una lettera o un numero, il simbolo "$" è considerato come una lettera in Scala. Tuttavia, i simboli che iniziano con "$" sono riservati ai simboli generati dal compilatore Scala, le applicazioni dovrebbero evitare di utilizzare simboli che iniziano con "$" per evitare conflitti.
Le regole di nomi di Scala adottano un sistema di nomi camel simile a Java, con la lettera iniziale minuscola, ad esempio toString. La lettera iniziale del nome della classe deve essere maiuscola. Inoltre, è consigliabile evitare di utilizzare simboli di underscore alla fine del simbolo per evitare conflitti. I simboli di simbolo contengono uno o più simboli, come +, :, ? ecc., ad esempio:
+ ++ ::: < ?> :->
Scala utilizza simboli di escape durante l'esecuzione interna, ad esempio:-> viene rappresentato con $colon$minus$greater. Pertanto, se devi accedere al metodo :-> nel codice Java, devi utilizzare il nome interno di Scala $colon$minus$greater.
Un simbolo misto è composto da un simbolo numerico di carattere seguito da uno o più simboli, ad esempio unary_+ è il nome interno dell'esecuzione interna del metodo + in Scala. Un simbolo letterale è una stringa definita con virgolette, ad esempio `x` `yield`.
Puoi utilizzare qualsiasi simbolo legittimo di Scala tra virgolette quadre, Scala li interpreta come un simbolo legittimo, un uso tipico è il metodo yield di Thread. Non puoi usare Thread.yield() in Scala perché yield è una parola chiave di Scala, devi utilizzare Thread.`yield`() per utilizzare questo metodo.
La tabella seguente elenca le parole riservate di Scala, non possiamo utilizzare le seguenti parole come variabili:
| 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 | |
| - | : | = | => |
| <- | <: | <% | :>: |
| # | @ |
Scala supporta i commenti in riga singola e multiriga come Java. I commenti multiriga possono essere annessi, ma devono essere correttamente annessi, un simbolo di inizio di commento corrisponde a un simbolo di fine di commento. I commenti vengono ignorati durante la compilazione Scala, come nell'esempio seguente:
object HelloWorld {
/* Questo è un programma Scala
/* Questo è un commento in riga singola
/* Qui viene dimostrato un commento multiriga
*/
def main(args: Array[String]) {
// Output Hello World
// Questo è un commento in riga singola
println("Hello, world!")
}
}Se una riga contiene solo spazi o commenti, Scala la considera una riga vuota e la ignora. I tag possono essere separati da spazi o commenti.
Scala è un linguaggio orientato alla riga, le frasi possono essere terminate con un punto e virgola (;) o con un carattere di newline. Nei programmi Scala, il punto e virgola alla fine della frase è solitamente opzionale. Se lo si desidera, è possibile inserirlo, ma se una riga contiene solo C'è anche una frase che può essere omessa. D'altra parte, se ci sono più frasi in una riga, è necessario usare il punto e virgola. Ad esempio
val s = "基础教程网"; println(s)
Scala utilizza la parola chiave package per definire il pacchetto, ci sono due modi per definire il codice in un pacchetto in Scala:
Il primo metodo è simile a Java, definisce il nome del pacchetto all'inizio del file, e tutti i codici successivi vengono messi nel pacchetto. Ad esempio:
package com.w3codebox class HelloWorld
第二種方法有些類似 C#，如：
package com.w3codebox {
class HelloWorld
}第二種方法，可以在一個文件中定義多個包。
Scala 使用 import 关鍵字引用包。
import java.awt.Color // 導入Color
import java.awt._ // 導入了包內所有成員
def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent
... // 因為導入了java.awt，所以可以省去前面的部分
}import語句可以出現在任何地方，而不是只能在文件頂部。import的效應從開始延伸到語句塊的結束。這可以大幅減少名稱衝突的可能性。
如果想要導入包中的幾個成員，可以使用selector（選取器）：
import java.awt.{Color, Font}
// 重命名成員
import java.util.{HashMap => JavaHashMap}
// 隱藏成員
import java.util.{HashMap => _, _} // 導入了util包的所有成員，但是HashMap被隱藏了注意：默認情況下，Scala 永遠會引入 java.lang._ 、 scala._ 和 Predef._，這裡也能解釋，為什麼以scala開頭的包，在使用時都是省去scala.的。