九阴真经--scala入门+变量+数据类型+运算符

一、入门

• Spark由scala编写，为后续学习Spark打基础
• scala基于java进行开发，把scala代码编译成class文件，运作在jvm上
• scala是一种多范式、支持面向对象和函数式编程的语言

Hello Word案例：

    object HelloScala{
		def main(args:Array[String]):Unit = {
			println("HelloScala")
		}
	}

	对第一个Scala案例进行说明
    >object
        关键字，表示声明一个伴生对象
    >Scala01_HelloWorld
        伴生对象的名字，取名的时候需要符合标识符命名规则
    >def
        关键字  标识声明一个方法
    >main
        方法的名称
    >(args: Array[String])
      &args 参数名称
      &Array[String]参数类型,在Scala语言中，[]表示泛型
      &声明参数的时候，名称在前，类型在后，名称和类型之间用冒号分隔
    >Unit
      &返回值类型为空，相当于java语言中的void关键字
      &Unit是一个类型，当前类型只有一个实例()
      &参数列表和返回值类型之间，用冒号进行分隔
      &返回值类型和函数体之间用等号进行连接
    > println("HelloScala")
      向控制台打印输出内容
      在Scala语言中，语句结束不需要加分号

• 伴生对象：以object修饰的类编译后会生成两个class文件(HelloScala、HelloWord$)，HelloScala为伴生类，HelloWord$为伴生对象所属类，真正的伴生对象为HelloWord$类中的MODULE$，这个类是单列对象。
• 通常情况下类中有静态方法或属性时，用object修饰，没有静态方法或属性的类用class修饰，两个类名必须一致，并且两个类方法和属性可以相互调用。

二、变量和数据类型

1、注释

scala和java的注释是一致的

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

//    （1）单行注释：//
//    var a:Int = 1;
 
//    （2）多行注释：/**    **/ 
   /** var b:Int = 1;
    var c:Int = 1; 88 **/
  }

//      （3）文档注释
  /**
   * 
   * @param name
   * @param age
   */
  def docZ(name:String,age:Int) : Unit = {
    
  }

2、变量和常量

• 变量：var 变量名:数据类型  = 值
• 常量：val 变量名:数据类型  = 值（相当于java中用finall修饰的变量）

  def main(args: Array[String]): Unit = {
    //（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
    var age = 18
    val name = "zhangsan"
    //（2）类型确定后，就不能修改，说明Scala是强数据类型语言。
    var age1 = 19
    //age = "" //变红
    
    //（3）变量声明时，必须要有初始值
    //var age2 : Int = //变红
    
    //（4）在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，val修饰的变量不可改。
    var age3 = 20
    age3 = 21
    
    val age4 = 12
    //age4 = 13 //变红
    
    //（5）var修饰的对象引用可以改变，val修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（
    // 比如：自定义对象、数组、集合等等）
    var std1 = new Student
    std1 = new Student
    
    val std2 = new Student
    //st2 = new Student //变红
    std2.age = 13
  }
  
  
  class Student{
    var name = "wangwu"
    var age = 18
  }

3、标识符命名规范

scala对各种变量、方法、函数等命名时使用的字符序列称为标识符。即：凡是自己可以起名字的地方都叫标识符。相对于java来说，scala可以使用运算符命名（如果开头是运算符，那么只能包含运算符），也可以使用关键字，但需要用单引号括起来。

// （1）以字母或者下划线开头，后接字母、数字、下划线
        var hello: String = "" // ok
        var Hello12: String = "" // ok
        var 1hello: String = "" // error 数字不能开头

        var h-b: String = "" // error   不能用-
        var x h: String = "" // error   不能有空格
        var h_4: String = "" // ok
        var _ab: String = "" // ok
        var Int: String = "" // ok 因为在Scala中Int是预定义的字符,不是关键字，但不推荐

        var _: String = "hello" // ok 单独一个下划线不可以作为标识符，因为_被认为是一个方法
        println(_)

        //（2）以操作符开头，且只包含操作符（+ - * / # !等）
        var +*-/#! : String = "" // ok
        var +*-/#!1 : String = "" // error 以操作符开头，必须都是操作符

        //（3）用反引号`....`包括的任意字符串，即使是Scala关键字（39个）也可以
        var if : String = "" // error 不能用关键字
        var `if` : String = "" // ok 用反引号`....`包括的任意字符串,包括关键字

4、字符串输出

通过+拼接字符串、通过printf格式化输出，常用（%d、%f、%s）、字符串模板

    var name : String = "zbb"
    var age : Int = 2
    //（1）字符串，通过+号连接
    var all = "name=" + name + ",age=" + age
    println(all)
    //（2）printf用法字符串，通过%传值
    printf("name=%s,age=%d",name,age)
    println()
    //（3）字符串，通过$引用
    //多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现。
    // 输入的内容，带有空格、\t之类，导致每一行的开始位置不能整洁对齐。
    //应用scala的stripMargin方法，在scala中stripMargin默认是“|”作为连接符，
    // 在多行换行的行头前面加一个“|”符号即可。
    var all1 = s"name=${name},age=${age}";
    var all2 =
      """
        |name=zbb
        |age=2
        |""".stripMargin

    var all3 =
      s"""
        |name = ${name}
        |age = ${age}
        |""".stripMargin

    println(all1)
    println(all2)
    println(all3)

5、键盘输入

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。基本语法：StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

6、数据类型

• scala一切数据都是对象，都是any的子类，分为AnyVal（数值型）、AnyRef（引用型）
• scala和java一样默认支持低精度向高精度隐式转换
• scala中StringOps是String的增强类型
• unit是数值型对象，他的值只有一个()。对应java中的void
• Null是引用类型的子类，他的值是null
• nothing：所有类的子类，用于方法或函数没有正常返回的时候

整数类型（Byte、Short、Int、Long）

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

        // 正确
        var n1:Byte = 127
        var n2:Byte = -128

        // 错误
        // var n3:Byte = 128
        // var n4:Byte = -129

        Scala的整型，默认为Int型，声明Long型，须后加‘l’或‘L’
        var n5 = 10
        println(n5)

        var n6 = 9223372036854775807L
        println(n6)

        Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long

浮点类型（Float、Double）

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

// 建议，在开发中需要高精度小数时，请选择Double
var n7 = 2.2345678912f
var n8 = 2.2345678912

println("n7=" + n7)
println("n8=" + n8)

字符类型（Char）

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

        （1）字符常量是用单引号 ' ' 括起来的单个字符。
        （2）\t ：一个制表位，实现对齐的功能
        （3）\n ：换行符
        （4）\\ ：表示\
        （5）\" ：表示"

        //（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("同学们都说：\"大海哥最帅\"")

布尔类型（Boolean）

布尔类型也叫Boolean类型，Booolean类型数据只允许取值true和false，占一个字节。

7、Unit类型、Null类型和Nothing类型

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

注意：

• Null属于引用型的子类，所有他不能赋值给数值型的子类
• Nothing常用于没有正常返回的情况，相当于java中的异常类，如果函数有正常返回则不能返回Nothing，否则会影响结果

8、类型转换

数值型自动转换：低精度到高精度自动转换。（byte，short）和char之间不会相互自动转换。byte，short，char他们三者可以计算，在计算时首先转换为int类型。

强制类型转换：相当于java的类型强转，使用点方法来进行强转，浮点转换成整数时可能会丢失精度，可使用小括号提升优先级

字符串和数值转换

• 基本类型转String类型（语法：将基本类型的值+"" 即可）
• String类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）
• 在将String类型转成基本数值类型时，要确保String类型能够转成有效的数据，比如我们可以把"123"，转成一个整数，但是不能把"hello"转成一个整数

三、运算符

Scala运算符的使用和Java运算符的使用基本相同，只有个别细节上不同。

1、算数运算符

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4; -b	-4
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取模(取余)	7%5	2
+	字符串相加	“He”+”llo”	“Hello”

2、关系运算符

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

java和scala中==和equals区别

• java中==表示比较对象的地址，equals表示比较对象的值
• scala中==和equals都表示比较对象的值，比较对象使用eq方法比较

3、逻辑运算符

运算符	描述	实例
&&	逻辑与	(A && B) 运算结果为 false
||	逻辑或	(A || B) 运算结果为 true
!	逻辑非	!(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中没有++、--操作符，可以通过+=、-=来实现同样的效果；

5、位运算

运算符	描述	实例
&	按位与运算符	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符	a << 2 输出结果 240 ，二进制解释： 0011 0000
>>	右移动运算符	a >> 2 输出结果 15 ，二进制解释： 0000 1111
>>>	无符号右移	a >>>2 输出结果 15, 二进制解释: 0000 1111

6、Scala运算本质

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

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

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

        // 标准的加法运算
        val i:Int = 1.+(1)

        // （1）当调用对象的方法时，.可以省略
        val j:Int = 1 + (1)

        // （2）如果函数参数只有一个，或者没有参数，()可以省略
        val k:Int = 1 + 1
        
        println(1.toString())
        println(1 toString())
        println(1 toString)