/*
   object: 关键字，声明一个单例对象（伴生对象）
 */
object HelloWorld {
  /*
    main 方法：从外部可以直接调用执行的方法
    def 方法名称(参数名称: 参数类型): 返回值类型 = { 方法体 }
   */
  def main(args: Array[String]): Unit = {
    println("hello world")
    System.out.println("hello scala from java")
  }
}

  def main(args: Array[String]): Unit = {
    //（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
    var age = 18
    age = 30
    //（2）类型确定后，就不能修改，说明 Scala 是强数据类型语言。
    // age = "tom" // 错误
    //（3）变量声明时，必须要有初始值
    // var name //错误
    //（4）在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰 的变量可改变，val 修饰的变量不可改。
    var num1 = 10 // 可变
    val num2 = 20 // 不可变
    num1 = 30 // 正确
    //num2 = 100 //错误，因为 num2 是 val 修饰的
  }

object TestVar {
  def main(args: Array[String]): Unit = {
    // p1 是 var 修饰的，p1 的属性可以变，而且 p1 本身也可以变
    var p1 = new Person()
    p1.name = "dalang"
    p1 = null
    // p2 是 val 修饰的，那么 p2 本身就不可变（即 p2 的内存地址不能变）， 但是，p2 的属性是可以变，因为属性并没有用 val 修饰。
    val p2 = new Person()
    p2.name="jinlian"
    // p2 = null // 错误的，因为 p2 是 val 修饰的
  }
}
class Person{
  var name : String = "jinlian"
}

def main(args: Array[String]): Unit = {
    // （1）以字母或者下划线开头，后接字母、数字、下划线
    var hello: String = "" // ok
    var Hello12: String = "" // ok
    var 1hello: String = "" // error 数字不能开头
    var h-b: String = "" // error 不能用-
    var x h: String = "" // error 不能有空格
    var h_4: String = "" // ok
    var _ab: String = "" // ok
    var Int: String = "" // ok 因为在 Scala 中 Int 是预定义的字符,不是关键字，但不推荐
    var _: String = "hello" // ok 单独一个下划线不可以作为标识符，因为_被认为是一个方法
    println(_)
    //（2）以操作符开头，且只包含操作符（+ - * / # !等）
    var +*-/#! : String = "" // ok
    var +*-/#!1 : String = "" // error 以操作符开头，必须都是操作符
    //（3）用反引号`....`包括的任意字符串，即使是 Scala 关键字（39 个） 也可以
    var if : String = "" // error 不能用关键字
    var `if` : String = "" // ok 用反引号`....`包括的任意字符串,包括关键字
}

 def main(args: Array[String]): Unit = {
    var name: String = "jinlian"
    var age: Int = 18
    //（1）字符串，通过+号连接
    println(name + " " + age)
    //（2）printf 用法字符串，通过%传值。
    printf("name=%s age=%d\n", name, age)
    //（3）字符串，通过$引用
    //多行字符串，在 Scala中，利用三个双引号包围多行字符串就可以实现。 三引号表示字符串，保持多行字符串的原格式输出
    //输入的内容，带有空格、\t 之类，导致每一行的开始位置不能整洁对齐。
    //应用 scala 的 stripMargin 方法，在 scala 中 stripMargin 默认 是“|”作为连接符，//在多行换行的行头前面加一个“|”符号即可。
    val s =
    """
      |select
      | name,
      | age
      |from user
      |where name="zhangsan"
      """.stripMargin
    println(s)
    //如果需要对变量进行运算，那么可以加${}
    val s1 =
      s"""
         |select
         | name,
         | age
         |from user
         |where name="$name" and age=${age + 2}
      """.stripMargin
    println(s1)
    val s2 = s"name=$name"
    println(s2)
  }

def main(args: Array[String]): Unit = {
    // 1 输入姓名
    println("input name:")
    var name = StdIn.readLine()
    // 2 输入年龄
    println("input age:")
    var age = StdIn.readShort()
    // 3 输入薪水
    println("input sal:")
    var sal = StdIn.readDouble()
    // 4 打印
    println("name=" + name)
    println("age=" + age)
    println("sal=" + sal)
  }

object TestDataType {
 def main(args: Array[String]): Unit = {
 // 正确
 var n1:Byte = 127
 var n2:Byte = -128
 // 错误
 // var n3:Byte = 128
 // var n4:Byte = -129
 } 
}

object TestDataType {
 def main(args: Array[String]): Unit = {
 var n5 = 10
 println(n5)
 var n6 = 9223372036854775807L
 println(n6)
 } 
}

object TestDataType {
 def main(args: Array[String]): Unit = {
 // 建议，在开发中需要高精度小数时，请选择 Double
 var n7 = 2.2345678912f
 var n8 = 2.2345678912
 println("n7=" + n7)
 println("n8=" + n8)
 } 
}

object Test {
    def main(args: Array[String]): Unit = {
      //（1）字符常量是用单引号 ' ' 括起来的单个字符。
      var c1: Char = 'a'
      println("c1=" + c1)
      //注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围，
      var c2:Char = 'a' + 1
      println(c2)

      //（2）\t ：一个制表位，实现对齐的功能
      println("姓名\t 年龄")
      //（3）\n ：换行符
      println("西门庆\n 潘金莲")
      //（4）\\ ：表示\
      println("c:\\岛国\\avi")
      //（5）\" ：表示"
      println("同学们都说：\"大海哥最帅\"")
    }
}

object TestBooleanType {
 def main(args: Array[String]): Unit = {
 
 var isResult : Boolean = false
 var isResult2 : Boolean = true
 }
}

object TestSpecialType {
 def main(args: Array[String]): Unit = {
 def sayOk : Unit = {// unit 表示没有返回值，即 void
 
 }
 println(sayOk)
 } 
}

object Test {
    def main(args: Array[String]): Unit = {
      //null 可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型 （AnyVal）
      var cat = new Cat();
      cat = null // 正确
      var n1: Int = null // 错误
      println("n1:" + n1)
    }
}

object TestSpecialType {
 def main(args: Array[String]): Unit = {
 def test() : Nothing={
 throw new Exception()
 }
 test
 } 
}