Scala——基本语法

Scala是一门以Java虚拟机（JVM）为运行环境并将 面向对象和 函数式编程的最佳特性结合在一起的静态类型编程语言（静态语言需要提前编译的如：Java、c、c++等，动态语言如：js）。
1）Scala是一门多范式的编程语言，Scala支持面向对象和函数式编程。（多范式，就是多种编程方法的意思。有面向过程、面向对象、泛型、函数式四种程序设计方法。）
2）Scala源代码（.scala）会被编译成Java字节码（.class），然后运行于JVM之上，并 可以调用现有的Java类库，实现两种语言的无缝对接。

1 语法的简单说明

/*
	object：关键字，声明一个单例对象（伴生对象）
*/
object HelloWorld{
	/*
	main 方法：从外部可以直接调用执行的方法
	def 方法名称（参数名称：参数类型）：返回值类型={方法体}
	*/
	def main(args: Array[String]):Unit = {
		println('Hello World')
		System.out.println('hello scala java')}
	
}

2 基本语法

2.1 注释

（1）单行注释：//
（2）多行注释：/* * /
（3）文档注释：
/**
*
*/

2.2 变量和常量

1. 基本语法

var 变量名 [:变量类型] = 初始值 var i:Int = 10
val 常量名 [:常量类型] = 初始值 val j:Int = 20
注意：能用常量的地方不用变量
2. 注意
（1）声明变量时，类型可以省略，编译器自动推导，即类型推导
（2）类型确定后，就不能修改，说明 Scala 是强数据类型语言
（3）变量声明时，必须要有初始值
（4）在声明/定义一个变量时，可以使用 var 或者 val 来修饰，var 修饰的变量可改变，val 修饰的变量不可改

var修饰的对象及对象引用可以改变，val修饰的对象则不可变，但对象的引用可变

object TestVar{
	def main(args: Array[String]):Unit = {
		//p1是var修饰的，p1的属性是可变的，p1也是可变的
		var p1 = new Person()
		p1.name = 'dalang'
		p1 = null

		//p2是val修饰的，p2本身不可变（内存地址不能变），但p2的属性是可变的
		val p2 = new Person()
		p2.name = 'jinlian'
		//p2 = null     这样是错误的
	}
}
class Person{
	var name : String = 'jinlian'
}

2.3 标识符的命名规范

（1）以字母或者下划线开头，后接字母、数字、下划线
（2）以操作符开头，且只包含操作符（+ - * / # !等）
（3）用反引号``包括的任意字符串，即使是 Scala 关键字（39 个）也可以

//这些都是可以的
var hello: String = ''
var hello12: String = '123'
var +-*/ : String = ''
var `if`: String = ''

2.4 字符串输出

（1）字符串，通过+号连接
（2）printf 用法：字符串，通过%传值。
（3）字符串模板（插值字符串）：通过$获取变量值

object TestPrint{
	def main(args: Array[String]): Unit = {
		val name : String = "alice"
		val age : Int = 18
		// + 拼接
		println(age + "岁的" + name + "在上学")
		println(name * 3)

		//printf：使用%
		printf("%d岁的%s在上学", age, name)

		//字符串模版：使用s"${变量}"
		println(s"${age}岁的${name}在上学")

		val num : Double = 2.3451
		//格式化模版字符串f" "  Double类型保留两位
		println(f"The num is ${num}%2.2f") //The num is 2.35
		//2.2f   第一个2表示长度不超过2，第二个2表示保留两位小数，f表示浮点类型
		//raw" "是什么就输出什么，不会进行解析
		println(raw"The num is ${num}%2.2f")  //The num is 2.3451%2.2f  是什么就输出什么

		//三引号表示多行的字符串
		val sql = s"""
			|select *
			|from
			|  student
			|where 
			|  name = ${name}
			|and
			|  age > ${age}
			|""".stripMargin
		println(sql)
		}
	}

2.5 键盘输入

基本语法：StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

import scala.io.Source
import java.io.{File, PrintWriter}
object TestStdIn{
	def main(args : Array[String]): Unit = {
		println("请输入您的大名")
		val name : String = StdIn.readLine()
		println("请输入您的芳龄")
		val age : Int = StdIn.readInt()

		//输出
		println(s"欢迎${age}岁的${name}的到来")
		//从文件中读取数据  可以直接输出结果
		Source.fromFile("./data").foreach(println)
		
		//向文件写入数据，scala没有写入文件的，需要借用java
		val writer = new PrintWriter(new file(path = "./output.txt"))
		writer.write("hello scala from java writer")
		writer.close()		
	}
}

2.6数据类型

数据类型：
（1）Scala中一切数据都是对象，都是Any的子类。
（2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。
（3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
（4）Scala中的StringOps是对Java中的String增强
（5）Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是 一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字
（6）Null是一个类型，只有一个对象就是null。它是所有引用类型（AnyRef）的子类。
（7）Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

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

（1）Scala 各整数类型有固定的表示范围和字段长度，不受具体操作的影响，以保证Scala 程序的可移植性。

var n1 : Byte = 127
var n2 : Byte = -128
var n3 : Byte = 128   //会出错代码片

（2）Scala 的整型，默认为 Int 型，声明 Long 型，须后加‘l’或‘L’

var n4 = 12 //这时默认为Int
var n5 = 1234667899999954L //超过了Int，需要声明为Long类型，在后面加'L'或'l'

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

2.8 浮点类型（Float、Double）

Scala 的浮点型常量默认为 Double 型，声明 Float 型常量，须后加‘f’或‘F’。

var n6 = 2.3423f  //默认是Double类型，需要加"F"或"f"指定为Float类型
var n7 = 3.567    //Double类型

2.9 字符类型（Char)

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

val c1 : Char = 'a'

2.10 布尔类型：Boolean

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

var isResult : Boolean = false
var isResult2 : Boolean = true

2.11 Unit类型、Null类型和Nothing类型

（1）Unit类型用来标识过程，也就是没有明确返回值的函数，Unit只有一个实例——()。方法返回空值。
（2）Null类只有一个实例对象，Null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）。空引用
（3）Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。

object TestNull{
	//1. 空值Unit
	def m1(): Unit = {
		println('m1被调用执行')
	}
	val a : Unit = m1()
	println("a: " + a)
	//返回：m1被调用执行   a: ()

	//2. 空引用Null
	var Student: Student = new Student(name = "alice", age = 20)
	student = null   //Student为引用类型，所以可以赋值为null
	println(student) #返回  null

	//3. Nothing ：所有类型的子类
	def m2(n : Int): Nothing = {	//这里要指定为Nothing和Int类型的父类，可以选Int和Any
		if (n == 0)					//为了不那么宽泛，可以选Int
			throw new NullPointException
		else
			return n

	}
	val b : Int = m2(2)
	println("b: " + b)
	//返回   b: 2
}

2.12 类型转换

2.12.1 数值类型自动转换

当 Scala 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：
基本说明：
（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
（3）(byte，short)和char之间不会相互自动转换。
（4）byte, short, char他们三者可以计算，在计算时首先转换为int类型。

2.12.2 强制类型转换

自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。
（1）将数据由高精度转换为低精度，就需要使用到强制转换。
（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先。

var r1 : Int = 2.5.toInt  //直接取整（不论正负，不论向上向下取整，也不会四舍五入）
var r2 : Int = (10 * 3.5 + 6 * 1.5).toInt

2.12.3 数值类型和String类型间转换

（1）基本类型转 String 类型（语法：将基本类型的值+"" 即可）。
（2）String 类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）。

//基本类型转换String
var str1 : String = 100 + ""
var str2 : String = 4.5 + ""
var str3 : String = true + ""

//String类型转基本数值类型(调用相关方法)
var s1 : String = "12"
var s2 : Short = s1.toShort
var s3 : Int = s1.toInt
var s4 : Long = s1.toLong