01_Scala基础_变量类型_运算符

源文件以 ".scala" 为扩展名 ; 程序的执行入口是main()函数, 严格区分大小写
方法由一条条语句构成，语句后不需要分号;  一行有多条语句，除了最后一条语句不需要分号，其它语句需要分号

\t      ：一个制表位，实现对齐的功能
\n     ：换行符
\\      ：一个\
\"      ：一个"
\r      ：一个回车  println("hello\rk"); 

Scala语言输出的三种方式

1 字符串通过+号连接（类似java）
2 printf用法 （类似C语言）字符串通过 % 传值。
3 字符串通过$引用(类似PHP）

Scala中的注释类型

单行注释    //注释文字
多行注释 /*  注释文字 */
文档注释   被工具 scaladoc 所解析，生成一套以网页文件形式体现的该程序的说明文档

变量 var | val 变量名 [: 变量类型] = 变量值

类型可以省略（类型推导）
类型确定后，就不能修改 (强数据类型)
var 修饰的变量可改变; 修饰的对象引用可以改变，  val 可改  编译后等同于加上final

/**
 * @deprecated xxx
 * @example testing coding
 */

object PrintVarTest {
  def main(args: Array[String]): Unit = {
    var name: String = "hello"
    var age: Int = 35

    // printf用法
    //字符串通过 % 传值
    //字符串通过$引用

    //1 printf + % 格式化输出
    printf("名字: %s , 年龄: %d \n", name,age)
    println("名字：" +name)

    // 2 println () $变量   输出
    println(s"名字: $name , 年龄: $age")


    // 变量 var | val 变量名 [: 变量类型] = 变量值

    //1 类型可以省略（类型推导）
    //2 类型确定后，就不能修改 (强数据类型)
    //3 var 修饰的变量可改变 val 修饰的变量不可改  编译后等同于加上final
    //4 var 修饰的对象引用可以改变
    //5 变量声明时，需要初始值

    // 编译器，动态的 (逃逸分析)： 当数据生命周期很长，经常引用，会放在堆里(heap) ,如果偶尔用一下会放在栈里面(stack) 对象也可能在stack里面
    var age_var: Int = 10
    var age_var_updated = 10 //1 类型可以省略（类型推导）
    var score:Float = 70.9f // 在scala中，小数默认为Double ,整数默认为Int
    // age_var = "alex"  2 类型确定后，就不能修改 (强数据类型)

    
    val lx2 = new jiefu  //因为val 没有线程安全问题，因此效率高
    var lx = new jiefu  //4 var 修饰的对象引用可以改变
    // 3 var 修饰的变量可改变  val 修饰的变量不可改  编译后等同于加上final
    lx.age = 30
//    lx.name = "bob"  报错 val  final 不可变
  }
}


class jiefu{
  var age: Int = 29
  val name: String = "Robin"
//  var high : Double = 0  // 5 必须有初始值 不然就是抽象的
}

数据类型介绍

1 Scala中根类型是 Any ,所有类的父类
2 AnyVal(值类型) 和 AnyRef(引用类型) 不管是AnyVal还是AnyRef 都是对象，都是any的子类
3 Null 类型是特殊类型，只有一个值null, 是bottom class， 是所有Anyref类型的子类
4 Nothing  也是bottom class, 所有类的子类， 将Nothing类型的值 返回给任意变量或函数，多用于异常

数据类型列表

数据类型介绍

1 Scala中根类型是 Any ,所有类的父类
2 AnyVal(值类型) 和 AnyRef(引用类型) 不管是AnyVal还是AnyRef 都是对象，都是any的子类
3 Null 类型是特殊类型，只有一个值null, 是bottom class， 是所有Anyref类型的子类
4 Nothing  也是bottom class, 所有类的子类， 将Nothing类型的值 返回给任意变量或函数，多用于异常

Booolean类型数据只允许取值true和false
null 可以赋值给任意引用类型(AnyRef)，
null 不能赋值给值类型(AnyVal: 比如 Int, Float, Char, Boolean, Long, Double, Byte, Short)

object DataTypeTest {
  def main(args: Array[String]): Unit = {
    sayHi()
    sayHi _ ; println("xxx")  // sayHi _ 不执行
    sayHi  // 无形参 可以省略

    // char
    //当我们输出一个char类型时，他会输出该数字对应的字符(码值表 unicode)//unicode 码值表包括ascii
    var c1 : Char = 'a'
    var c2 : Char = 97
    printf(s"c1: $c1,  c2: $c2\n")   //c1: a,  c2: a

    //char 可以当做数字进行运行

    var char2: Char = 'a'
    var num = 10 + char2
    println("num=" + num + " =>" +  num.getClass) // num=107 =>int

    //1. 当把一个计算的结果赋值一个变量，则编译器会进行类型转换及判断（即会看范围+类型）
    //2. 当把一个字面量赋值一个变量，则编译器会进行范围的判定
//        var cc2: Char = 'a' + 1 //报错 require char found int
//        var cc3: Char = 97 + 1 // 报错 require char found int
        var cc4: Char = 98

  // Null & Nothing
  //Null类只有一个实例对象，null，类似于Java中的null引用。null可以赋值给任意引用类型(AnyRef)，
  //不能赋值给值类型(AnyVal: 比如 Int, Float, Char, Boolean, Long, Double, Byte, Short)
    var d1 : Dog = null
//    var d2 : Double = null // 报错 an expression of type Null is ineligible for implicit conversion
    

  }
  def sayHi(): Unit = {
    println("hello")
  }
  //比如开发中，我们有一个方法，就会异常中断，这时就可以返回Nothing
  //即当我们Nothing做返回值，就是明确说明该方法没有没有正常返回值
  def sayException: Nothing = {
    throw  new Exception("Nothing 类型 抛出异常")
  }
}

class Dog {
}

1 自动类型提升 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换(隐式转换)。
2 强转： 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转函数，但可能造成精度降低或溢出
java  :  int num = (int)2.5
scala :  var num : Int =  2.7.toInt  //对象

1 当进行数据的 从 大——>小，就需要使用到强制转换
2 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
3 Char类型可以保存 Int的常量值，但不能保存Int的变量值，需要强转
4 Byte和Short类型在进行运算时，当做Int类型处理

object DataTransAtest {
  def main(args: Array[String]): Unit = {

    var c1 : Char = 'a'
    var c2 : Int  = c1

    println("c1: " +  c1.getClass) // c1: char
    println("c2: " +  c2) // c2: 97   低精度向高精度转换  char -> int

    var i1 :Byte = 20
//    var c3: Char = i1  //type mismatch Byte 不能与 char 互转

    //1 自动类型提升：有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算
    var n1 = 10
    var n2 = 1.1f
    var n3 = n1 + n2
    println(n3.getClass)  //float

    // 2 强转：自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转函数，但可能造成精度降低或溢出
    val d1 = 1.2
    val s1 = d1 + "" // + 拼接 返回字符串

    //String类型转基本数据类型 精度损失

    val s2 = "12"
    val num1 = s2.toByte; val num2 = s2.toShort
    val num12 = num1 + num2 // 返回int  类型
    val num3 = s2.toDouble ;  val num4 = s2.toLong
    var num5 = num3 + num4  //返回double类型

    //在scala中，不是讲小数点后的数据进行截取，而是会抛出异常
    val s4 = "12.5"
    println(s4.toInt) // error
    println(s4.toDouble) //  ok

  }
}

运算符  特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符 (arithmetic)是对数值类型的变量进行运算
比较运算符(关系运算符) 结果都是Boolean型，也就是要么是true，要么是false
逻辑运算符 用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个Boolean值 
赋值运算符  就是将某个运算后的值，赋给指定的变量
位运算符