Scala 基本概念学习

[color=blue][size=x-large][b]Type Inference类型推断[/b][/size][/color]
[color=red][b]当你声明的任何变量时，你不需要指定类型。[/b][/color]让我们来看看下面的例子。打开REPL下输入

val number1:Int =5

结果是number1: Int = 5

val number2=5

结果是number2: Int = 5

在上面的例子在第一种情况下，[color=red][b]我们声明的变量number1它的类型为INT（冒号后）， 在第二种情况下，我们没有指定类型，Scala推断的它作为Int。[/b][/color] 此外，[color=blue][b]在Scala中你不需要在语句尾部指定分号；[/b][/color]

[color=red][size=x-large][b]Immutability不变性[/b][/size][/color]
Scala语言是不变性优先，这与函数式编程的原则一致。所以，如果你不指定任何修饰符，默认情况下VAL将被使用。如果您使用var时，表示变量的值是可以改变的。

[color=red][size=large][b]数组[/b][/size][/color]

[b]数组的写法如下：[/b]

val names = Array("John","Ron","Tom")

或

val numbers = Array(1,2,3)

为访问数组中元素，直接定义索引ｉｎｄｅｘ就可以：

scala> numbers(1)
res0: Int = 2

[size=medium][color=red][b]mkString方法可以串连数组或集合的元素：[/b][/color][/size]

scala> names.mkString(",")
res6: String = John,Ron,Tom

[size=medium][b]集合[/b]
[/size]
Scala 支持可变和不可变集合。默认值是不可改变的，下面是集合结构：

[img]http://dl2.iteye.com/upload/attachment/0124/3282/f37ea255-9c8c-38f8-ad39-08b3d349cafe.png[/img]

[size=medium][b]Set[/b][/size]

缺省你创建的Set是不可变的，如果你要创建可变的，使用导入scala.collection.mutable.Set.

scala> val citySet = Set("LA","NY","MUM")
citySet: scala.collection.immutable.Set[String] = Set(LA, NY, MUM)

scala> citySet+="SFO"
:9: error: value += is not a
 member of scala.collection.immutable.Set[String]
              citySet+="SFO"

scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set

scala> val citySetNew=Set("LA","NY","MUM")
citySetNew: scala.collection.mutable.Set[String] = Set(MUM, NY, LA)

scala> citySetNew+="SFO"
res3: citySetNew.type = Set(MUM, SFO, NY, LA)

scala> citySetNew
res4: scala.collection.mutable.Set[String] = Set(MUM, SFO, NY, LA)

上面当我们对不可变的集合增加一个元素 citySet+="SFO"时，出错。只要使用可变集合才通过。

[size=medium][b]Map[/b][/size]

此Map非前面函数map，两者意思不同，这里是数据结构，[color=red][b]类似Java的Map,Map也和Set类似，缺省是不可变的，可变需要导入可变的Map[/b][/color]

scala> 
val cityMap = Map(1->"Mum",2->"NY",3->"LA")
cityMap: scala.collection.immutable.Map[Int,String] = Map(1 -> Mum, 2 -> NY, 3 -> LA)

scala> cityMap += (4->"SFO")
:10: error: value += is not a member of scala.collection.immutable.Map[Int,String]
              cityMap += (4->"SFO")
                      ^

scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map

scala> val cityMap2 =  Map(1->"Mum",2->"NY",3->"LA")
cityMap2: scala.collection.mutable.Map[Int,String] = Map(2 -> NY, 1 -> Mum, 3 -> LA)

scala> cityMap2 +=(4->"SFO")
res6: cityMap2.type = Map(2 -> NY, 4 -> SFO, 1 -> Mum, 3 -> LA)

[size=medium][b]List[/b][/size]

如果List声明为不可变，你也不能增加元素：

scala> val list1 = List(1,2,3,4)
list1: List[Int] = List(1, 2, 3, 4)

scala> list1 = 5::list1
:8: error: reassignment to val
       list1 = 5::list1
             ^

scala> var list2 = List(1,2,3,4)
list2: List[Int] = List(1, 2, 3, 4)

scala> list2 = 5::list2
list2: List[Int] = List(5, 1, 2, 3, 4)

scala> list2.size
res0: Int = 5

[size=medium][b]元tuples[/b][/size]

[size=medium][color=red][b]当你从函数返回多个值/类型时，使用元组。下面元组包含整数型和字符串两种类型。[/b][/color][/size]

scala> val tup1 = (4,"SFO")
tup1: (Int, String) = (4,SFO)

[size=medium][b]循环和表达式[/b][/size]

[color=red][b]在Scala中的每个声明结果statement可以是一个表达式expression（任何声明返回的值被认为是一个表达式）。[/b][/color]

scala> val num1 = 4
num1: Int = 4

scala> val num2 =5
num2: Int = 5

scala> val finalNum = if(num1 > num2) num1 else num2
finalNum: Int = 5

scala> println(finalNum)

[color=blue][b]if / else表达式的结果分配给finalNum。这是非常相似的三元运算符在Java中[/b][/color]

for循环：

scala> val array1 = Array(1,2,3)
array1: Array[Int] = Array(1, 2, 3)
scala> for(x:Int <- array1) print (x)
123

上面的for循环有副作用。没有副作用的表现应该在一个循环返回一些值，以便以后能够使用，也就是要有输出，否则如果在这个for中对集合元素进行了修改，后面的代码是不会发现的，这带来了副作用。那么使用yeild来返回值

scala> array1
res10: Array[Int] = Array(1, 2, 3)
scala> for(x:Int<-array1) | yield(x*2) 
res11: Array[Int] = Array(2, 4, 6) 

最好的办法是用map来替代。

[size=medium][b]函数[/b][/size]

定义一个函数如下：

scala> def max(a:Int,b:Int):Int ={
          if (a > b) a
          else b
}
max: (a: Int, b: Int)Int

scala> max(3,4)
res12: Int = 4

说明：
[b]函数的定义用def关键字[/b]
参数以及它们的类型一起指定（类型在名称后面）
返回参数也需要指定函数类型。在上述情况下，它是Int
函数详细定义是等号（=）后面的指定大括号内
上面的精简版如下，更显得地道：

scala> def maxoneline(a:Int,b:Int):Int = if(a > b) a else b
maxoneline: (a: Int, b: Int)Int


[size=medium][b]类和对象伴侣[/b][/size]

Scala没有静态static概念。不过它有一个伴侣对象 Companion objec。一个同伴对象具有相同的名称作为类名。你可以直接调用它们的方法，而无需创建实例。

class Product(n:String, p:Int) {
   var name :String= n
   var price:Int=p
   def this(n:String) = this(n , 200)
   override def toString = ( "name ="+name+", price="+price)
}
object Product {
    def computeTax(price:Int):Double = {
    price+price*10
}
}
defined class Product
defined module Product

scala> val p8 = new Product("product8",800)
p8: Product = name =product8, price=800

scala> val tax = Product.computeTax(p8.price)
tax: Double = 8800.0