第1-4章 基础语法学习总结

第二章 基础语法之数据赋值及其类型

2.1 变量赋值的两种方式

    //TODO val修饰的是常量,类似java final修饰的,不能修改值
    val name:String = "lisi"
    //name = "zhagnsan"
    
    //TODO var修饰的是变量,类似java非final修饰的,可以修改值
    var age:Int = 20
    age = 100

2.2 String类型的用法

    val name = "jack"
    println(name)

    val name1 = "jack"+"tom"
    println(name1)
	
    val name2 = "123456".substring(3)
    println(name2)

    val name3 = name1+"cat"
    println(name3)
	
	val name4 = new String("lisi")

    //三引号的使用
    println(
      """
        |wwww,
        |ssdasd,
        |sdasdqwe,
        |asfggg,
        |""".stripMargin)

2.3 数据类型

Any: 所有类的父类

​ AnyVal: 值类型Byte、Short、Int、Long、Float、Double、Char、Boolean
​ Unit: 相当于java的void，有一个实例()
​ Stringops: 是对java补充的一系列的统称

AnyRef: 引用类型

​ String、java数组、java集合、scala数组/集合、java class、scala class
​ Null: 是所有引用类型的子类,有一个null, null一般用于给引用类型变量赋予初始值,但是在赋予初始值的候必须指定变量的类型。

​

//这是正确的，因为Unit最后执行代码块最后一行，没有返回值
var x :Unit = null
println(x) //返回()

​ Nothing: 所用类型的子类,是scala内部使用。

2.4数据类型转换

2.4.1多态

    //Unit的值为()
    val a:Unit =()
    println(a)

    //引用类型
    var b = null
    println(b)

//    var c:Int = null 引用类型与值类型不互通
//    println(c)

    //多态,null是所有引用类型的子类，String是null的父类
    var c:String= null
    var d:Null= null

2.4.2数据类型转换之低精度与高精度之间的转换

    //低精度转高精度
    val a:Int = 10
    val b:Long = a
    val c:Double = a

    //高精度转低精度 b是Long类型，e是Short类型，需要用到强转的方法
    val e:Short = b.toShort

2.4.3 值类型计算发生的数据类型转换

    //byte，short，char他们三者可以计算，在计算时首先转换为int类型。
    val b1: Byte = 20
    val b2: Byte = 20
    //直接报错了，
//    val i1: Byte = b1 + b2

    val i1: Int = 1100000000
    val i2: Int = 1200000000
    // 超出范围的int值计算会造成结果错误
    val i3: Int = i1 + i2
    println(i3) //-1994967296 超出计算结果了

2.4.4字符串与数字之间的转换

 //字符串转数字 
    val d:Int =Integer.valueOf(s)
    println(d)

	val s ="123"
    val e1 = s.toInt
    println(e1)
    
    //todo 数字转字符串
    val numStr1:String = a+"1"
    val numStr2:String = s"${a}${e1}"
    val numStr3:String = a.toString

    println(numStr1)
    println(numStr2)
    println(numStr3)

第三章 值类型、引用类型比较

3.1值比较、对象比较

def main(args: Array[String]): Unit = {
    var a: Int = 2
    var b: Int = 1
    var c: Int = 3

    //数值比较
    println(a > b)
    println(a >= b)
    println("a==b" + (a == b)) //a==bfalse
    println(a != b)

    println(a<c)
    println(a!=c)
    println("asssd"+(a==c)) //asssdfalse

    println()
    //对象比较
    var d = new Hello()
    var e = new Hello()
    println(d==e) //false
    println(d.equals(e)) //false

    println()
    //String类型比较
    var f = new String("ssss")
    var g = new String("ssss")
    println(f==g) //true
    println(f.eq(g)) //false

  }

3.2对象调用方法并且传参的两种写法

    //对象调用方法并且传参
    var h = new Hello()
    //方式1
    h.main(null)
    //方式2
    h main null
    //方式3
    h main(null)

第四章 流程控制

4.1、代码块测试，代码块的返回值，与代码块内最后一行语句相关

object $01blockTest {
  def main(args: Array[String]): Unit = {
    val b = {
      val a = 10
      val b = 20
      println(a + b) //println方法的返回值也是unit，所以外层的b为unit类型
    } //返回30
    println(b)//返回()

    println()

    val a = {
      val a = 10 //代码块内的赋值语句不会给到外面的a
      val b = 20
      1             //代码块的一个值可以给到外面的a，而且这个地方有1，外面的类型变成了Int
    }
  println(a) //打印1
  }
}

4.2、if给变量赋值

object $02if_test {
  def main(args: Array[String]): Unit = {
    var a = 10
    //类型为Any，是所有数据类型的父类
    var num = if(a%2==0){
      println("这个是偶数")
      a
    }else if (a%3 ==0 ){
      println("这个数是被三整除的数")
      "123"
    }else {
      println("这个数是被三整除的数")
      3.3
    }
    println(num) //打印了10
  }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JZtmoHOy-1654432507742)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1653905534319.png)]

观察到num此时的数据类型是Any，说明给他赋值的类型有值类型和引用类型

4.3、for循环相关的语法

4.3.1 to与until

    val ra1 = 1.to(10)
    println(ra1.toList) //List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val ra2 = 1.to(10).by(3)
    println(ra2.toList) //List(1, 4, 7, 10)

    val ra3 = 1.until(10)
    println(ra3.toList) //List(1, 2, 3, 4, 5, 6, 7, 8, 9)

4.3.2 for循环用法

    //1、基础for循环
    for (i<- 1 to 10){
      println(s"num=${i}")
    }

    //2、守卫if(k%2==0)类似于java循环里面的判断条件
    for (k<- 1 to 10 if(k%2==0)){
      println(s"num=${k}")
    }

    //3、for循环内嵌套if
    for (i<- 1 to 10){
      if (i%3==0) {
        println(s"num=${i}")
      }else {
        println(0)
      }
    }

    //4、for循环内无返回值，如果让for循环能返回数值，需要调用yield函数
    var r =for (i<-1 to 10 if(i%2==0)) yield{
      if (i%2 == 0){
        i * 10
      }
    }
    println(r)

4.3.3 while循环

    var a = 11
    while(a<=10){
      println(s"a=${a}")
      a = a+1
    }

    var b=11
    do {
      println(s"b=${b}")
      b+=1
    }while(b<=10)

4.4 breakable方法

4.4.1模拟java的break

 //模拟java的break，实际上就类似于，breakable是一个try-catch，break()类似一个抛异常
 //如下代码，如果逮到break()只接跳出循环执行breakable之外的方法,println("123321 我在这")
    breakable({
      while (a<=10){
        if(a==2){
          break()
        }else{
          a=a+1
          println(a)
        }
      }
    })
    println("123321 我在这")

4.4.2模拟java的continue

    //模拟continue，breakable再循环内，捕捉到break之后，不执行当前代码，只接到breakable的末尾，
    // 但是到末尾时外面还是循环，所以又进去循环内，效果很像java的continue
    var b = 1
    while (b<=10){
      breakable(
      if(b==2){
        b=b+1
        break() //如果进入这里前没把数值改了，那么b=2永远停在这里
      }else{
        b=b+1
        println(b)
      })
    }

continue

    //模拟continue，breakable再循环内，捕捉到break之后，不执行当前代码，只接到breakable的末尾，
    // 但是到末尾时外面还是循环，所以又进去循环内，效果很像java的continue
    var b = 1
    while (b<=10){
      breakable(
      if(b==2){
        b=b+1
        break() //如果进入这里前没把数值改了，那么b=2永远停在这里
      }else{
        b=b+1
        println(b)
      })
    }