乐趣区

关于scala:一Scala概述与基础语法

作者：

jiezi

在

一.Scala 概述

1.1 什么是Scala

Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种个性。

Scala 运行在 Java 虚拟机上，并兼容现有的 Java 程序。

Scala 源代码被编译成 Java 字节码，所以它能够运行于 JVM 之上，并能够调用现有的 Java 类库。

Scala官网 https://www.scala-lang.org/

1.2 装置

1.2.1 装置jdk(1.8以上版本)

略

1.2.2 装置Scala

在官网上下载，我这里是Ubuntu零碎，抉择版本为scala-2.12.11.tgz
装置很简略
1）解压文件
2）将解压后的目录搁置在指定目录

# 我这里是/usr/local 目录
mv scala-2.12.11 /usr/local/

3）配置环境变量
/etc/profile 追加如下内容

# set scala
export SCALA_HOME=/usr/local/scala-2.12.11
export PATH=${PATH}:${SCALA_HOME}/bin

执行source /etc/profile

4）测试下
如下显示，示意装置胜利

(base) zhaow@zhaow-610:~$ scala
Welcome to Scala 2.12.11 (Java HotSpot(TM) 64-Bit Server VM, Java 11.0.1).
Type in expressions for evaluation. Or try :help.
scala>

二.Scala 根本语法

2.1 第一个Scala程序 HelloWorld

学习编程语言，第一个入门程序，必然是HelloWorld.scala

object HelloWorld {
  def main(args: Array[String]): Unit = {
   // 打印HelloWorld
    println("Hello World!")
  }

}

而后进行编译

scalac HelloWorld.scala

编译之后生成两个文件,

HelloWorld.class
HelloWorld$.class

运行HelloWorld.class

scala HelloWorld

输入后果HelloWorld

2.2 正文

Scala正文与Java正文齐全一样

/**
 * 文档正文
 */
object HelloWorld {
  def main(args: Array[String]): Unit = {
    // 单行正文
    /*
     多行正文1
     多行正文2
     */
    println("Hello World!")
  }

}

2.3 标识符

Scala应用的标识符有两种模式：字符数字和符号

  • 字符数字应用字母或是下划线结尾，前面能够接字母或是数字，符号”$”在 Scala 中也看作为字母。然而以”$”结尾的标识符为保留的 Scala 编译器产生的标志符应用，应用程序应该防止应用”$”开始的标识符，免得造成抵触。
  • Scala 的命名规定采纳和 Java 相似的 camel 命名标准，首字符小写，比方 toString。类名的首字符还是应用大写。此外也应该防止应用以下划线结尾的标志符以防止抵触。
  • Scala 外部实现时会应用本义的标志符，比方:-> 应用 $colon$minus$greater 来示意这个符号。

代码示例

object Scala_Indentifier {
  def main(args: Array[String]): Unit = {
    // 默认状况下，scala标识符申明形式和java统一
    val name = "张三"
    val user_age = 14
    val address1 = "BJ"
    val _sex = "男"
    val $emain = "123@123.com"
//    val 1name = "张三" //谬误示范
//    val class = "张三" // 谬误示范

    // Scala 标识符能够应用符号进行申明，但常见语法操作的符号是不能应用的
    // 例如(),[],"",''
    val + = "张三"
    val - = "张三"
    val * = "张三"
    val / = "张三"
//    val ( = "张三" // error
    

  }

}

2.4 数据类型与类型转换

2.4.1 数据类型

Scala是齐全面向对象的语言，所以不存在根本数据类型的概念，有的只是任意值对象类型（AnyVal）和任意援用对象类型(AnyRef)
如下图所示

数据类型 形容
Byte 8位有符号补码整数。数值区间为 -128 到 127
Short 16位有符号补码整数。数值区间为 -32768 到 32767
Int 32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long 64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float 32位IEEE754单精度浮点数
Double 64位IEEE754单精度浮点数
Char 16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String 字符序列
Boolean true或false
Unit 示意无值，和其余语言中void等同。用作不返回任何后果的办法的后果类型。Unit只有一个实例值，写成()。
Null null 或空援用
Nothing Nothing类型在Scala的类层级的最低端；它是任何其余类型的子类型。
Any Any是所有其余类的超类
AnyRef AnyRef类是Scala里所有援用类(reference class)的基类

2.4.2 类型转换

1）主动类型转换

object ScalaDataType {
  def main(args: Array[String]): Unit = {
    // Scala 主动类型转换
    // 例如Byte类型和Short类型的主动转换
    val byte_num = 11
    val short_num = byte_num
    val i_num:Int = short_num
 

  }
}

2）强制类型转换

object ScalaDataType {
  def main(args: Array[String]): Unit = {

    // 将精度打的类型转换为精度小的类型
    // Scala中应用办法进行转换
    val i_num = 12
    val b_num = i_num.toByte
    // 基本上Scala的AnyVal类型之间都提供了相应转换的办法
  }
}

3）字符串类型转换
scala是齐全面向对象的语言，所有的类型都提供了toString办法，能够间接转换为字符串

2.5 变量

1）语法申明

object ScalaVariable {
  def main(args: Array[String]): Unit = {
    // 申明形式1 var 变量名:变量类型 = 变量值
    var name1:String = "张三"
    // 申明形式2 val 变量名:变量类型 = 变量值
    val name2:String = "张三"
    // var 和 val 申明形式不同之处
    // var 申明形式 变量能够批改，为可变变量
    name1 = "王五"
    // val 申明形式 变量不能够批改，为不可变变量
    name2 = "王五" // 谬误
  }
}

2）精简书写

object ScalaVariable {
  def main(args: Array[String]): Unit = {
    // 残缺申明规定
    val name1:String = "张三"
    // 其中数据类型能够不指定，这时候，则会进行数据类型的推断
    val name2 = "张三"
    println(name2.getClass.getSimpleName) // 输入后果为String
  }
}

3）总结

  • 申明变量时，数据类型能够指定，也能够不指定，如果不指定，那么就会进行数据类型的推断。
  • 如果指定数据类型，数据类型的执行 形式是 在变量名前面写一个冒号，而后写上数据类型。

  • scala外面变量的修饰符有两个，var和val。

    • 如果是var润饰的变量，那么这个变量的值是能够批改的。
    • 如果是val润饰的变量，那么这个变量的值是不能够批改的。

2.5 字符串

Scala中，字符串的类型实际上就是Java中的String
咱们从String的源码能够看到这一点

type String        = java.lang.String

String是不可变的字符串对象，不可被批改，这与Java统一，批改时，会产生一个新的字符串对象。

2.5.1 字符串连贯

object Scala_string {
  def main(args: Array[String]): Unit = {
    val name:String = "张三"
    val sex:String = "男"
    println(name+":"+sex)
  }
}

2.5.2 字符串传值

代码示例

object Scala_string {
  def main(args: Array[String]): Unit = {
    val name = "张三"
    // 应用printf格式化字符串
    printf("name=%s",name)
  }
}

2.5.3 字符串插值和多行字符串

代码示例

object Scala_string {
  def main(args: Array[String]): Unit = {
    // 字符串插值
    val name = "张三"
    println(s"name=$name")
    
    // 多行字符串格局，在封装SQL或者JSON比拟罕用
    // | 默认顶格符
    println(
      s"""
         |select
         |*
         |from
         |demo_tb
         |""".stripMargin)
    
    
  }
}

2.6 运算符

scala运算符的应用和Java运算符的应用基本相同，只是Scala中运算符实际上是办法。
示例

object ScalaOper {
  def main(args: Array[String]): Unit = {
    val i = 10
    // val j = i + 10 // 实际上执行的是办法
    val j = i.+(10)
    println(j)
  }

}

2.7 流程管制

2.7.1 分支语句

代码示例

object Scala_Flow {
  def main(args: Array[String]): Unit = {
    // 单分支
    val num = 91
    if(num>100){
      println("num 大于 100")
    }

    // 双分支
    if(num>100){
      println("num 大于 100")
    }else{
      println("num 不大于 100")
    }

    // 多分支
    if(num>100){
      println("num 大于 100")
    }else if(num > 90){
      println("num 大于 90 ，且小于等于100")
    }else{
      println("num....")
    }

  }
}

另外if条件表达式是有返回值的，返回值会依据条件表达式的状况主动进行数据类型推断
代码示例

object Scala_Flow {
  def main(args: Array[String]): Unit = {
    val age = 20
    val res = if(age > 20) 1 else 0
    println(res)
  }
}

2.7.2 循环语句

1）for循环

  • 根本语法
for ( 循环变量 <- 数据集 ) { // 这里的数据集能够是任意类型的数据汇合，如字符串，汇合，数组等
    循环体
}

代码示例

object Scala_Loop {
  def main(args: Array[String]): Unit = {
    // 示例1
    for(i <- Range(1,5)){ // 左闭右开，不蕴含5
      println("i========="+i)
    }
    // 示例2
    for(i <- 1 to 5){ // 蕴含5
      println("i=========="+i)
    }

    // 示例3
    for(i <- 1 until 5){ // 不蕴含5
      println("i======="+i)
    }

  }
}
  • 循环时减少条件判断

代码示例

object Scala_Loop {
  def main(args: Array[String]): Unit = {
    for(i <- Range(1,30) if (i%2)==0){
      println("i========"+i)
    }

  }
}
  • 循环步长
object Scala_Loop {
  def main(args: Array[String]): Unit = {
    for(i <- Range(1,10,2)){
      println("i=========="+i)
    }
    for(i <- 1 to 10 by 2){
      println("i========="+i)
    }

  }
}
  • for 循环推导
object Scala_Loop {
  def main(args: Array[String]): Unit = {
    // for 循环推导式:
    // 如果for训话中的循环体以yield开始，则该循环会构建一个汇合，每次迭代会生成汇合中的一个值
    val value = for(i <- 1 to 5) yield i * 20
    println(value)
  }
}

2）while循环

  • 根本语法
while( 循环条件表达式 ) {
    循环体
}
  • 代码示例
object Scala_Loop {
  def main(args: Array[String]): Unit = {
    var i = 0
    while (i < 5){
      println("i========="+i)
      i+=1
    }
  }
}

3）中断循环
Scala是齐全面向对象的语言，无奈应用break、continue这样的关键字。
Scala采纳函数式编程的形式代替了循环语法中的break
示例

import scala.util.control.Breaks

object Scala_Loop {
  def main(args: Array[String]): Unit = {
    Breaks.breakable{
      for(i <- 1 to 5){
        if( i==3 ){
          Breaks.break
        }
      }
    }
  }
}

也能够这样导包，简化书写

import scala.util.control.Breaks._

object Scala_Loop {
  def main(args: Array[String]): Unit = {
    breakable{
      for(i <- 1 to 5){
        if( i==3 ){
          break
        }
      }
    }
  }
}

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章