Scala初学总结

1.什么scala
    Scala是一门以jvm为运行环境并将 面向对象 和 函数式编程 的最佳特性结合在一起的
         静态类型编程语言

2.scala特点？
    Scala是一门多范式的编程语言，Scala支持面向对象和函数式编程
    Scala源代码会被编译成Java字节码，然后运行于jvm之上，并可以调用现有的Java类库，
         实现两种语言的无缝对接
    Scala作为一种语言来说，非常简洁高效
    Scala源于Java，是将函数式编程语言的特点融合到Java中。

3.scala的注意事项？
    Scala源文件以“.scala"为扩展名
    Scala程序的执行入口是object中的main()函数
    Scala语言严格区分大小写
    Scala至简原则。方法由一条条语句构成，每个语句后不需要分号（Scala自动加）
    如果在同一行有多条语句，除了最后一条语句不需要分号，其他语句都需要分号

4.scala的注释？
    单行注释//、 多行注释/* */、 文本注释/**    */

5.scala的关键字？
    package , import , class , extends , type , for ,—— object （对象）, trait （实现）, with
    private , protected , abstract , final , lazy , override ,——sealed , implicit
    try , catch , finally , throw
    if , else , case , do , while , for , return —— match （匹配）, yield
    ——def , val , var （声明变量）
    this , super
    new
    true , false , null

6.scala的变量声明？
    声明变量时，类型可以省略（编译器自动推导类型）
    类型确定后，就不能修改。说明Scala是强数据类型语言
    变量声明时，需要初始值
    在声明/定义一个变量时，可以使用var或者val来修饰，var修饰的变量可改变，
         val修饰的变量不可改
    val修饰的变量在编译后，等同于加上final通过反编译看下底层代码
    var修饰的对象引用可以改变，val修饰的则不可改变，但对象的状态（值）确是可以
         改变的。（比如：自定义对象、数组、集合等等）

7.scala数据类型？
    整数类型：byte（1）、short（2）、int（4）、long（8）
    浮点类型：float（4）、double（8）
    字符类型：char
    布尔类型：Boolean（1）
    unit类型：表示无值，和其他语言中的void等同。unit只有一个实例值，写成（）。
    null类型：null类型只有一个实例值null
    nothing类型：nothing类型在Scala的类层级的最低端，它是任何其他类型的子类型
    Any：Scala 中一切数据都是对象，都是 Any 的子类。

8.scala运算符？
         (一）算术运算符
    + 正号
    - 负号
     + 加
     - 减
    * 乘
     / 除
     % 取模(取余)     eg：7%5 ——>2
    + 字符串相加     eg：“He”+”llo” ——>“Hello”
         （二）关系运算符（比较运算符）——结果是布尔值
    == 相等于
    != 不等于
     < 小于
     > 大于
     <= 小于等于
     >= 大于等于
         （三）逻辑运算符 ——结果是布尔值
    假定：变量 A 为 true，B 为 false
    &&     逻辑与     (A && B) 运算结果为 false
    ||    逻辑或     (A || B) 运算结果为 true
    !     逻辑非      !(A && B) 运算结果为 true
         （四）赋值运算符
    =    简单的赋值运算符，将一个表达式的值赋给一个左值
    +=    相加后再赋值
    -=    相减后再赋值
    *=    相乘后再赋值
    /=    相除后再赋值
    %=    求余后再赋值
    <<=    左移后赋值
    >>=    右移后赋值
    &=    按位与后赋值
    ^=    按位异或后赋值
    |=    按位或后赋值
         （五） 位运算符
    &    按位与运算符
    |    按位或运算符
    ^    按位异或运算符
    ~    按位取反运算符
    <<    左移动运算符
    >>    右移动运算符
    >>>    无符号右移

eg： 0010  << 2   1000

        0001 <<3  2^3

-----------------------------------------------------------------------------------------
9.函数和方法的区别
    1）为完成某一功能的程序指令（语句）的集合，称为函数。
    2）类中的函数称之方法。
    3) 函数没有重载和重写的概念;方法可以进行重载和重写。

10.块语句的特点？
    最后一行可以当作返回值 直接返回

11.函数的几种写法？
    Scala
    /*
    > sum(函数名)
    > (Int,Int) 函数类型
    > (a:Int,b:Int) 函数字面量
    > */
    val sum :(Int,Int) => Int = (a:Int,b:Int) => x+y

    /* 匿名函数*/ (x: Int, y: Int) => x + y
    // 可以赋值给变量 调用 var sum = (x:Int,y:Int) => x + y
    // 可以简写 _ 所有的元素 _ + _

12.函数的参数
    Scala () 参、数
    声明 参数名与类型
    对声明参数名与类型 进行赋值 (默认值)
    最后一个参数可声明位 可变参数 参数类型后跟*

13.函数至简原则
    能省则省
    （1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
    （2）返回值类型如果能够推断出来，那么可以省略
    （3）如果函数体只有一行代码，可以省略花括号
    （4）如果函数无参，则可以省略小括号。若定义函数时省略小括号，则调用该函数时， 也需省略小       括号；若定时函数时未省略，则调用时，可省可不省。
    （5）如果函数明确声明 Unit，那么即使函数体中使用 return 关键字也不起作用
    （6）Scala 如果想要自动推断无返回值，可以省略等号
    （7）如果不关心名称，只关系逻辑处理，那么函数名（def）可以省略
    （8）如果函数明确使用 return 关键字，那么函数返回就不能使用自行推断了，需要声明返回值类           型

14.什么是闭包
    就是一个函数和与其相关的引用环境（变量）组合的一个整体(实体)

15.什么是柯里化
    将一个接收多个参数的函数转化成一个接受一个参数的函数过程，可以简单的理解为
        一种特殊的参数列表声明方式。

16.什么是lazy？
    Lazy懒加载，当被调用得时候才会被执行
    当在创建大的变量，或者执行比较耗时的程序   比如读写数据时执行

-----------------------------------------------------------------------------
17.scala默认导入分别是？
    import java.lang._
    import scala._
    import scala.Predef._

18.scala 的访问修饰符，作用域
    在 Java 中，访问权限分为：public，private，protected 和默认。在 Scala 中，
    你可以通过类似的修饰符达到同样的效果。但是使用上有区别。
    （1）scala 中属性和方法的默认访问权限为 public，但 scala 中无 public 关键字。
    （2）private 为私有权限，只在类的内部和伴生对象中可用。
    （3）protected 为受保护权限，Scala 中受保护权限比 Java 中更严格，同类、子类可以 访问，同包无法访问。
    （4）private[包名]增加包访问权限，包名下的其他类也可以使

19.伴生类和伴生对象？
    Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概 念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象 来模拟类对象，该对象为          单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴 生对象，这个类的所有“静态”内容都          可以放置在它的伴生对象中声明。
    （1）单例对象采用 object 关键字声明
    （2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
    （3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

20.@BeanProperty 特点？
    属性是类的一个组成部分
    基本语法 [修饰符] var 属性名称 [：类型] = 属性值
    注：Bean 属性（@BeanPropetry），可以自动生成规范的 setXxx/getXxx 方法
                       为该属性 提供类似java 的 getter setter 方法

21.scala构造器？
    和 Java 一样，Scala 构造对象也需要调用构造方法，并且可以有任意多个构造方法。
    Scala 类的构造器包括：主构造器和辅助构造器

    class 类名(形参列表) { // 主构造器
        // 类体
         def this(形参列表) { // 辅助构造器 }
        def this(形参列表) { //辅助构造器可以有多个... }
    }
    说明：（1）辅助构造器，函数的名称 this，可以有多个，编译器通过参数的个数来区分。
              （2）辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。

22.内部类访问的方法？
    1) 通过new 外部类 在 new (外部类 ming). 内部类 获取（创建内部类）
    2) 通过外部类方法返回内部类对象    ——————

23.scala apply?
    （1）通过伴生对象的 apply 方法，实现不使用 new 方法创建对象。
    （2）如果想让主构造器变成私有的，可以在()之前加上 private。
    （3）apply 方法可以重载。
    （4）Scala 中 obj(arg)的语句实际是在调用该对象的 apply 方法，即 obj.apply(arg)。用 以同一面          向对象编程和函数式编程的风格。

24.样例类特点？
    1）样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中自动提供了一些常用的方法，如apply、unapply、toString、equals、hashCode和copy。
    2）样例类是为模式匹配而优化的类，因为其默认提供了unapply方法，因此，样例类可以直接使用模式匹配，而无需自己实现unapply方法。
    3）构造器中的每一个参数都成为val，除非它被显式地声明为var（不建议这样做）

25.什么是trait？
    Trait 类中 只能存放 属性方法的 声明定义 (代替java接口 interface)
    Scala 语言中，采用特质 trait（特征）来代替接口的概念，也就是说，多个类具有相同 的特征（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。
    Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可 以混入（mixin）多个特质。
    Scala 引入 trait 特征，第一可以替代 Java 的接口，第二个也是对单继承机制的一种 补充。

26.scala类型检查和类型转换？
    （1）obj.isInstanceOf[T]：判断 obj 是不是 T 类型。
    （2）obj.asInstanceOf[T]：将 obj 强转成 T 类型。
    （3）classOf 获取对象的类名。
    （4）getClass 精确判断
-----------------------------------------------------------------
27.scala集合？
    Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable 特质。

28.集合可变不可变导包？
    对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下 两个包：
    不可变集合：scala.collection.immutable
    可变集合： scala.collection.mutable

29.元组？
    元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。
    说的简单点，就 是将多个无关的数据封装为一个整体，称为元组。
    注意：元组中最大只能有 22 个元素。

-----------------------------------------------------------------
30.java消息队列有哪些？
    目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ等；
    部分数据库如Redis、Mysql以及phxsql也可实现消息队列的功能；
    具有 低耦合、可靠投递、广播、流量控制、最终一致性 等一系列功能。

31.queue 的特点？
    scala 也提供了队列（Queue）的数据结构，队列的特点就是先进先出。
    进队和出队的方 法分别为 enqueue 和 dequeue。

32.模式匹配的用法？
    Scala 中的模式匹配类似于 Java 中的 switch 语法，但是更加强大。
    模式匹配语法中，采用 match 关键字声明，每个分支采用 case 关键字进行声明，当需 要匹配时，
会从第一个 case 分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹 配不成功，继续执行下一个分支进行判断。如果所有 case 都不匹配，那么会执行 case _分支， 类似于 Java 中 default 语句。

33.常用的函数？
    （1）获取集合长度     println(list.length)
    （2）获取集合大小     println(list.size)
    （3）循环遍历     list.foreach(println)
    （4）迭代器     for (elem <- list.iterator) { println(elem) }
    （5）生成字符串     println(list.mkString(","))
    （6）是否包含    println(list.contains(3))

    （1）获取集合的头     println(list1.head)
    （2）获取集合的尾（不是头的就是尾）     println(list1.tail)
    （3）集合最后一个数据     println(list1.last)
    （4）集合初始数据（不包含最后一个）     println(list1.init)
    （5）反转         println(list1.reverse)
    （6）取前（后）n 个元素     println(list1.take(3))     println(list1.takeRight(3))
    （7）去掉前（后）n 个元素     println(list1.drop(3))     println(list1.dropRight(3))
    （8）并集        println(list1.union(list2))
    （9）交集         println(list1.intersect(list2))
    （10）差集     println(list1.diff(list2))
    （11）拉链      println(list1.zip(list2))
    （12）滑窗     list1.sliding(2, 5).foreach(println)

    （1）求和         println(list.sum)
    （2）求乘积     println(list.product)
    （3）最大值     println(list.max)
    （4）最小值     println(list.min)
    （5）排序
    // （5.1）按照元素大小排序     println(list.sortBy(x => x))
    // （5.2）按照元素的绝对值大小排序     println(list.sortBy(x => x.abs))
    // （5.3）按元素大小升序排序     println(list.sortWith((x, y) => x < y))
    // （5.4）按元素大小降序排序     println(list.sortWith((x, y) => x > y))

34.option的子类？Some的取值？
    option 的子类有两个：some  none
    调用some.get()方法