Scala学习视频心得（二）变量和数据类型、运算符

1、变量&常量

    声明一个整数类型的变量  a ，并将10赋值给a
    var a:Int = 10
    println(a)
    （1）声明变量时，类型可以省略，编译器自动推导，即类型推导
    var a = 10
    println(a)
    （2）类型确定后，就不能修改，说明Scala是强数据类型语言。
    var a  = 10
    a = "abc"
    println(a)
    （3）变量声明时，必须要有初始值
    var a : Int

    （4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。
    var a = 10
    val b = 20
    a = 30
    b = 40

    （5）var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）
    var std1 = new Student()
    std1 = new Student()

    val std2 = new Student()
    std2.name = "lisi"
    //std2 = new Student()

    （6） 在实际开发的过程中，var和val优先选谁？
    val

    var s:String = "abc"

2、命名规范

1）命名规则

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

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

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

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

3、字符串输出

    var name:String = "xyp"
    var age:Int =18

    //1)字符串，通过＋号直接连接
    //println(age+"岁的"+name+"在吃饭")

    //2)printf用法：通过%传值
    //printf("%d岁的%s在吃饭",age,name)

    //3)字符串模板（插值字符串），通过$获取变量值
    //多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现保持原格式显示与输出。
    //输入的内容，带有空格、\t之类，导致每一行的开始位置不能整洁对齐。
    //应用scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符，
    //在多行换行的行头前面加一个“|”符号即可
    var sql:String =
      s"""
        |select
        | *
        |from
        | student
        |where
        | name = ${name}
        |and
        | age = ${age}
      """.stripMargin
    printf(sql)

4、键盘输入

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

    println("请输入您的芳名")
    val name:String = StdIn.readLine()
    println("请输入您的芳龄")
    val age:Int = StdIn.readInt()

    println(s"欢迎${age}岁的${name}来到兰智数加")

5、数据类型

总体上来说分为两大类：AnyVal、AnyRef

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C3MOui1Z-1614515010778)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210227220630364.png)]

1）整数类型

数据类型	描述
Byte [1]	8位有符号补码整数。数值区间为 -128 到 127
Short [2]	16位有符号补码整数。数值区间为 -32768 到 32767
Int [4]	32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long [8]	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 = 2的(64-1)次方-1

2）浮点类型

数据类型n	描述
Float [4]	32 位, IEEE 754标准的单精度浮点数
Double [8]	64 位 IEEE 754标准的双精度浮点数

3）字符类型

	    //（1）字符常量是用单引号 ' ' 括起来的单个字符。
        var c1: Char = 'a'
        println("c1=" + c1)
		//注意：这里涉及自动类型提升，其实编译器可以自定判断是否超出范围，
    	//不过idea提示报错
		var c2:Char = 'a' + 1
		println(c2)
        
        //（2）\t ：一个制表位，实现对齐的功能
        println("姓名\t年龄")

        //（3）\n ：换行符
        println("西门庆\n潘金莲")

        //（4）\\ ：表示\
        println("c:\\岛国\\avi")

        //（5）\" ：表示"
        println("同学们都说：\"大海哥最帅\"")

4）特殊类型

数据类型	描述
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null , Null 类型只有一个实例值null
Nothing	Nothing类型在Scala的类层级最低端；它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

	//演示Unit
    println(m1())

    def m1():Unit={
      println("m1方法被执行了")
    }
	//结果
	m1方法被执行了
	()



    //演示Nothing
    println(m2(0))
    def m2(n:Int): Nothing ={
      if(n==0){
        throw new NullPointerException
      }else{
        throw new RuntimeException
      }
    }

6、类型转换

1）数值类型自动转换

    //1、自动类型转换，当有多种类型混合计算的时候，系统首先自动将所有数据换成精度大的数据类型，然后再进行计算
    //var b1: Byte = 10
    //var n: Long = 20
    //val res: Long = n+b1

    //2、把精度大的数值类型给精度小的数值类型时，就会报错，反之就会进行自动类型转换
    //var b:Byte=10
    //var n:Int=b //隐式转换
    //var b1:Byte=n //会报错

    //3、（byte、short）与char之间不会相互转化
    //var b:Byte=10
    //var c:Char=b//会报错
    //var c:Char=96
    //var n:Int=c //Char可以赋给Int

    //4、byte、short、char三者之间可以计算，在计算的时候首先转换为Int
    var b:Byte=10
    var s:Short=20
    var c:Char=30
    val res: Int = b+s+c //自动提升为Int

2）强制类型转换

	//1、将数据由高精度转换为低精度，需要使用到强制转换
    var n:Int=2.5.toInt
    println(n)

    //2、强制符号只针对于最近的操作有效，往往使用
    //var n:Int=2.5.toInt+3.6.toInt
    //var n:Int=(2.5+3.6).toInt//两种方式的计算结果可能不一样要根据具体的业务分析

3）数值类型和String类型转换

	//数值-->字符串
    //var n=10+""

    //字符串-->数值
    var res="12.3".toDouble
    println(res)

类型转换面试题

    var b:Byte=128.toByte
    println(b)//结果是-128

    /**
      * 130在scala中默认是Int类型，应该有32位
      * 源码 00000000 00000000 00000000 10000010
      * 补码 00000000 00000000 00000000 10000010
      * 对Int数据进行截取，截取为Byte类型，剩8位
      * 负数补码：10000010 --> 反码：11111101 --> 源码：11111110
      */
    var c:Byte=130.toByte
    println(c)//结果是-126

7、运算符

1）算术运算符

	//（1）对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
    var r1: Int = 10 / 3 // 3
    println("r1=" + r1)

    var r2: Double = 10 / 3 // 3.0
    println("r2=" + r2)

    var r3: Double = 10.0 / 3 // 3.3333
    println("r3=" + r3)
    println("r3=" + r3.formatted("%.2f")) // 含义：保留小数点2位，使用四舍五入

2）比较运算符

运算符	运算	范例	结果
==	相等于	4==3	false
!=	不等于	4！=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true

Scala中==、equals、eq

	/**
      * 比较运算符
      *
      * Java：==比较的是对象的内存地址
      *       equals默认和==一样，也是比较的地址，但String对equals方法进行了重写，字符串的equals比较的是内容
      *
      * Scala：==和equals功能一样，比较的是内容是否相等（底层实际上是调用了equals）
      *       eq比较地址
      *
      */
    var s1:String = new String("abc")
    var s2: String = "abc"
    println(s1==s2)//true
    println(s1.equals(s2))//true
    println(s1.eq(s2))//false

3）逻辑运算符

	    // 测试：&&、||、!
        var a = true
        var b = false

        println("a&&b=" + (a && b))     // a&&b=false
        println("a||b=" + (a || b))     // a||b=true
        println("!(a&&b)=" + (!(a && b))) // !(a&&b)=true

扩展避免逻辑与空指针异常
isNotEmpty(String s){
	//如果逻辑与，s为空，会发生空指针
	return s!=null && !"".equals(s.trim());
}

4）赋值运算符

运算符	描述	实例
=	简单的赋值运算符，将一个表达式的值赋给一个左值	C = A + B 将 A + B 表达式结果赋值给 C
+=	相加后再赋值	C += A 等于 C = C + A
-=	相减后再赋值	C -= A 等于 C = C - A
*=	相乘后再赋值	C *= A 等于 C = C * A
/=	相除后再赋值	C /= A 等于 C = C / A
%=	求余后再赋值	C %= A 等于 C = C % A
<<=	左移后赋值	C <<= 2等于 C = C << 2
>>=	右移后赋值	C >>= 2 等于 C = C >> 2
&=	按位与后赋值	C &= 2 等于 C = C & 2
^=	按位异或后赋值	C ^= 2 等于 C = C ^ 2
|=	按位或后赋值	C |= 2 等于 C = C | 2

注意：Scala中没有++、–操作符，可以通过+=、-=来实现同样的效果；

相比较Java而言，+=实则上是底层做了一个类型转换，而scala却并没有这样做，开发的作者认为既然你想转换那就直接在定义类型的时候声明所需类型就可以，何必多此一举让编译器来帮你转换

    var b:Byte = 10
    b += 1
    println(b)

常规操作如上这样编译肯定会出错，因而聪明人的做法如下，手动滑稽

    var b:Int = 10
    b += 1
    println(b)

5）Scala运算符本质

IDEA中宏定义

在Scala中其实是没有运算符的，所有运算符都是方法。

1）当调用对象的方法时，点.可以省略

2）如果函数参数只有一个，或者没有参数，()可以省略