Conceptos básicos de Scala
Uno, construcción ambiental
Para la construcción del entorno Scala , consulte Construcción del entorno Scala + Instalación del complemento IDEA y creación del proyecto
2. Características
2.1, tipo estático
Scala no permite cambiar los tipos de variables después de la declaración, y los tipos de todas las variables y expresiones se determinan por completo en el momento de la compilación.
2.2, tipo fuerte
Scala generalmente no necesita mostrar el tipo especificado al declarar una variable, el compilador inferirá automáticamente el tipo .
No hay una conversión de tipo obligatoria en Scala, pero hay tres formas de reemplazarla:
- Nombre de objeto.asInstanceOf [XXX]
- Nombre de objeto.toXXX método
- Conversión implícita (palabra clave implícita)
2.3, programación de múltiples paradigmas
- Funciones orientadas a objetos
- Todos los valores en Scala son objetos
- Utilice objetos complementarios para simular objetos de clase y elimine la palabra clave estática (las propiedades estáticas y los métodos modificados por estático en Java no son objetos puros)
- No hay interfaz, en lugar de clases y rasgos; uso de rasgos para lograr una herencia múltiple mixta
-
Programación funcional
Todas las funciones son valores, por lo que puede usar funciones como parámetros y valores de retorno
Tres, tipo de datos
1. Tipo de valor (AnyVal)
(1) Almacene el valor directamente y almacene su valor en la pila
(2) Consistente con los ocho tipos básicos de Java (Byte, Short, Int, Long, Float, Double, Char, Boolean)
2. Tipo de referencia (AnyRef)
(1) Almacene la referencia a su valor, almacene la dirección en la pila y almacene el valor en el montón
(2) Lista, Opción, etc., la clase se ha personalizado
3. Literal: La forma de escribir valores constantes directamente en el código: 0, 0L, etc .; Símbolo literal: '<identificador>', correspondiente a scala.Symbol tipo
4. Tipos especiales:
(1) Nulo: todas las subclases de tipos de referencia, solo hay un objeto de instancia nulo y nulo es la palabra clave
(2) Nada: Lista () devuelve Lista [Nada]
(3) Unidad: solo un objeto de instancia " () ", un marcador de posición inútil, similar al vacío de Java. Todas las expresiones tienen un valor
Cuatro, gramática básica
4.1, constantes y variables
Variables: se pueden cambiar después de la asignación y se pueden asignar varias veces durante el ciclo de vida
var 变量名称:类型 = xxx
Constante: no se puede cambiar después de la asignación, similar a las variables finales en Java
val 常量名称:类型 = xxx
4.2, palabras clave
4.3. Notas
object HelloWorld {
/* 这是一个 Scala 程序
* 多行注释
*/
def main(args: Array[String]) {
// 单行注释
// 输出 Hello World
println("Hello, world!")
}
}
4.4, salto de línea
Scala es un lenguaje orientado a líneas.Las sentencias pueden terminar con un punto y coma (;) o un carácter de nueva línea. Si solo hay una declaración en una línea, el punto y coma es opcional; si escribe varias declaraciones en una línea, necesita un punto y coma
val s = "换行"; println(s)
Paquete de 4.5 、
Scala usa la palabra clave package para definir paquetes. Hay dos formas de definir el código en un paquete en Scala:
El primer método es el mismo que el de Java. El nombre del paquete se define en el encabezado del archivo. Este método coloca todos los códigos posteriores en el paquete
package scalatest
class HelloWorld
El segundo método, puede definir varios paquetes en un archivo
package scalatest {
class HelloWorld
}
4.6, paquete de referencia
Scala usa la palabra clave import para hacer referencia a paquetes
import java.awt.Color // 引入Color
import java.awt._ // 引入包内所有成员
def handler(evt: event.ActionEvent) {
// java.awt.event.ActionEvent
... // 因为引入了java.awt，所以可以省去前面的部分
}
La declaración de importación puede aparecer en cualquier lugar, no solo en la parte superior del archivo. El efecto de la importación se extiende desde el principio hasta el final del bloque de instrucciones. Esto puede reducir en gran medida la posibilidad de conflictos de nombres.
Si desea introducir varios miembros en el paquete, puede usar selector (selector)
import java.awt.{
Color, Font}
// 重命名成员
import java.util.{
HashMap => JavaHashMap}
// 隐藏成员
import java.util.{
HashMap => _, _} // 引入了util包的所有成员，但是HashMap被隐藏了
4.7, interpolación de cuerdas
- s interpolación de cadenas, use $ para hacer referencia a variables y expresiones
object Test {
def main(args: Array[String]): Unit = {
var name = "Kyrie Irving"
println(s"my name is $name")
println(s"1+1=${1+1}")
}
}
resultado
- f interpolación de cadenas, utilizada para formatear la salida
object Test {
def main(args: Array[String]): Unit = {
val name = "Kyrie"
val score = 57d
println(f"$name%s got $score%.1f points")
}
}
resultado
- Interpolación cruda, efectos de control de protección, como caracteres de escape.
object Test {
def main(args: Array[String]): Unit = {
println(s"a\nb")
println("----------")
println(raw"a\nb")
}
}
resultado
4.8. Control de condición
- si 和 si ... si no ...
val x = 10
if(x==10)println("x等于10")
println("------------")
if(x>10){
println("x大于10")
}else{
println("x小于等于10")
}
4.9, control de ciclo
- mientras que bucle
object Test {
def main(args: Array[String]): Unit = {
var a = 10
while(a>=8){
println(a)
a = a-1
}
}
}
- hacer ... mientras bucle
object Test {
def main(args: Array[String]): Unit = {
var a = 10
do{
println(a)
a = a + 1
}while(a<=13)
}
}
- en bucle
Las condiciones del ciclo hasta y hasta ambos representan el intervalo, el hasta antes del paquete y el después del paquete, el hasta antes del paquete y el después del paquete no están incluidos.
object Test {
def main(args: Array[String]): Unit = {
for(a <- 1 to 3){
print(a+"\t")
}
for(a <- 1 until 3){
print(a+"\t")
}
}
}
- para múltiples bucles: tabla de multiplicar de nueve a nueve
def main(args: Array[String]): Unit = {
for(i <- 1 to 9;j <- 1 to i){
print(s"$j*$i=${i*j}\t")
if(i==j)println()
}
}
- para filtrado de bucle
def main(args: Array[String]): Unit = {
for(i <- 1 to 10;if i%2==0;if i<9){
print(i+"\t")
}
}
- Interrupción de bucle
No hay una declaración de interrupción en el lenguaje Scala de forma predeterminada, y debe importar el paquete
import scala.util.control.Breaks._
La fuente sigue al
caso
import scala.util.control.Breaks._
for(elem <- 1 to 4){
print(6)
if(elem%3==0){
break()
}
}
- Valor de retorno del bucle
El rendimiento en el bucle for registrará el elemento actual y lo guardará en la colección, que se devolverá a la colección una vez que finalice el bucle. Para derivación
def main(args: Array[String]): Unit = {
var ret = for(i <- 1 to 10;if i%2==0;if i<9) yield i;
for(j <- ret){
print(j+"\t")
}
}
4.10, expresión de bloque
(1) Una expresión de bloque también es un resultado, la estructura de la última línea en {} es el resultado de la expresión de bloque
(2) Si la última línea es una declaración de asignación, es unidad ()
def main(args: Array[String]): Unit = {
val myblock = {
var x = 2
var y = 3
x+y
}
println(myblock)
}
val myblock = {
var x = 2
var y = 3
x = x+y
}
println(myblock)
Cinco, matrices, tuplas, colecciones
5.1, matriz
- Almacenar elementos de tamaño fijo
- El índice de matriz comienza desde 0
- Uso genérico corchetes []
- El acceso a la matriz usa paréntesis ()
5.2, tupla
- Puede contener diferentes tipos de elementos
- Admite hasta 22 elementos (Tuple1 ~ Tuple22)
- Excepto Tuple1, se pueden crear otros directamente con ()
- Utilice el guión bajo "_" para acceder al elemento, "_1" significa el primer elemento
5.3. Colección
1. Clasificación
- Seq: Secuencia, los elementos están ordenados (Lista)
- Set: set, los elementos no se repiten
- Map: Map, una colección de pares clave-valor
Todas las colecciones se heredan de Traversable, puede usar las funciones que contiene
2. Variable / inmutable
-
Colección
inmutable scala.collection.immutable, La colección inmutable está seleccionada en scala por defecto
-
Scala.collection de colección variable .mutable, Puede modificar, agregar o eliminar elementos de una colección
