Scala学习（变量和数据类型、流程控制）

变量和数据类型

注释

package learn02
object demo01 {
  def main(args: Array[String]): Unit = {
    //单行注释
    /*
    多行注释
     */
    /**
     * 文档注释
     */
  }
}

变量

package learn02
object demo02 {
  def main(args: Array[String]): Unit = {
    val name//错误，必须显示进行初始化操作
    val name: String = "xwk" //不可变变量
    name = "stefan" //错误，值不可改变
    var age: Int = 21 //可变变量
    age = 22
    age = "abc" //错误，值可以改变，类型不可变
  }
}

字符串

package learn02
object demo03 {
  def main(args: Array[String]): Unit = {
    val name : String="xwk"
    //字符串连接
    println("hello "+name)
    //传值字符串(格式化字符串)
    printf("my name is %s\n",name)
    //插值字符串
    println(s"my name is ${name}")
    //多行字符串
    println(
      s"""
         |Hello
         | ${name}
         |""".stripMargin
    )
  }
}

输入输出

package learn02
import java.io.{File, PrintWriter}
object demo04 {
  def main(args: Array[String]): Unit = {
    //标准化屏幕输入
    println("请输入您的年龄:")
    val age:Int=scala.io.StdIn.readInt()
    println("您的年龄为:"+age)

    //从文件中获取输入
    scala.io.Source.fromFile("./src/learn02/users.txt").foreach(
      line=>{
        print(line)
      }
    )
    scala.io.Source.fromFile("./src/learn02/users.txt").getLines()

    //输出，文件写操作
    val writer=new PrintWriter(new File("./src/learn02/test.txt"))
    writer.write("Hello Scala")
    writer.close()
  }
}

Scala进行网络数据交互时，采用的是 java中的I/O类
先运行demo05_TestServer再运行demo05_TestClient，然后demo05_TestServer会显示输出内容，结束掉程序即可。

package learn02
import java.io.{BufferedReader, InputStreamReader}
import java.net.{ServerSocket, Socket}
object demo05_TestServer {
  def main(args: Array[String]): Unit = {
    val server=new ServerSocket(9999)
    while(true){
      val socket:Socket=server.accept()
      val reader=new BufferedReader(
        new InputStreamReader(
          socket.getInputStream,
          "UTF-8"
        )
      )
      var s:String=""
      var flg=true
      while(flg){
        s=reader.readLine()
        if(s!=null){
          println(s)
        }else{
          flg=false
        }
      }
    }
  }
}

package learn02
import java.io.{OutputStreamWriter, PrintWriter}
import java.net.Socket
object demo05_TestClient {
  def main(args: Array[String]): Unit = {
    val client=new Socket("localhost",9999)
    val out=new PrintWriter(
      new OutputStreamWriter(
        client.getOutputStream,
        "UTF-8"
      )
    )
    out.print("Hello Scala")
    out.flush()
    out.close()
    client.close()
  }
}

数据类型

从图中可以看出，Any是所有类型的超类型，也称为顶级类型，它包含两个直接子类，具体如下：
1.AnyVal：表示值类型，值类型描述的数据是一个不为空的值，而不是一个对象。它预定义了9种类型，分别是Double、Float、Long、Int、Short、Byte、Unit、Char和Boolean。其中，Unit是一种不代表任何意义的值类型，它的作用类似Java中的void。
2.AnyRef：表示引用类型。可以认为，除值类型外，所有类型都继承自AnyRef。

​在Scala数据类型层级结构的底部，还有两个数据类型，分别是Nothing和Null，具体介绍如下：
1.Nothing：所有类型的子类型，也称为底部类型。它常见的用途是发出终止信号，例如抛出异常、程序退出或无限循环。
2.Null：所有引用类型的子类型，它主要用途是与其他JVM语言互操作，几乎不在Scala代码中使用。

类型转换

package learn02
object demo06 {
  def main(args: Array[String]): Unit = {
    //自动类型转化（隐式转换）
    val b:Byte=10
    val s:Short=b
    val i:Int=s
    val lon:Long=i
    println(lon)

    //强制类型转化
    /*
    java语言
    int a=10
    byte b=(byte)a
     */
    var n1:Int=10
    var n2:Byte=n1.toByte

    //字符串类型转化
    var n3:Long=10
    println("num "+n3)
    n3.toString//scala是完全面向对象的语言，所有的类型都提供了toString方法，可以直接转换为字符串
    println("num "+n3)//任意类型都提供了和字符串进行拼接的方法
  }
}

标识符

Scala 可以使用两种形式的标志符，字符数字和符号。
	字符数字使用字母或是下划线开头，后面可以接字母或是数字，符号"$"在 Scala 中也看作为字母。然而以"$"开头的标识符为保留的 Scala 编译器产生的标志符使用，应用程序应该避免使用"$"开始的标识符，以免造成冲突。
	Scala 的命名规范采用和 Java 类似的 camel 命名规范，首字符小写，比如 toString。类名的首字符还是使用大写。此外也应该避免使用以下划线结尾的标志符以避免冲突。

流程控制

分支控制

package learn02
object demo07_if {
  def main(args: Array[String]): Unit = {
    var age=10
    //单分支
    if(age==10){
      println("yes")
    }
    //双分支
    age=15
    if(age==10){
      println("yes")
    }else{
      println("no")
    }
    //多分支
    age=25
    if(age<18){
      println("童年")
    }else if(age<=30){
      println("青年")
    }else if(age<=50){
      println("中年")
    }else {
      println("老年")
    }
  }
}

循环控制

for

package learn02
object demo07_for {
  def main(args: Array[String]): Unit = {
    for (i <- Range(1, 5)) {//范围集合，1-4
      print(i + " ")
    }
    println()
    for (i <- 1 to 5) { //包含5
      print(i + " ")
    }
    println()
    for (i <- 1 until 5) { //不包含5
      print(i + " ")
    }
    println()
    //循环守卫
    for(i <- Range(1,5) if i !=3){
      print(i+" ")
    }
    println()
    //循环步长
    for(i <- Range(1,5,2)){
      print(i+" ")
    }
    println()
    for(i <- 1 to 5 by 2){
      print(i+" ")
    }
    println()
    //循环嵌套
    for(i <- Range(1,5);j<- Range(1,4)){
      print("i="+i+",j="+j+" ")
    }
    println()
    for(i <- Range(1,5)){
      for(j <- Range(1,4)){
        print("i="+i+",j="+j+" ")
      }
    }
    println()
    //引入变量
    for(i <- Range(1,5);j=i-1){
      print("j="+j+" ")
    }
    println()
    //循环返回值
    val result=for(i <- Range(1,5))yield {
      i*2
    }
    print(result)
  }
}

while

package learn02
object demo07_while {
  def main(args: Array[String]): Unit = {
    var i=0
    while(i<5){
      print(i+" ")
      i+=1
    }
    println()
    var j=5
    do{
      print(j+" ")//5
    }while(j<5)
  }
}

循环中断

package learn02
object demo07_zd {
  def main(args: Array[String]): Unit = {
    scala.util.control.Breaks.breakable{
      for(i <- 1 to 5){
        if(i==3){
          scala.util.control.Breaks.break
        }
        print(i+" ")//1 2
      }
    }
  }
}