Scala 01-- （简介，安装，基本语法）

一、Scala的简介

1.1 scala的简介

1. Martin Odersky在2001年开始设计的，Java平台的Scala于2003年底/2004年初发布。
2. Scala名字由来：Scalable Language两个单词相结合；意大利语中 scala意为“梯子”或“楼梯”，蕴含“更佳的编程语言”。 
3. 设计目标是将面向对象、函数式编程和强大的类型系统结合起来，让人要能写出优雅、简洁的代码。

1.2 scala的特点

1. 具有面向对象的特点
2. 具有函数式编程的特点
3. 具有静态类型的特点，也就是在编译期检查语法
4. 扩展性比较好
5. 并发性，scala使用的是actor的并发模型

1.3 函数式编程的简介

1. 函数式编程也是一种编程范式（范式就是编程思想）
2. scala函数是一等公民：指的是函数与其他数据类型一样，处于平等地位，可以赋值给其他变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值
3. scala以表达式为中心  
4. scala函数无副作用：只用纯函数来构造程序，或者说函数没有副作用。
   一个函数在程序执行过程中除了根据输入参数给出运算结果外，没有其他的影响，就称为没有副作用的。
5. 引用透明：函数的运行不依赖于外部变量或"状态"，只依赖于输入的参数，任何时候只要参数相同，引用函数所得到的返回值总是相同的。
6. Lambda表达式、闭包、高阶函数、柯里化
7. 递归与尾递归

总之，函数式编程的优点，代码简洁，开发快速；接近自然语言，易于理解；更方便的代码管理；易于"并发编程"

1.4 语言的类型

1.4.1静态语言和动态语言

静态编译语言：事先声明变量类型，类型不能改变，编译时检查；
动态编译语言：不用事先声明类型，随时可以赋值为其他类型，编程时不知道什么类型，很难推断；
静态语言和动态语言关键区别是何时获得类型信息，是在编译时间还是运行时间。

1.4.2强类型和弱类型

强类型语言：不同类型之间操作，必须强制类型转换为同一类型，print('a'+1):
弱类型语言：不同类型间可以操作，自动隐式转换。
强类型和弱类型语言的区别关键是类型之间的区别是否严格，例如语言是否会做字符串类型到数字类型的隐式转换。

二、Scala的安装

2.1 windows平台的安装

1. 去官网下载scala-2.11.8.msi(安装版本，需要点击下一步安装)或者scala-2.11.8.zip(解压版本，解压后就可以使用)
2. 安装到你喜欢的目录下，比如C:\Program File(x86)\
3. 配置环境变量（可以在用户变量下，也可以在系统变量下）
	变量名：SCALA_HOME
    变量值：C:\Program File(x86)\scala
    变量名：PATH
    变量值: 以追加的方式，添加一个scala的bin目录，比如C:\Program File(x86)\scala
4. 打开命令提示符界面，输入scala -version 检查版本号   
5. 也可以输入scala,直接回车，进入命令行交互界面（REPL）

2.2 idea与scala的整合

2.2.1 离线安装(网络好的情况下，也可以在线安装)

1. 去idea的插件官网上下载相应版本的scala插件，注意版本号的问题，应该看一下idea版本与哪一款scala插件兼容，下载兼容的那一款。
	官网：https://plugins.jetbrains.com/plugin/1347-scala
2. 将下载后的插件放入某一个目录下，比如idea软件自己的plugins目录下，创建一个scala目录来存储
   如：D:\Users\Michael\Documents\IntelliJ IDEA 2019.3.1\plugins\scala\scala-intellij-bin-2019.3.23.zip

3. 打开idea, file-->settings-->plugins-->找到车轮图标里的install plugin from disk。
   然后选中步骤2里的插件，然后重启idea  

创建一个maven项目

1. 创建项目
2. 添加scala框架支持，选择windows上安装的scala安装路径
3. 在main目录下新建一个文件夹scala, 然后mark directory as Sources Root
4. 在scala目录下创建一个scala class. 注意：选择object
5. 打印helloworld

package com.qf.scala.day01

object Demo01 {
  def main(args: Array[String]): Unit = {
    print("hello world")
  }
}

2.3 linux平台的安装

1. 在scala官网上下载scala-2.11.8.tgz

2. 上传，解压，[更名]，配置环境变量
[root@qianfeng01 ~]# tar -zxvf scala-2.11.8.tgz -C /usr/local/
[root@qianfeng01 ~]# cd /usr/local/
[root@qianfeng01 local]# vim /etc/profile
    ..........省略..........
    # scala  environment
    export SCALA_HOME=/usr/local/scala-2.11.8
    export PATH=$SCALA_HOME/bin:$PATH
3. 测试版本号： 
[root@qianfeng01 local]# scala -version
Scala code runner version 2.11.8 -- Copyright 2002-2016, LAMP/EPFL

三、Scala基础语法

3.1 scala解释器

1. scala解释器，指的就是命令行交互界面，也称之为REPL
    (Read（取值）-> Evaluation（求值）-> Print（打印）-> Loop（循环）。)

案例演示1：

scala> 1+1
res0: Int = 2       

解析：  输入的1+1 我们称之为表达式，   会输出结果res0: Int = 2
res0: 是scala解释器提供的内置变量,也可以继续使用它运算，比如

scala>res0*2.0
res1: Double = 4.0

注意：如果没有指定变量的类型，scala会自动推断变量的类型。

案例演示2：编译并执行scala程序

1. 准备工作，在D盘下创建一个scala目录，然后创建一个a.scala文件，编写一个输出hello world的经典小程序
   object HelloWorld{
    def main(args: Array[String]): Unit={
	    println("HelloWorld")
	}
   }
2. 在cmd中切换到D:/scala目录下
3. 编译scala源文件
   D:\scala>scalac a.scala      注意：编译时要写源文件的具体名字。
4. 运行字节码文件
   D:\scala>scala HelloWorld    注意：运行时要写字节码文件的具体名字

3.2 编程规范

1. scala源文件的后缀名必须是.scala
2. 源文件的名字最好和文件内部的最上面的类型名一致。
3. 源文件的字符集最好是UTF-8
4. 使用驼峰命名法，尽量见名知意(望文知意)
5. 使用空格代替tab键，最好是4个空格
6. 单行建议不超过150个字符，不超出可视范围
7. 花括号的用法：
    - 左花括号（{）前不能换行，在其后换行。
    - 在右花括号（}）前要有换行。
    - 如果右花括号是一句语句、一个方法、构造函数或非匿名类的结尾，其后需要换行。
8. scala中的简单表达式可以省略括号
9. 空行的使用： 主要目的就是做逻辑分组
    成员变量 和构造方法，和普通方法 之间使用空行隔开，显的比较优雅，好看
10. 注释：
    单行注释：  //
    多行注释：  /*   */
    文档注释：  /**  */

3.3 scala类型的讲解

3.3.1 类型的层次结构（重点）

3.3.2 变量的使用

1. 变量的命名规则与java的一致，数字不能开头
2. 驼峰命名法，见名知意
3. 使用val或var声明变量，声明时必须初始化。
4. 在变量声明时，可以不指定类型，scala会自动推断变量的类型。也可以指定类型。
5. val声明的变量，相当于在变量前加了一个final，表示最终的值，就是不能再次修改值。
   如果就是想要同一个变量，赋一个新值，就必须在添加val声明。
6. var声明的变量，可以再次被赋值。
7. 官方建议使用val。
   - 更安全
   - 代码可读性更高
   - 资源回收更快，方法执行完，val所定义的变量即回收

3.3.3 整型类型

四个整型类型，分别是Byte,Short,Int,Long。相当于java的四个包装类，这些类型的值都可以调用自己的方法，比如：

val numStr:String = 10.toString()   //将10转成了字符串类型

val r1 = 1.to(10)      //获取一个Range对象
r: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

注意事项：

1. 在定义变量时，如果不明确指定类型，整型会默认推断成Int类型，不可以超范围的赋值，除非明确指定类型
2. 小于Int类型的数值做运算时，会自动隐式转换成Int类型，然后再做运算，结果是Int类型

3.3.4 浮点型

1. 有两个浮点型，分别是Float和Double。 
2. 在给变量赋值时，如果没有明确指定类型，则是Double类型，如果想要赋值为Float，则需要添加F/f
3. 两个浮点型相加时，其结果通常情况下是不精确的。
4. 案例：
	- 十进制数形式：如：5.12       512.0f        .512   (必须有小数点）；
	- 科学计数法形式:如：5.12e2  = 5.12乘以10的2次方     5.12E-2  = 5.12除以10的2次方。

3.3.5 字符类型

1. 赋值方式有两种，分别是使用单引号或者是unicode对应的整数（0-65535）
   val ch1 = 'A'
   val ch2:Char = 65
2. 也可以使用16进制的方式，注意：8进制已经被弃用了 
   val ch3 = '\u0041'     //显示的就是A

3.3.6 布尔类型

布尔类型只有两个值,分别是true和false.
val flag = true
val flag:Boolean = false
val flag:AnyVal = false
val flag：Any = true

3.3.7 字符串类型

1. 赋值特点必须使用双引号
2. 双引号中如果有特殊字符，需要使用转义符号\
   比如，想要赋值一个变量为\"'。 那么写法如下
   val str = "\\\"\'"
3. scala里引入了三层双引号，引号里是什么，就是什么
    println("""welcome to 
               "1000phone".""")
4. scala的字符串类型其实就是java的String类型
	"hello".getClass().getName()
	"hello".getClass.getName

3.3.8 其他类型

Unit类型：

相当于java中的void类型。
赋值方式使用（）
val a = ()

Any类型：

是所有类型的父类、超类、基类

AnyVal类型和AnyRef类型

是Any类型的两个子类型

Null类型：

是所有的AnyRef类型的子类型，只有一个实例就是null

Nothing类型

Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
当一个函数，我们确定没有正常的返回值，可以用Nothing 来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

  def a:Nothing = {
     throw new Exception
  }

Option类型：用于表示有值或者是无值。有值则是Some(xxxx)，无值就是None。 Some和None是Option类型的两个实例。

scala> val myMap: Map[String, String] = Map("name" -> "zhangsan","age"->"23")
myMap: Map[String,String] = Map(name -> zhangsan, age -> 23)

scala> val value1: Option[String] = myMap.get("name")
value1: Option[String] = Some(zhangsan)

scala> val value1: Option[String] = myMap.get("address")
value1: Option[String] = None

3.3.9 类型转换

1. 自动类型转换：小范围类型转大范围类型，会自动转换。也叫隐式转换
   val a:Long = 19   //Int的19 自动转成了Long类型的19
   val b:Double = a  //Long类型的a里的值转成了Double类型的b里的值。
2. 强制类型转换：大范围类型转小范围类型，需要强制转换，在scala中要调用方法
   比如：
   "19.9".toDouble
   "19".toInt
   "19".toDouble

 def main(args: Array[String]): Unit = {
      val a = 3  // 0000 0011
      val b = 10 // 0000 1010
      println(a&b)   //0000 0010   // 全1为1
      println(a|b)   //0000 1011   // 有1为1
      println(a^b)   //0000 1001    // 相同为0，不同为1
  }

3.4 scala操作符

1. 算术操作符
2. 关系操作符
3. 逻辑运算符
4. 位运算符
5. 赋值运算符
6. 运算符优先级
7. 注意事项：  scala操作符都是方法。 比如 a+b  其实底层会转成a.+(b)

3.5 SCALA表达式（重点）

1. 什么是scala表达式
	表达式就是一个语句块，包含一条或者多条语句
    特点：
    （1）表达式有返回值
    （2）返回值是表达式最后一条语句的执行结果
2. 常见的scala表达式
	- 块表达式
	- if表达式
	- 循环表达式
	- 异常表达式
	- Actor
3. 块表达式	
    - 即{}块，其内部包含了一系列的表达式。
    - 块是有返回值的，块中最后的表达式值，就是块的值。
    - 赋值语句本身返回unit类型，如果块的最后一个语句是赋值语句，则块的值返回()
    - 块里的变量在块外不可见

3.6 分支结构

1. 共有三种写法，分别是单分支，双分支else，多分支else if。
2. 执行逻辑是某一个分支的条件表达式为true时才会执行，然后后续的分支直接跳过。
3. if分支是有返回值的。返回值的特点是多个块表达式返回值的共同父类型。

达式有返回值
（2）返回值是表达式最后一条语句的执行结果
2. 常见的scala表达式
- 块表达式
- if表达式
- 循环表达式
- 异常表达式
- Actor
3. 块表达式
- 即{}块，其内部包含了一系列的表达式。
- 块是有返回值的，块中最后的表达式值，就是块的值。
- 赋值语句本身返回unit类型，如果块的最后一个语句是赋值语句，则块的值返回()
- 块里的变量在块外不可见

## 3.6 分支结构

1. 共有三种写法，分别是单分支，双分支else，多分支else if。
2. 执行逻辑是某一个分支的条件表达式为true时才会执行，然后后续的分支直接跳过。
3. if分支是有返回值的。返回值的特点是多个块表达式返回值的共同父类型。