Scala 学习记录（一）

1. 相对于java，scala的值修饰用val，变量修饰用var.值相当于java的final 修饰了。

package demo

object ScalaBase extends App {
  println(1)
  println(1 + 1)
  println("Hello！")
  println("Hello," + " World!")
  /**
    * val 是值得修饰符，相当于java的final int x;
    * scala 可以不指名类型
    */
  val x = 1 + 1
  println(x)
  ///x =2 //不编译的
 //指明类型可以如下写
  val x1 : Int = 1 + 1
  println(x1)

  /**
    * var 是变量修饰符，相当于java int x2,不加final修饰
    */
  var x2 = 1 + 1
  x2 = 3
  println(x2 * x2)

  /**
    * scala 是个万能表达式语言,比如可以通过{}组合表达式
    */
  println({
    val x = 1 + 1
    x + 1
  })
  println({
    val x = "test " + "scala "
    x + "demo!"
  })

  /**
    * scala相对于java 方法定义，分为函数和方法
    * 函数是带参数的表达式,也就是相对于java8的匿名方法（）->{}
    * (int x, int y) ->{}
    * 左边是参数，右边是表达式
    */
  (x: Int) => x + 1
  val addOne = (x: Int) => x + 1
  println(addOne(1))

  val add = (x: Int,y: Int) => x + y
  println(add(1,2))
  val getTheAnswer = () => 42
  println(getTheAnswer())

  /**
    * def 是方法关键字
    * def 后面是方法名
    * 与java不同的是，scala的返回类型是写在: Int
    * =后面就是方法体
    * 类似于java的 public int addMethod(int x, int y) {return x + y}
    * 注意：scala虽然有return保留字，一般都不用，scala用最后一行进行返回
    * @param x
    * @param y
    * @return
    */
  def addMethod (x: Int, y: Int): Int = x + y
  println(addMethod(1, 2))
  /**
    * 方法可以有多个参数
    * 相对于java，scala有多个参数类别，不用定义在同一（）里面，比较明显表明表达式结构
    */
  def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = {
    (x + y) * multiplier
  }

  /**
    * 当然scala也可以没有参数
    */
  def name: String = System.getProperty("name")
  println("Hello, " + name + "!")
  /**
    * scala 可以用{}使用多行表达式
    */
  def getSquareString(input: Double): String = {
    val square = input * input
    square.toString
  }

  println(getSquareString(2.22))

  /**
    * 类跟Java一样都是用class 关键字
    * 不同的是scala的参数可以定义在（）里面
    * 类似于Java的构造函数
    * 相对于java用void表示没有返回值，scala用 Unit
    */
  class Greeter(prefix: String, suffix: String) {
    def greet(name: String): Unit = println(prefix + name + suffix)
  }

  /**
    * scala 同样使用new 作为创建实例的关键字
    */
  val greeter = new Greeter("Hello,","!")
  greeter.greet("Scala developer")

  /**
    * case class 是一个非常特殊的类，它可以用于模式匹配
    * case class 可以不用new关键字
    * 它是一个public类
    * 它自动生成hashCode 、equals
    */
  case class Point(x: Int,y: Int)
  val point = Point(1, 2)
  val anotherPoint = Point(1, 2)
  val yetAnotherPoint = Point(2, 2)
  if (point == anotherPoint) {
    println(point + " and " + anotherPoint + " are the same.")
  } else {
    println(point + " and " + anotherPoint + " are different.")
  }
  // Point(1,2) and Point(1,2) are the same.

  if (point == yetAnotherPoint) {
    println(point + " and " + yetAnotherPoint + " are the same.")
  } else {
    println(point + " and " + yetAnotherPoint + " are different.")
  }

  /**
    * Objects 是一个单例，不能用new
    * 就像Java定义单例模式一样，它只有一个
    */
  object IdFactory {
    private var counter = 0
    def create(): Int = {
      counter += 1
      counter
    }
  }

  val newId: Int = IdFactory.create()
  println(newId)
  val newerId: Int = IdFactory.create()
  println(newerId)

  /**
    * Traits 类似于Java的Interface，只不过Traits可以部分实现
    * Java 只能通过default 进行部分实现，实现包内访问
    * trait 只用extends修饰，到不用实现
    */
  trait GreeterTrait {
    def greet(name: String): Unit
    def greetDefault(name: String): Unit =
      println("Hello, " + name + "!")
  }

  class DefaultGreeterTrait extends GreeterTrait {
    override def greet(name: String): Unit = {
      println()
    }
  }

  class CustomizableGreeter(prefix: String, postfix: String) extends GreeterTrait {
    override def greet(name: String): Unit = {
      println(prefix + name + postfix)
    }
  }

  val greeterTrait = new DefaultGreeterTrait()
  greeterTrait.greet("Scala developer")
  val customizableGreeter = new CustomizableGreeter("How are you","?")
  customizableGreeter.greet("Scala developer")

  /**
    * scala 是运行与jvm，因此也需要一个主要方法main,main也是一个字符串数组
    */
}

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