数据类型	描述
Byte	8bit的有符号数字，范围-128~127
Short	16bit,-32768~32767
Int	32bit
Long	64bit
Float	32bit
Double	64bit
Char	16bit Unicode编码，U+0000 到 U+FFFF
String	字符串：序列Seq
Boolean	布尔类型
Unit	表示无值，有点像Java中void。但在scala中的函数使用Unit实际上返回的空元组：()
Null	空引用或空值
Nothing	所有其他类型的类型，表示没有值
Any	所有类型的超类，任何实力都属于Any类型的
AnyRef	所有应用类型的超类

scala拥有和java几乎一样的类型，和java的数据类型的内存布局也完全一致，精度也完全相同。

有关Any和AnyRef的一些说法： val p = new Person(),Person对象（就是p）父类是Any，Person{}的超类就是AnyRef。

3 运算符

和Java类似。

scala的++和--是用于连接两个集合，不是做运算的！

4 流程控制语法

4.1 if表达式

结果是一个空元组，但是if也可以做返回值

4.1.2 if自己本身返回

4.2 循环

4.2.1 breakable语句块

因为Scala没有break，只能使用breakable把语句进行隔离

breakable{}代码块是针对break跳出的范围，break当然也在breakable{}中

4.2.2 for

4.3 异常控制

说明：

scala的异常不需要我们手动抛出，代码底层会处理那些不能避免的异常。

Java遇到不可处理的异常就是throw，scala底层对于不可处理的异常会处理哦！

下面是编写捕获异常的代码，其实try{}catch{}一样，就是里面的异常用了类型匹配

5 函数

函数一般是有返回值的，就是直接放在函数体的最后一行就可以了，不需要写return

5.1 普通函数

5.2 特殊函数

5.2.1 单行函数

所谓单行函数，顾名思义就是只有一行的函数。需要注意的是，单行函数，必须使用"="来作为函数的返回值类型推断。

5.2.2 无参函数

参数列表为空的函数，（）可以省略，如果（）省略，那调用的时候（）也要省略。

5.2.3 默认参数函数

就是函数的参数列表中直接赋值给参数，这样调用函数的时候就可以不用赋值啦。

5.2.4 带名参数的函数

就是调用函数的时候直接声明函数参数名调用啦。

5.2.5 可变参数

我们先回顾一下java的可变参数

其实scala的可变参数就是对数组可变参数的一种表示而已了。

6 集合类型

6.0 集合体系

Iterable: 其中Iterable是所有集合的根trait。
Seq(IndexSeq): 指一个有先后顺序的的序列，比如数组或者列表（List）。IndexSeq允许我们通过下标索引快速访问任意元素的序列。比如：ArrayBuffer。链表也是序列，链表不是IndexSeq。
Set(SortedSet)：是一组没有先后顺序的集合。但是sortedSet中，元素可以某种排序被访问。
Map(SortedMap)：一组对偶。

6.1 数组

6.1.1 可变的: ArrayBuffer : 理解为java的ArrayList

6.1.2 不可变的：Array:理解为java的普通数组

6.1.3 通用操作

6.2 Map

Map是一种对偶，映射的k-v键值对的集合，k不重复，v是可以重复的。map也分为可变和不可变

6.2.1 不可变

import scala.collection.immutable.Map是一个trait。无法直接new，需要使用伴生对象方式创建对象

6.2.2 可变

import scala.collection.mutable.Map

6.2.3 通用操作

6.3 列表

6.3.1 List ：不可变

6.3.2 ListBuffer : 可变

6.4 Set

7 面向对象语法

7.1 类的定义

类或者类型，就是对客观的一类事物的抽象。用class关键字来描述，一个类中包含了属性和行为。因为类表示对一类事物的抽象，所以不具备行为的执行能力，要想完成具体的操作，就需要使用该类的实例或者对象。

7.2 Getter/Setter操作

7.2.1 @BeanProperty

7.3 类的构造器

7.3.1 java中的构造器

类的构造器，在java中一个类的构造器，可以分为有参构造器和无参构造器，或者默认构造器的说法。所谓默认构造器指用户不指定构造器，JVM会自动的为我们的类添加无参的构造器，用于创建对象。

在java中的一个类，可以拥有若干个构造器，既可以拥有无参构造器，也可以拥有有参构造器，如果用户提供了构造器，那么JVM就不会再提供默认构造器了。

public class Person {

public Person() {} // 构造器

}

7.3.2 scala中的构造器

主构造成员的另一种申明方式

7.4 内部类

在类中定义的类，就是内部类。

7.4.1 Java

7.4.2 Scala

7.5 object关键字

7.5.1 Java单例

单例的目的就是了只有一个对象，无论创建几个实例都是同一个对象

饿汉

懒汉（线程不安全啊）

解决线程安全问题，就是加锁，同步锁

7.5.2 Scala单例

饿汉

懒汉

7.5.3 伴生对象

伴生类：相对于object来说我们称class为伴生类。

伴生对象：相对于class来说我们称object为伴生对象。

伴生对象主要作用，就是为半生类提供类似于java的静态成员、方法；还提供了另一种对象的创建方式。

tip:

要想使用伴生对象创建本类的对象，必须要让本伴生对象创建apply方法，该apply方法的参数列表对应的是本类构造器的参数列表
伴生对象，不仅可以访问对应伴生类的非私有成员，同时还可以访问对应伴生类的私有成员
伴生对象的使用，在scala中使用非常广泛。在使用scala基础之上的框架的时候几乎都要这么用，特别是后面的spark、flink都是。

7.6 类的继承

7.6.1 继承的基本语法

7.6.2 类型检查和类型转换

java

scala

equals另一种重写

7.6.3 抽象类

基本定义

 package com.qf.bigata.scala
 
 object Demo25_Abs {
   def main(args: Array[String]): Unit = {
 
   }
 }
 
 abstract class Cat {
   var color:String = _
   def dead():Unit = println("猫固有一死，或清蒸，或火烧~")
   abstract def sleep() // 抽象方法
   def bark() // 抽象方法
 }
 
 class BossCat extends Cat {
   override def sleep(): Unit = println(s"波斯猫趴着睡")
   override def bark(): Unit = println("喵~~~")
 }

抽象字段

 abstract class Cat {
   var color:String = _
   abstract var name:String // 抽象字段
   def dead():Unit = println("猫固有一死，或清蒸，或火烧~")
   abstract def sleep() // 抽象方法
   def bark() // 抽象方法
 }
 
 class BossCat extends Cat {
   override def sleep(): Unit = println(s"波斯猫趴着睡")
   override def bark(): Unit = println("喵~~~")
 
   override var name: String = "波斯猫"
 }

7.6.4 trait：特质

7.7 函数式编程

7.7.1 将函数作为值

7.7.2 匿名函数

7.7.3 将函数作为参数的函数(重要)

7.7.4 参数/类型推断

7.7.5 常见的高阶函数

7.7.5.1 filter

7.7.5.2 map

7.7.5.3 flatMap

7.7.5.4 foreach

7.7.5.5 reduce

7.7.5.6 dropWhile

7.7.5.7 sortWith

7.7.5.8 groupBy

7.7.5.9 partition

 println(s"-----------partition-------------->> 对集合进行了partition处理---------------------->>")
 val (left, right) = slist.partition(_ <= 0)
 println(left.mkString(","))
 println(right.mkString(","))

7.7.6 闭包：closesure

 package com.qf.bigata.scala
 
 object Demo31_Closure {
 
   /*
    * 闭包函数
    */
   def mulBy(factor:Double) = (x:Double) => factor * x
 
   val triple = mulBy(3) // triple = (x:Double) => 3 * x
   val half = mulBy(0.5) // half = (x:Double) => 0.5 * x
 
 
   def main(args: Array[String]): Unit = {
     println(triple(14) + "--->" + half(14)) // 42 ---> 7 3 * 14 --> 0.5 * 14
     println(mulBy(3)(14) + "--->" + mulBy(0.5)(14))
   }
 }

 def a(num:Int):Int = { // 范围更大
     def b(factor:Double):Double = { // 范围较小
         var res = num * factor
         println(res)
         res
     }
     b(1.0).toInt
 }

 object Test {
     def main(args: Array[String]) {
         println("mul(1) value = " + mul(1))
         println("mul(2) value = " + mul(2))
     }
        
     var factor = 3
     val mul = (i:Int) => i * factor
 }

Scala入门编程复盘

1 Scala与java的关系

2 Scala的数据类型