scala的简单总结

scala的简单总结

一、scala的概述

1.1学习Scala的原因

spark需要scala来编写

1.2scala诞生小故事

创始人：Madin Ordersky

1.3Scala和Java以及JVM的关系图

使用相同的类库、各有自己的编译器、都要转为xxx.class，再到JVM上运行

1.4Scala语言的特点

Scala是一门以java虚拟机(JVM)为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。

1）多范式（面对对象和函数式）

2）被编译为java字节码（.class）

3）三元运算符（++ --）

1.5各种操作系统环境下搭建Scala

略

1.6Scala开发工具介绍

1)IDEA

2)Scala插件

1.7Scala快速入门（idea-hello工程）

1）maven

2）add framework support——引入Scala框架

3）src-main-scala为源文件目录（初次使用需要source root）

1.8Scala执行流程

待补充

1.9Scala注意事项（重）

1）源文件为xxx.scala

2）入口为main（）

3）严格区分大小写（重）

4）无需分号，自动加入

5）单行多语句初最后一行都需要分号

1.10Scala转义字符

同C（\t,\r,\,\n……）

1.11Scala语言输出的三种方式

1)字符串加号连接（print（str1 + str2））

2)%传值（类C）

3）$引用变量（类php）

print（s"name = $str1 age = ${num + 1}"）

1.12查看源码关联

1）ctrl + b

2）没有（待补充）

1.12注释

1）单行

//……

2）多行

“/* 注释内容 */”

3）文档

多行注释嵌套

1.13良好的编程规范

1）tab 与 shift tab实现缩进

2）cttrl + alt + L实现一键规范

3）运算符两边空格

4）单行不超80字符

二、变量

2.1变量是程序的基本单位

2.2变量的使用

1）声明变量（Scala要求声明变量时初始化）

val | var 变量名 [:变量类型] = 变量值（类型可以省略—类型推导）

var age ：Int （或double） = 10

Scala中整数默认为int，小数默认为double

2）注意事项

• 声明变量时，类型可以省略（编译器自动推导）
• Scala是强类型语言，类型确定后不能修改
• val修饰不可改变变量，var修饰可改变变量

3）val对象的状态可以改变（待议）

2.3变量之间的“+”

1）左右为数值时做加法

2）左右为字符串时做连接

2.4数据类型

1）Scala与Java有着相同的数据类型，Scala中的数据类型都是对象

2）Scala类型分为两大类AnyVal（值类型）与AnyRef（引用类型）

3）数据类型一栏图

几点说明

Null是一个特别类型，只有一个null值

Nothing是所有类的子类，常用它返回任意值或函数，常异常返回值

def sayhello ：Nothing = {

​ throw new Exception(“抛出异常”)

}

4）Scala中支持低精度值向高精度值自动转换（隐式转换）

2.5整数类型

Bety | Short | Int | Long （声明为Long型时数字后加“l | L”）

2.6浮点类型

Float | Double （声明为Float，时数字后加“f | F”）

2.7字符类型

char字符 | Unicode字符

使用细节

char----‘’单引号

转义字符-----\

char类型可以进行计算（有自己的Unicode）

2.8布尔类型

值为 ture | false （占一个字节）

2.9Null类型、Unit类型、Nothing类型使用技巧

待补充

2.10值类型转换

1）隐式转换

2）自动提升原则

3）byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型

2.11高级隐式转换和隐式函数

略

2.12强制类型转换

将精度大的转换为精度小的，可能造成精度溢出

scala : var num : Int = 2.7.toInt //对象

Char 类型可以保存 Int 的常量值，但不能保存 Int 的变量值，需要强转

Byte 和 Short 类型在进行运算时，当做 Int 类型处理

2.13值类型和 String 类型的转换

1）基本类转String类

语法： 将基本类型的值+"" 即可

eg；val num = d1 + “” //以后看到有下划线，就表示编译器做了转换

2）String类型转其他类型

val num = d1.toSting

3）注意

• 确保String类型有效

2.14命名规范

1）标识符；和Java一样

2）包名：尽量采取有意义的包名，简短，有意义

3） 变量名、函数名 、方法名 采用驼峰法

4）注意关键字

三、运算符

3.1运算符种类

• 算数运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符
• 位运算符

3.2算数运算符

与Java一样，特别注意+可以连接字符串

没有++和–，可用+=和-=来实现

注意 “/”分为整数除和小数除

3.3赋值运算符

使用与Java一样

3.4逻辑运算符

• &&逻辑与
• ||逻辑或
• ！逻辑非

3.5赋值运算符

1）常规：=、+=、-=、*=、/=、%=

2）特殊：

3）赋值运算符的特点

• 从右往左
• 左边只能是变量，右边可以是变量、表达式、常量值、字面量

3.6位运算符

1）与Java一样

2）&、|、^、~

3）<<左、>>右移、>>>无符号右移

4）Scala不支持三目运算符

3.7运算符优先级

3.8键盘输入语句

import scala.io.StdIn

val name = StdIn.readLine()//读入字符串

val age = StdIn.readInt()//读入整型

val sal = StdIn.readDouble()//读入double型

四、程序流程控制

4.1程序流程分类

1）顺序控制

2）分支控制

3）循环控制

4.2顺序控制

4.3分支控制

1）单分支

if（条件）{语句体}

2）双分支

if（条件）{语句体1}

else {语句体2}

3）多分支

if（条件）{语句体1}

else if（条件）{语句体2}

……

else {语句体n}

4）if else注意事项

• 如果大括号{}内的逻辑代码只有一行，大括号可以省略, 这点和 java 的规定一样
• Scala 中任意表达式都是有返回值的，也就意味着 if else 表达式其实是有返回结果的，具体返回 结果的值取决于满足条件的代码体的最后一行内容

4.4嵌套分支

最多不超过三层

4.5switch分支

在 scala 中没有 switch,而是使用模式匹配来处理（match -case）

4.6for循环介绍

1）范围循环控制1

for (i<- 1 to 10) ——i 将会从 1-10 循环， 前后闭合

2）范围循环控制2

for (i<- 1 until 10) ——i 将会从 1-9 循环， 前闭后开

3）循环守卫

for(i <- 1 to 3 if i != 2)

循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环体内部，为 false 则跳过，类似于 continue

4）引入变量

for(i <- 1 to 3; j = 4 - i) { print(j + " ") }

等价于：

for ( i <- 1 to 3) { val j = 4 –i print(j+"") }

5）嵌套循环

for(i <- 1 to 3; j <- 1 to 3)

6）循环返回值

val res = for(i <- 1 to 10) yield i

println(res)

将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字

待学习

7）使用花括号{}代替小括号()

{}和()对于 for 表达式来说都可以 for 推导式有一个不成文的约定：

当 for 推导式仅包含单一表达式时使用圆括号，

当其包含多个表 达式时使用大括号

当使用{} 来换行写表达式时，分号就不用写了

4.7控制步长

new Range(start, end, step)

scala 的 for 循环的步长如何控制! [for(i <- Range(1,3,2)]

控制步长的第二种方式-for 循环守卫

for (i <- 1 to 10 if i % 2 == 1)

4.8while循环

循环变量初始化

while（循环条件）{

​ 循环体

​ 循环变量迭代

}

说明

• 与 If 语句不同，While 语句本身没有值，即整个 While 语句的结果是 Unit 类型的()
• 需要在循环外部声明变量，等同于影响了内部变量，因此不推荐使用

4.9do while循环

和while一样，do的加入和Java也是一样

4.10多重循环

循环之间的相互嵌套

4.11 循环的中断

Scala 内置控制结构特地去掉了 break 和 continue，是为了更好的适应函数化编程，

推荐使用函数式的风格解决 break 和 continue 的功能，而不是一个关键字。

continue可以用循环守卫来实现

五、函数式编程基础

5.1几点说明

1）函数的创建不用依赖于类或者对象，而在 Java 当中，函数的创建则要依赖于类、抽象类或者 接口

2）scala 中函数式编程和面向对象编程融合在一起

3）函数式编程中，将函数也当做数据类型，

4）如果没有 return ,默认以执行到最后一行的结果作为返回值

5.2函数的定义

def 函数名 ([参数名: 参数类型], …)[[: 返回值类型] =] { 语句… return 返回值 }

5.3函数调用机制

待补充

5.4函数的递归调用

函数递归遵守的几点重要原则

程序执行一个函数时，就创建一个新的受保护的独立空间(新函数栈)

函数的局部变量是独立的，不会相互影响

递归必须向退出递归的条件逼近

当一个函数执行完毕，或者遇到 return，就会返回，遵守谁调用，就将结果返回给谁

5.5函数注意事项

1)函数的形参列表可以是多个, 如果函数没有形参，调用时 可以不带()

2)形参列表和返回值列表的数据类型可以是值类型和引用类型

3)Scala 中的函数可以根据函数体最后一行代码自行推断函数返回值类型。因此，

• return 关键字可以省略

• 因为 Scala 可以自行推断，所以在省略 return 关键字的场合，返回值类型也可以省略

• 如果写了 return ,返回值类型就不能省略

• 如果你什么都不写，即使有 return 返回值为()

• 如果函数明确声明无返回值（声明 Unit），那么函数体中即使使用 return 关键字也不会有返回 值

  4）如果明确函数无返回值或不确定返回值类型，那么返回值类型可以省略(或声明为 Any

  5）Scala 语法中任何的语法结构都可以嵌套其他语法结构(灵活)，函数中可以再声明/定义函数， 类中可以再声明类 ，方法中可以再声明/定义方法

  6）Scala 函数的形参，在声明参数时，直接赋初始值(默认值)，这时调用函数时，如果没有指定实 参，则会使用默认值。如果指定了实参，则实参会覆盖默认值

  7）如果函数存在多个参数，每一个参数都可以设定默认值，那么这个时候，传递的参数到底是覆盖默认值，还是赋值给没有默认值的参数，就不确定了(默认按照声明顺序[从左到右])。在这种情况下， 可以采用带名参数来覆盖指定的参数

  8）递归函数未执行之前是无法推断出来结果类型，在使用时必须有明确的返回值类型

  9）Scala 函数支持可变参数

  支持 0 到多个参数

  def sum(args :Int*) : Int = { }

  支持 1 到多个参数

  def sum(n1: Int, args: Int*) : Int = { }

  args 是集合

  sum(10, 30, 10, 3, 45, 7)//调用sum

  def sum(n1: Int, args: Int*): Int = {

  var sum = n1

  for (item <- args) { sum += item }

  sum

  }

5.6过程

1）基本概念：将返回类型为Unit的函数称为过程，

2）注意：如果函数声明时没有返回值类型，但是有 = 号，可以进行类型推断最后一行代码。 这时这个函数实际是有返回值的，该函数并不是过程

5.7惰性函数

1）基本概念：当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。 这种函数我们称之为惰性函数

待补充

2）注意事项

• lazy 不能修饰 var 类型的变量
• 我们在声明一个变量时，如果给 声明了 lazy ,那么变量值得分配也会推迟

5.8异常

1）Scala 提供 try 和 catch 块来处理异常。try 块用于包含可能出错的代码。catch 块用于处理 try 块中发 生的异常。可以根据需要在程序中有任意数量的 try…catch 块

2）Java的处理异常

• java 语言按照 try—catch-catch…—finally 的方式来处理异常
• 不管有没有异常捕获，都会执行 finally, 因此通常可以在 finally 代码块中释放资源
• 可以有多个 catch，分别捕获对应的异常，这时需要把范围小的异常类写在前面，把范围大的异 常类写在后面，否则编译错误

3）Scala的处理异常

待补充

4）Scala处理异常小结

• 我们将可疑代码封装在 try 块中。 在 try 块之后使用了一个 catch 处理程序来捕获异常。如果发 生任何异常，catch 处理程序将处理它，程序将不会异常终止
• 用 throw 关键字，抛出一个异常对象。所有异常都是 Throwable 的子类型。throw 表达式是有类 型的，就是 Nothing，因为 Nothing 是所有类型的子类型，所以 throw 表达式可以用在需要类型的地方
• 在 Scala 里，借用了模式匹配的思想来做异常的匹配，因此，在 catch 的代码里，是一系列 case 子句来匹配异常，当匹配上后 => 有多条 语句可以换行写
• 越具体的异常越要靠前，越普遍的异常越靠后
• finally 子句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清 理工作，这点和 Java 一样
• Scala的异常声明（待补充）

六、面向对象编程（基础）

七、面向对象编程（中级）

八、面向对象编程（高级）

九、隐式转换与隐式值

十、数据结构（上）

十一、数据结构（下）

十二、模式匹配

十三、函数式编程（高级）

十四、使用递归的方法去思考和编程

cala处理异常小结

• 我们将可疑代码封装在 try 块中。 在 try 块之后使用了一个 catch 处理程序来捕获异常。如果发 生任何异常，catch 处理程序将处理它，程序将不会异常终止
• 用 throw 关键字，抛出一个异常对象。所有异常都是 Throwable 的子类型。throw 表达式是有类 型的，就是 Nothing，因为 Nothing 是所有类型的子类型，所以 throw 表达式可以用在需要类型的地方
• 在 Scala 里，借用了模式匹配的思想来做异常的匹配，因此，在 catch 的代码里，是一系列 case 子句来匹配异常，当匹配上后 => 有多条 语句可以换行写
• 越具体的异常越要靠前，越普遍的异常越靠后
• finally 子句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清 理工作，这点和 Java 一样
• Scala的异常声明（待补充）

六、面向对象编程（基础）

七、面向对象编程（中级）

八、面向对象编程（高级）

九、隐式转换与隐式值

十、数据结构（上）

十一、数据结构（下）

十二、模式匹配

十三、函数式编程（高级）

十四、使用递归的方法去思考和编程