基础

文档地址

1. Scala中不需要“;”结尾

目录结构

- project // 项目配置，插件配置
- src // 源码相关
- build.sbt // 项目依赖配置相关，通过sbt管理

变量 vs 常量

@main
def main(): Unit = {
  val num: Int = 10 // 常量，不可更改
  //  num = 10 // 常量不可以修改值
  var value:Int = 10 // 定义变量
  value = 11 // 变量可用重新赋值
  println(s"Hello world! $num")

}

代码块

表达式！！！

@main
def main(): Unit = {
  val num = {
    val value = 10
    value * value // 代码块中最后一个“表达式”的结果为代码块的结果
  }
  println(s"num is: $num")

}

函数

函数是带有参数的表达式。

分为：匿名函数、具名函数

@main
def main(): Unit = {
  // 匿名： (x:Int) => x * x
  // 具名： val power = (x:Int) => x * x
  val power = (x:Int) => x * x
  println(s"func is: $power") // func is: main$package$$$Lambda$16/0x000002cade0023f0@58ceff1
}

方法

通过def 来定义 “方法”。方法和函数类似。方法体的最后一个表达式就是方法的返回值

// 定义方法格式： def funName(params1:Type1)(param2:Type2):ReturnType = statements or code block
//
def helloWorld(name:String): Unit = {
  println(s"hello,world! => $name")
}
// 方法可用直接跟方法体，也可以跟{}

def power(num:Int):Int = num * num

类

使用class定义类。对于方法如果没有返回值，类似于“void”，需要使用Unit接。Scala里表达式必须有值。

@main
def main(): Unit = {
  val stu = Student("jonny",19)
  stu.print()
}
// 定义class： class className(constructor) {}
class Student(name:String,age:Int){
  def print(): Unit = {
    println(s"student[name=$name,age=$age]")
  }
}

进阶内容

@main
def main(): Unit = {
  val point = Point(x = 10,y = 2)
  // point.x = 11 // x 因为val修饰无法更改
  point.y = 20
  val addr = Address()
  addr.province = "四川"
}

/**
 * Scala中的类是用于创建对象的蓝图，
 * 其中包含了方法、常量、变量、类型、对象、特质、类，这些统称为成员。
 */

/**
 * 通过构造方法 实现 成员变量定义
 * @param x 通过val进行修饰，不可更改
 * @param y 通过var进行修饰，可以更改值
 * @param z 没有val、var修饰，外部无法访问，相当于私有。同时设置有默认值
 */
class Point(val x:Int,var y:Int,z:Int = 0){
  private val sum = x * y * z
}

/**
 * 定义无参构造方法，自定义私有变量、setter、getter方法
 */
class Address{
  // 通过private 定义私有属性，同时规则私有属性以“_”开始
  private var _province = ""
  private var _city = ""

  // 定义属性的getter方法，直接返回值
  def province: String = _province
  // 定义属性的setter方法。通过 “_=”特殊语法实现。
  def province_= (province:String): Unit = {
    println(s"modify province with $province")
    _province = province
  }
  def city:String = _city
  def city_= (city:String):Unit = {
    _city = city
  }
}

样例类

默认情况下，样例类一般由于不可变对象，并且值可比较。通过使用case class进行定义。类似于DDD的值对象value object。

@main
def main(): Unit = {
  val p0 = Point(0,0)
  val p1 = Point(1,1)
  // 样例类可以进行比较
  if(p0 == p1){
    println("p0 equals p1")
  }else{
    println("p0 not equals p1")
  }
}
// 通过case class进行定义
case class Point(x:Int,y:Int)

对象

对象是它们自己定义的单实例，你可以把它看作它自己的类的单例（换句话说，也就是定义一个对象就相当于定义了一个该类的唯一单例对象）。

可以直接通过名字访问对象。

@main
def main(): Unit = {
  // 不能进行实例化 China()
  China.good() // 定义的方法直接通过 对象就可以调用
  IdFactory.generate()
}
object China {
  def good(): Unit = {
    println("china is No.1")
  }
}
object IdFactory{
  def generate():Long = {
    System.currentTimeMillis()
  }
}

特征

特征是包含某些字段和方法的类型。可以组合多个特征。

@main
def main(): Unit = {
  val stu = Student("jonny")
  stu.greet()
}
trait Greeter{
  // train可以定义 方法定义 也可以 提供 默认实现
  def greet():Unit = {
    println("default greet")
  }
}

/**
 * class 可以继承多个特征
 * Student 继承了 Greeter 特征。并实现了对应的方法
 * @param name name
 */
class Student(name:String) extends Greeter {
  override def greet(): Unit = {
    super.greet()
    println(s"my name is $name")
  }
}

主方法

JVM需要一个main方法。有一个字符串数组的参数。

object Main {
  def main(args: Array[String]): Unit =
    println("Hello, Scala developer!")
}