一些关于scala的基础问题

（如有错误，欢迎指正）

1.Scala怎样声明变量与常量？

声明变量：var （声明后是可变的）
声明常量：val （声明后不可变）
对val修饰的值赋值会报错。

scala> val a=1
a: Int = 1

scala> a=2
<console>:12: error: reassignment to val
       a=2
        ^

2.Scala数据类型有哪些？

数据类型有：
Byte，Short，Int，Long，Float，Double，Char，String，Boolean，Unit，Null，Nothing，Any，AnyRef。

3.String 对象是可变还是不可变？假如要创建一个可以修改的字符串，应该使用哪个类？

在 Scala 中，String 是一个不可变的对象，所以该对象不可被修改。这就意味着你如果修改字符串就会产生一个新的字符串对象（Scala没有自己的String类型，用的是java的java.lang.String）。
可修改的字符串可以使用StringBuffer和StringBuilder。

4.转义字符用什么符号？（第一个字母是什么符号？）

用的是反斜杠“\”。（\n,\t…）

5.IF…ELSE 语法是什么？

if(布尔表达式)
{
   // 如果布尔表达式为 true 则执行该语句块
} else {
   //如果布尔表达式为 false 则执行该语句块
}

6.循环语句哪三种，分别语法是什么？怎样退出循环？

大部分语言的循环语句都相似，Scala也不例外。

循环类型	描述
while 循环	运行一系列语句，如果条件为true，会重复运行，直到条件变为false。
do…while 循环	类似 while 语句区别在于判断循环条件之前，先执行一次循环的代码块。
for 循环	用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。

循环语句都有判断条件，一但判断条件结果是false，就会退出循环。

7.函数中 Unit是什么意思？

Scala中的Unit类型类似于java中的void。

scala> val a : Unit = ""
<console>:11: warning: a pure expression does nothing in statement position
       val a : Unit = ""
                      ^
a: Unit = ()

scala> a

scala> b
<console>:12: error: not found: value b
       b
       ^

如果给一个Unit类型的赋字符串，会报错，并且自动赋值成”()”，这是因为Scala的Unit类型是可以有值的，而java中是没有void类型的值的。

8.Scala怎样定义一个不带入参，不返回值的函数

def printMe( ) : Unit = {
   println("Hello, Scala!")
}

不带入参的函数是可以省略小括号的，但是省略之后在调用的时候也不能带小括号。
定义的无入参函数如果是带小括号的，那么调用的时候可以带也可以不带。（有入参的函数定义时必须有小括号）

9.Scala怎样定义一个带入参，返回值的函数

def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }

return可以省略（Scala默认最后一行是返回值，具体情况见第12题）。

10.什么是闭包？

如果函数入参只有一个，但是函数内的代码块有两个或更多参数，正常情况下定义这个函数：

scala> def add1(x:Int) = x + y
<console>:11: error: not found: value y
       def add1(x:Int) = x + y
                             ^

或者匿名函数

scala> val add2 = (x:Int) => x + y
<console>:11: error: not found: value y
       val add2 = (x:Int) => x + y
                                 ^

都会报错。
但是，如果在定义函数之前已经定义了用到的参数：

scala> var y = 1
y: Int = 1

scala> def add1(x:Int) = x + y
add1: (x: Int)Int

scala> add1(3)
res0: Int = 4

scala> val add2 = (x:Int) => x + y
add2: Int => Int = $$Lambda$1050/611639121@2864d34d

scala> add2(3)
res1: Int = 4

那么就不会报错，并且可以正常调用。
通过引入一个自由变量 y，这个变量定义在函数外面，那么定义的函数与变量y 成为一个”闭包”，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。
闭包就是函数本身加上所需要的非入参的变量。

11.val a = 10，怎样将a转为double类型、String类型？

a.asInstanceOf[Double]
a.asInstanceOf[String]

12.Scala函数中是把方法体的最后一行作为返回值，需不需要显示调用return？

不需要，但是如果使用的话也行，但是不建议使用。可以参考“scala中为什么不建议用return”http://blog.csdn.net/u010256841/article/details/53467905

13.怎样定义一个字符串数组？下标是从1开始的吗？

//长度为10的String类型数组，所有元素初始化为null。
val strArr = new Array[String](10)
//可以使用Scala的类型自动推断来定义长度为2的字符串数组。
val strArr = Array("str1","str2")

下标是从0开始的。（扩展阅读：https://www.zhihu.com/question/20302205）

14.1 to 10 ==> 1.to(10)，10包含不包含？

1 to 10等价于1.to(10)，其中10是包含的。

scala> for (i <- 1 to 10)
     | print(i + ",")
1,2,3,4,5,6,7,8,9,10,

15.Range(1, 10)，10包含不包含？

不包含。

scala> for (i <- Range(1 , 10))
     | print(i + ",")
1,2,3,4,5,6,7,8,9,

scala> Range(1,10)//Range的底层其实是由until实现的（until也不包含）
res6: scala.collection.immutable.Range = Range 1 until 10

16.Scala 模式匹配语法是什么？

变量 match{
case _ => …
}

object Test {
   def main(args: Array[String]) {
      println(matchTest("two"))   //2
      println(matchTest("test"))  //many
      println(matchTest(1))       //one
      println(matchTest(6))       //scala.Int
   }

   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }
}

17.异常报错是语法？

try {
  //可能有异常的代码块
} catch {
  //对出现的异常进行处理
} finally {
  //一般执行关闭操作（无论有没有异常发生，finally内的语句都会执行）
}

18.Array、ArrayBuffer，谁是定长？谁是变长？

Arrray是定长的，ArrayBuffer是变长的。
ArrayBuffer可以使用+=和++=来添加元素或元组。

19.什么是隐式转换函数？什么场景下用？怎样定义？

隐式转换函数是以implicit关键字开头的函数，如：

implicit def man2SuperMan(man:Man) = new SuperMan(man.name)

使用场景是想在一个没法修改的类里添加一个方法，就可以用上面的方式把man变为superMan。
隐式转换有三种使用方式：
1.将方法或变量标记为implicit
2.将方法的参数列表标记为implicit（隐式参数）
3.将类标记为implicit（隐式类）

20.Scala面向对象,三大特性是什么？什么区别？

继承：父和子的关系
封装：属性、方法
多态：父类引用指向子类对象

21.Scala 基本语法需要注意点？

21.1.类名 - 对于所有的类名的第一个字母要大写吗？

需要大写。

21.2.方法名称 - 所有的方法名称的第一个字母用小写吗？

需要小写。
例如：
class MyFirstScalaClass
def myMethodName()
建议是这种格式，不按照这种规定也可以。

22.对象是什么？类是什么？怎样在IDEA创建文件？

对象是真实存在的，比如每个人都是一个对象。
类是对象抽象出来的，是一个定义包括在特定类型的对象中的方法和变量的软件模板。比如：人类是一个类，具有一些属性（眼睛，嘴…），和方法（吃饭，睡觉…），小明是个人，那么他就能用嘴吃饭（正常情况下）。

23.变长数组ArrayBuffer的系列问题

scala> var c = new scala.collection.mutable.ArrayBuffer[Int]()
c: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

23.1. 在尾部添加一个元素

scala> c += 0
res4: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0)

23.2. 在尾部添加多个元素

scala> c += (1,2,3)
res5: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3)

23.3. 追加集合

scala> c ++= Array(4,5)
res6: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 5)

23.4. 指定位置添加元素

scala> c.insert(4,4,5) //在索引为4的位置加上4,5两个元素（可以加任意个）。

scala> c
res15: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 5, 6, 7)

23.5. 移除尾部n个元素

scala> c.trimEnd(2) //移除尾部2个元素

scala> c
res17: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 5)

23.6. 移除开头n个元素

scala> c.remove(0,2)

scala> c
res19: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3, 4, 5)

23.7. 移除某个位置的元素

scala> c.remove(2)
res20: Int = 2

scala> c
res21: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3, 5)

23.8. 移除从下标为n开始（包括n）的count个元素

scala> c.remove(1,2)

scala> c
res23: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(3)

23.9. ArrayBuffer 转 Array

scala> c.toArray
res24: Array[Int] = Array(3)

23.10. Array 转 ArrayBuffer

scala> val b = c.toArray
b: Array[Int] = Array(3)

scala> b.to    //按Tab键，会出现提示
to        toBuffer       toIterable   toList   toSeq   toStream   toTraversable
toArray   toIndexedSeq   toIterator   toMap    toSet   toString   toVector

scala> b.toBuffer
res26: scala.collection.mutable.Buffer[Int] = ArrayBuffer(3)