scala学习(已完结)

初识scala语法

object 关键字是声明一个单例对象(伴生对象)

main 执行入口方法只能定义在object 伴生对象里

def 函数名称(参数名称:参数类型): 返回值类型 = { 方法体 }

object study_01 {
  def main(args: Array[String]): Unit = {
    println("hello world")
    System.out.println("scala from java")
  }
}

伴生对象

class Student(name:String,age:Int){
  def printInfo():Unit = {
    println(this.name+" "+this.age+"  "+Student.school)
  }
}
// 我们想要实现静态属性的时候使用伴生对象
object Student{
  val school:String = "zhonghuaSchool"
}

注释

scala的注释和java一样有三种注释的方式

// 单行注释
/*
多行注释
*/
/**
 * 文档注释
 */

变量和数据类型

变量和常量(重点)

常量: 常量就是定义一个在执行程序过程中不会被改变的变量

scala基本语法

        var 变量名[: 变量类型 ] var name:String = "jack"

        val 常量名[: 变量类型 ] val school:String = "kongfu"

注: 能用常量就不用变量

注意事项:

1. 定义变量的时候我们可以不指定变量类型,编译器会自动推导
2. 当类型确定之后就不能修改类型,强类型
3. 变量声明的时候必须要有初始值
4. 声明变量的时候我们要注意,var修饰的变量值可以被修改,而val修饰的变量值不可以修改
5. 修饰符为val的变量值是引用类型的时候,不能够修改引用类型指向,但是可以修改内部值的属性等var的变量

标识符的命名规范

1. 以字母下划线开头,后面接字母数字下划线
2. 操作符只包含(+ - * / 等)
3. 不能直接使用关键字命名
4. 可以用``反引号包裹关键字来命名

字符串输出

1. 字符串println输出+号拼接,或者使用*进行复制几倍
2. println格式化%输出
          println("%d%s",name,age)
3. 模板字符串进行输出
          println(s"")  //格式
          println(s"${name}")
4. 格式化模板字符串输出
          println(f"${num}%2.2f") // 格式化输出小数.必须长度两位不够补零保留两位小数
5. 多行字符串保持原格式输出       

   println(s"""
      |hello
      |read
      |""".stripMargin)

6. 输出方式
          printf() // 不换行输出
          println() // 换行输出

读写文件

object study_02 {
  def main(args: Array[String]): Unit = {
    // 使用scala的ip读取文件
    Source.fromFile("src/main/resources/test.txt").foreach(print)
    // 使用java的io写入文件
    val writer = new PrintWriter(new File("src/main/resources/output.txt"))
    writer.write("hello world from scala")
    writer.close()
  }
}

数据类型(重点)

数据的一切数据都是对象,都是any的子类

数据类型分为两大类:数值类型(anyval)引用类型(anyref),不管是值还是引用类型都是对象

Unit: 对应java的void Unit是一个数据类型,只有一个对象()

Null: 是一个类型,是所有引用对象的子类

整数类型

整数类型就是用来存放整数值的

整形分类:

        Byte[1]        Short[2]        Int[4]        Long[8]

整数默认类型是Int

浮点类型默认是Double

字符类型和布尔类型

字符类型可以表示单个字符,字符类型是Char

'\t': 一个制表位,实现对齐的功能

'\n': 换行符

'\\': 表示\

布尔类型也叫Boolean类型: Boolean类型数据只允许取值true和false

boolean类型占一个字节

Unit类型 Null类型和Nothing类型(重点)

Unit: 表示无值,和其他语言的void等同,用作不反悔任何结果的方法结果类型,Unit只有一个实例值,写成()

Null: Null类型只有一个实例值null,是所有引用类型的子类,用作引用类型制空

Nothing: Nothing类型在类层级最低端,它可以是任何类型的子类型,当一个函数我们没有确定的正常的返回值,可以用Nothing来指定返回类型,我们可以把返回值(异常)赋值给其他的函数或者变量,也就是可以返回任何类型数据,包括异常.

类型转换

数值类型自动转换

多种类型进行运算的时候,系统会首先把类型都提升到当中最大的数据类型然后再进行计算

(byte,short)和char之间不会相互转换,char只能直接转换Int

(byte,short,char)三者可以进行计算,首先转换为int类型

强制类型转换

自动类型转换的逆过程,将精度大的数值类型转换为精度小的数值类型,使用需要加上强制转换函数,强转有可能会造成精度损失

数值强转低

        例:

                var num: Int = 2.7.toInt

        强转符号只针对于最近的操作有效果,使用小括号提升优先级

                val n2:Int = (2.6+2.1).toInt

数值转换String

        例:

                val s:String = 27 + ""

String转数值

        例:

                val m:Int = "12".toInt

                val f: Float = "12.3".toFloat

                val f2:Int = "12.3".toDouble.toInt

运算符

算数运算符

基本语法:

        +:正号

        -:负号

        +:加号

        -:减号

        *:乘号

        /:除号

        %:取模(取余)

        +:字符串拼接

关系运算符

基本语法:

        ==:判断是否相等于,判断的是值是否等于

        !=:判断是否不等于

        <: 小于号

        >:大于号

        <=:小于等于

        >=:大于等于

        .eq():用来判断引用地址是否相同

逻辑运算符

基本语法:

        &&: 逻辑与

        ||:逻辑或

        !:逻辑非

赋值运算符

基本语法:

        =:将一个表达式的值赋值给左值

        +=:和其本身相加再赋值

        -=:和其本身相减再赋值

        *=:和其本身相乘再赋值

        /=:和其本身相除再赋值

        %=:和其本身求余再赋值

注意:scala里没有和jjava一样的++ -- 的自增方法 

运算符的本质

在scala里一切都是对象

例:

        n1.+(n2) == n1 + (n2) == n1 + n2   // 我们都可以通过调用方法的方式来调用运算符进行计算

        7.5 toInt toString  // 中间的点可以省略,转换成数字再转换成字符串

流程控制

条件分支

单分支

        基本语法:

                if (条件表达式)  {    执行代码块    }

        例:

                if (age >= 18){    println("成年")    }

双分支

        基本语法

                if(条件表达式) {    执行代码块     } else {执行代码块}

       例:

                if(age >= 18) {println("成年")} else {println("未成年")}

多分支

        基本语法

                 if(条件表达式) {    执行代码块     } else if(条件表达式){执行代码块} else {执行代码块}

        例:

                if(age >= 18) {println("成年")}else if(age>=30) {println("中年人")} else {println("未成年")}

条件分支返回值

        var result:Unit = if(age>18){println("成年")}  // 默认的返回值Unit就是一个()

        var result:String =  if(age>18){

                                                println("成年")

                                                 "成年"

                                                }  // 返回值则是"成年"

scala没有三元运算符      

        var result:String =  if(age>18) "成年" else "未成年" // 可以用这种方式代替

For循环

范围循环

基本语法

for(i <- 1 to 3){ // 循环1-3

        print(i)

}

for(i <- 1util 10){ // 循环1-9不包含10

        println(i)

}

遍历集合

循环出集合内的每一个值

for (i <- Array(12,34,21)){println(i)}

for (i <- List(12,34,21)){println(i)}

for (i <- Array(12,34,21)){println(i)}

循环守卫

循环守卫也称为条件判断式,保护式为true则进入循环,false则跳过,类似continue

基本语法

        for (i <- 1 to 3 if i != 2){println(i)}

循环步长

基本语法:

        for(i <- 1 to 10 by 2){println(i)} // 正序循环1-10步长2

         for(i <- 10 to 1 by -1){println(i)} // 倒序循环10-1步长1

         for(i <- 1 to 10 reverse){println(i)} // 翻转输出10-1

循环嵌套

基本语法

         for(i <- 1 to 10;j <- 1 to 10){

                println(i+j)

        }

等价于

        for(i <- 1 to 10 ){

         for(j <- 1 to 10){

                println(i+j)

                }

        }

引入循环变量

for(i <- 1 to 10;j=10 - i){

                println(i+j)

        }

或者

for{

i <- 1 to 10

j <- 1 to 10

}

{

                println(i+j)

}

for返回值

for循环默认赋值之后得到的是()空

val b = for(i <- 1 to 10) yield i  // 使用yield 可以生成一个Vector集合包含i的每一个值

while循环

循环条件是一个返回一个布尔值的表达式

while循环是先判断再执行语句

var i:Int = 10
    while (i >=1){
      println(i)
      i -= 1
    }

do while循环

第一次会先无条件执行一次do里面循环体内容,在进行判断

var j:Int = 10
    do {
      println(j)
      j -= 1
    }while(j >= 1)

循环中断

使用抛出异常的方式中断循环

object study_04 {
  def main(args: Array[String]): Unit = {
    // 使用抛出异常的方式中断循环
    try{
      for (i <- 1 until 5){
        if(i == 3){
          throw new RuntimeException()
        }
        println(i)
      }
    }catch{
      case e:Exception =>  //什么都不要左,实现异常的抛出何捕获
    }
  }
}

使用scala中的Breaks类中的break方法,实现异常的抛出何捕获

object