一. 安装环境

wget https://downloads.lightbend.com/scala/2.12.6/scala-2.12.6.tgz

vi ~/.bash_profile

export PATH=$SCALA_HOME/bin:$PATH

 

二. 运行

Scala是解释性JVM语言，编译后会生成*.class。也可在交互式CLI上编码。



ling-Pro:~ sun$ scala
Welcome to Scala 2.12.4 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_102).

scala> var list = List(1,2,3)
list: List[Int] = List(1, 2, 3)

scala> println("hello world")
hello world



 

三. 示例

新的语言总会有一些奇怪的语法或表达式。

//import java.util._      // All
//import java.awt.{Color, Font}  // Part

/**
 * trait相当于Interface，但可有方法体，支持多重继承
 */
trait MyTrait {
  def show()
  def foo(){
    println("Hello foo")
  }
}

/// Impl
class MyTraitImpl extends MyTrait{
  def show(){
    println("Hello show")
  }
}


/// Objec
object Test {
  def init(): String = {
    println("Init var")
    return "kettas"
  }

  /**
   * 默认访问修饰符为 public
   * 测试返回多个元素(元组)
   * ReturnType = {}  比较奇怪
   */ 
  def getMulit(a: Int) : Tuple2[Int, String] = {
    return (a, "Hello")
  }

  // 测试类型
  def testType(){
    var mystr:String = "hello"  
    var myVar = 10    // 类型推断
    val myVar1 = "world"

    // lambda
    val f = (x: Int) => x+3
    Console.println(f(5))
  }

  // 测试for循环
  def testLoop(){
    var list = List(1,2,3,4,5,6)

    // foreach <-操作符
    for (a <- list)
    {
      Console.print(a + "\t")
    }

    // range
    for (a <- 1 to 10)
    {
      Console.print(a + "\t")
    }

    Console.println()
  }

  /**
   * 测试容器
   * Uint =  相当于 void, 可省略
   */
  def testContainer(): Unit = {
    val map: Map[Int, String] = Map(1 -> "hello", 2 -> "world")
    val v1: Option[String] = map.get(1)   // 可选值结构
    val v2: Option[String] = map.get(3)

    // Option vs Some
    println(v1)
    println("v1: " + v1.get)  // Some(hello) Some是一个类，通过some.get获取值
    println("v2: " + v2)  // None

    // 获取元组
    val tuple = getMulit(5)
    println(tuple._1)
    println(tuple._2)

    // ++操作符，用于连接两集合
    val l1 = List(1, 2)
    var l2 = List(3, 4)
    var l5 = l1 ++ l2 // (1,2,3,4)

    // 可变容器，链表实现
    val buf = collection.mutable.ListBuffer.empty[Int]
    buf += 1
    buf += 10 
    println(buf.toList) // 1,10
  }

  /**
   * lazy关键字使用
   * 借鉴懒汉式单例模式实现思想，使用变量时才初始化
   *
   */
  def testLazy(){
    lazy val a = init();
    println("After init")
    println(a)    // After init; Init var; kettas
  }

  // main
  def main(args: Array[String]){
    // 基本类型测试
    testType()

    // 循环测试
    testLoop()

    // 容器测试
    testContainer()

    // 懒加载
    testLazy()

    // 测试类
    val p = new MyTraitImpl()
    p.show()
  }
}

 

 四. 其它语法

4.1 App

App 类连main方法都封装了，不过采用延迟加载方式。



object HelloScala extends App { println("Hello scala!") }



 运行输出：Hello scala!

 

4.2 case语法

 1. case match

与java switch语法类似，新增=>操作分隔模式和表达式。



def matchTest(x: Int): String = x match {
  case 1 => "one"
  case 2 => "two"
  case _ => "many"
}

println( matchTest(1) )   // one


 

2. case class



// case类默认不可变，可通过模式匹配分解
case class Person(name: String, age: Int)

val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("Charlie", 32)

// 遍历用户列表
for (person <- List(alice, bob, charlie)) {
  person match {
    case Person("Alice", 25) => println("Hi Alice!")
    case Person("Bob", 32) => println("Hi Bob!")
    case Person(name, age) =>
       println("Age: " + age + " year, name: " + name + "?")
  }
}


输出： 

Hi Alice!

Hi Bob!

Age: 32 year, name: Charlie?

 

五. Akka框架

Akka 是一组构建高并发，分布式，弹性消息驱动应用工具库，便于构建JVM的并发应用和分布式应用，支持java/scala。

 

基础示例：



import akka.actor._
import akka.util._
 
/** Simple hello from an actor in Scala. */
object Hello1 extends App {
  // 配置 
  val system = ActorSystem("actor-demo-scala")
  val hello = system.actorOf(Props[Hello])

  hello ! "Bob"   // ! 运算符是 Akka 中表示将一条消息发送到 actor 的便捷方式
  Thread sleep 1000
  system shutdown
  
  // 接收器 
  class Hello extends Actor {
    def receive = {
      case name: String => println(s"Hello $name")   // s 字符串插值器
    }
  }
}



 

 

 

 

参考：

​​https://akka.io​​