Scala学习3——注释和变量类型

1.注释

Scala注释和java完全一致

• // 单行
• /* */ 多行
• /** */ 文档，方法或者类前面，便于scaladoc生成文档。

  //单行注释

  /*
  多行注释
   */

  /*
  * 文档注释
  *
  *
  * */

2.代码规范

• 使用tab操作实现缩进，默认整体向右移动；shift+tab整体左移
• 使用ctrl+alt+L进行格式化
• 运算符两边习惯性各加一个空格，例如：2 + 4 * 5
• 一行最多不超过80个字符，超过可以换行展示

3.变量和常量

常量：在程序执行的过程中，其值不会改变的变量

1）基本语法

var 变量名 [:变量类型] = 初始值　　var i : Int = 10

val 常量名 [:常量类型] = 初始值　　val j : Int = 20

注意：能用常量的地方不用变量

• 声明变量时，类型可以省略，编译器会自动推导。
• 静态类型，类型经过给定或推导确定后就不能修改。
• 变量和常量声明时，必须有初始值。
• 变量可变，常量不可变。
• 引用类型常量，不能改变常量指向的对象，可以改变对象的字段。
• 不以;作为语句结尾，scala编译器自动识别语句结尾。

val自身不可变，但它其中的属性可以改变

class Student(name:String, var age:Int) {
  def printInfo() : Unit = {
    println(name + " " + age + " " + Student.school)
  }
}

    val bob = new Student("bob",23)
    bob.age = 24
    bob.printInfo()
//    bob = new Student("bob",24)

2）练习代码

package chapter02

import chapter01.Student

object Test02_Variable {
  def main(args: Array[String]): Unit = {
    //声明一个变量的通用语法
    var a : Int = 10

    //(1)声明变量时，类型可以省略，编译器自动推导，即类型推导
    var a1 = 10
    val b1 = 23

    //(2)类型确定后，就不行修改，说明Scala是强数据类型的语言，和js等弱数据类型语言是有区别的
    val a2 = 15
//    a2 = "hello"

    //(3)变量声明时，必须要有初始值
//    var a3 : Int

    //(4)在声明|定义一个变量时，可以使用var或者val来修饰，var修饰的变量可以改变，val修饰的变量不可改
    a1 = 12
//    b1 = 30

    var alice = new Student("alice",20)
    alice = new Student("Alice",20)
    alice = null
    val bob = new Student("bob",23)
    bob.age = 24
    bob.printInfo()
//    bob = new Student("bob",24)
  }
}

4.标识符的命名规范

1）规则

Scala中的标识符声明，基本和java一致但在细节上有所变化，有以下三种规则：

（1）以字母或者下划线开头，后接字母、数字、下划线，和Java一样

（2）以操作符开头，且只包含操作符（+ - * / # !）

（3）用反引号`......`包括的任意字符串，即使是Scala关键字（39个）也可以

    //(1)以字母或者下划线开头，后街字母、数字、下划线
    val hello : String = ""
    var Hello123 = ""
    val _abc = 123

//    val h-b = ""
//    val 123abc = 234

    //(2)以操作符开头，且只包含操作符（ + - * / # ! 等）
    val -+*% = "hello"
    println(-+*%)

    //(3)用反引号`......`包括的任意字符串，即使是Scala关键字（39个）也可以
    val `if` = "if"
    println(`if`)

2）Scala关键字

• package import class obejct trait extends with type for
• private protected abstract sealed final implicit lazy override
• try catch finlly throw
• if else match case do while for return yield
• def var val
• this super
• new
• true false null
• 其中Java没有的关键字：object trait with implicit match yield def val var

5.字符串输出

1）基本语法

（1）字符串，通过+号连接

（2）printf用法：字符串，通过%传值，类似C语言

（3）字符串模板（插值字符串）：通过$获取变量值

2）练习代码

package chapter02

import java.util.function.DoubleBinaryOperator

object Test04_String {
  def main(args: Array[String]): Unit = {
    //(1)字符串，通过+号连接
    val name : String = "alice"
    val age : Int = 18
    println(age + "岁的" + name)

    // *用于将一个字符串复制多次并拼接
    println(name * 3)

    //(2)printf用法：字符串，通过%传值
    printf("%d岁的%s", age, name)
    println()

    //(3)字符串模板（插值字符串）：通过$获取变量值
    println(s"${age}岁的${name}")


    val num:Double = 2.3456
    println(f"The num is ${num}%2.2f")   //f""格式化模板字符串
    println(raw"The num is ${num}%2.2f")    //raw""原始输出

    //三引号表示字符串，保持多行字符串的原格式输出
    val sql =
      s"""
        |select *
        |from
        |   student
        |where
        |   name = ${name}
        |and
        |   age = ${age}
        |""".stripMargin
    println(sql)
  }
}

6.键盘输入

在编程中，需要接收用户输入的数据，就可以用键盘输入语句来获取

1）基本语法

StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

 2）练习代码

package chapter02

import scala.io.StdIn

object Test05_StdIn {
  def main(args: Array[String]): Unit = {
    //输入信息
    println("请输入您的姓名：")
    val name: String = StdIn.readLine()
    println("请输入您的年龄：")
    val age: Int = StdIn.readInt()

    //控制台打印输出
    println(s"欢迎${age}岁的${name}")
  }
}

 

7.文件的输入输出

package chapter02

import java.io.{File, PrintWriter}
import scala.io.Source

object Test06_FileIO {
  def main(args: Array[String]): Unit = {
    //1.从文件中读取数据
    Source.fromFile("src/main/resources/test.txt").foreach(print)

    //2.将数据写入文件
    val writer = new PrintWriter(new File("src/main/resources/output.txt"))
    writer.write("hello scala from java")
    writer.close()
  }
}

 

8.数据类型

1）数据类型

• java基本类型char byte short int long float double boolean。
• java基本类型对应包装类型：Charater Byte Short Integer Long Float Double Boolean。
• java中不是纯粹的面向对象。
• Scala吸取了这一点，所有数据都是对象，都是Any的子类。
• Any有两个子类：AnyVal值类型 AnyRef引用类型。
• 数值类型都是AnyVal子类，和Java数值包装类型都一样，只有整数在scala中是Int、字符是Char有点区别。
• StringOps是java中String类增强，AnyVal子类。
• Unit对应java中的void，AnyVal子类。用于方法返回值的位置，表示方法无返回值，Unit是一个类型，只有一个单例的对象，转成字符串打印出来为()。
• Void不是数据类型，只是一个关键字。
• Null是一个类型，只有一个单例对象null就是空引用，所有引用类型AnyRef的子类，这个类型主要用途是与其他JVM语言互操作，几乎不在Scala代码中使用。
• Nothing所有类型的子类型，也称为底部类型。它常见的用途是发出终止信号，例如抛出异常、程序退出或无限循环。

2）整数类型

都是有符号整数，标准补码表示

• Byte 1字节
• Short 2字节
• Int 4字节
• Long 8字节
• 整数赋初值超出表示范围报错。
• 自动类型推断，整数字面值默认类型Int，长整型字面值必须加L后缀表示。
• 直接向下转换会失败，需要使用强制类型转换，(a + 10).toByte。

3）浮点类型

• Float IEEE 754 32位浮点数
• Double IEEE 754 64位浮点数
• 字面值默认Double

4）字符类型

• 同java的Character，2字节，UTF-16编码的字符。
• 字符常量：''
• 类型Char
• 转义：\t \n \r \\ \" \'etc

5）布尔类型

　　布尔类型：true false

6）空类型

• Unit 空值，只有一个实例，用于函数返回值。
• Null 空引用，只有一个实例null。
• Nothing 既没有值也没有引用，什么也没有，只知道空但不确定是值空还是引用类型空。确定没有正常的返回值，可以用Nothing来指定返回值类型。好像意思是抛异常时返回Nothing，不是特别懂。

Unit

    //空值Unit
    def m1(): Unit = {
      println("函数m1被调用执行！")
    }

    val a: Unit = m1()
    println("a: " + a)

 可以看到Unit空指就是一个括号

Null

    //空引用Null
//    val n: Int = null   //error
    var student: Student = new Student("alice",20)
    student = null
    println(student)

 不能直接定义为Null类型

可以空引用，null

Nothing

    //Nothing
    def m2(n: Int): Nothing = {
      throw new NullPointerException
    }

    val b = m2(0)
    println(b)

明天继续学习