一文学会使用Scala

• Introduce

Scala上一门纯面向对象的函数式编程语言，其主要贡献以及备受欢迎大概是因为其是Spark的开发语言（个人观点）。

1.Scala 语言具有一下特性：

     •  面向对象特性

     •  函数式编程

     •  静态类型

     •  扩展性

     •  并发 性

 2.语法基础：

Scala：执行可以是交互模式，亦可脚本模式

语法：

    • 区分大小写

    • 类名称：首字母大写，一般命名以一个或多个单词连接，每一单词首字母大写

    • 方法 名称：首字母小写， 一般命名以一个或多个单词连接，每一单词首字母大写

    • 程序文件 名： 程序文件的名称应与对象名称完全 匹配

    • 入口函数： def main( args ： Array[String])   - 从 main() 方法开始，这是每个 Scala 程序的强制性部分

3.关键字

abstract	case	catch	class
def	do	else	extends
false	final	finally	for
forSome	if	implicit	import
lazy	match	new	Null
object	override	package	private
protected	return	sealed	super
this	throw	trait	Try
true	type	val	Var
while	with	yield
-	:	=	=>
<-	<:	<%	>:
#	@

数据类型

序号	数据类型	说明
1	Byte	8位有符号值，范围从-128至127
2	Short	16位有符号值，范围从-32768至32767
3	Int	32位有符号值，范围从-2147483648至2147483647
4	Long	64位有符号值，范围从-9223372036854775808至9223372036854775807
5	Float	32位IEEE 754单精度浮点值
6	Double	64位IEEE 754双精度浮点值
7	Char	16位无符号Unicode字符。范围从U+0000到U+FFFF
8	String	一个Char类型序列
9	Boolean	文字值true或文字值false
10	Unit	对应于无值
11	Null	null或空引用
12	Nothing	每种其他类型的亚型; 不包括无值
13	Any	任何类型的超类型; 任何对象的类型为Any
14	AnyRef	任何引用类型的超类型

4.变量以及定义形式：

• Scala 具有 用于声明变量的不同 语法，常数（ val ）或变量 ( var )

• 定义： val or var   VariableName : DataType = [ InitialValue ]

注：当为变量分配初始值时，Scala编译器可以根据分配给它的值来推断变量的类型。这被称为变量类型推断。因此，可以编写这样的变量声明

5.循环语句

注：break并不像c++，Java一样，在Scala中break是一个类，下文会有code实例。

6. if...else

define:

// _1

 if(判断条件){

// code block

}

// _2

if(判断条件){

 // code block

}else{

// code block

}

//_3

if(判断条件_1){

 // code block

}else if(判断条件_2){

// code block

}else if(判断条件_3){

}else{

}

7.函数

• Scala 函数声明具有以下形式 -

deffunctionName([listof parameters]):[returntype]

•Scala为调用方法提供了许多句法变体。以下是调用方法的标准方法 -

functionName( listof parameters )Scala

• 如果使用对象的实例调用函数，那么可使用与 Java 类似的点符号，如下所示：

[instance.]functionName( listof parameters )

Scala函数是Scala编程的核心，因此Scala被认为是函数式编程语言。以下是与Scala函数相关的几个重要概念，Scala程序员应该要理解。（各类函数实例见下文code）

序号	函数
1	按名称调用函数（将代码块传递给调用，奉调即算）
2	命名参数的函数
3	可变参数的函数（最后一个参数可重复）
4	递归函数（一般思考尾递归方式解决栈溢出问题）
5	默认参数值函数
6	高阶函数（将其他函数作为参数或其结果是函数的函数）
7	嵌套函数
8	匿名函数
9	部分应用函数
10	柯里化函数

8.闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

9.字符串，数组，集合

• Scala 像 Java 一样，除了基本的数据结构以外，还提供字符串，数组，集合（ List,Set,Map , 元组 ,Option ）等复合数据结构类并提供对象的基本操作方法 , 并实现各类型的迭代器。

• 详细请参阅 Scala API 文档

10. 类和对象

• 类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板 。

• Scala 中的类不声明为 public ，一个 Scala 源文件中可以有多个类 。

• Scala 的类定义可以有参数，称为类参数，如上面的 xc, yc ，类参数在整个类中都可以访问 。

• Scala 继承一个基类跟 Java 很相似 , 但我们需要注意以下几点：

    1. 重写 一个非抽象方法必须使用 override 修饰符 。

    2. 只有 主构造函数才可以往基类的构造函数里写参数 。

    3. 在 子类中重写超类的抽象方法时 ，无需使用 override 关键字。

• Scala 的单例对象实现方法是使用关键字 object 。单例模式除了定义类之外，还须定义同名的 object 对象。与类区别于单例禁带参数。

• 当单例对象与某一类同名时，其被称为该类的伴生对象（ companoin object ）。类和伴生对象须同一文件下。 类与其伴生 对象可以 互访私有成员。

11.Scala Trait(特征)  

• Scala Trait( 特征 ) 类似 Java 的接口 ，但比接口功能 强大。

• 除接口的功能外，它 还可以定义属性和方法的实现。

• 一般 Scala 类 只 能单一继承，但 可以继承多个 Trait ( 特征 ) ，就实现多继承 。

• Trait( 特征 ) 定义的方式与类类似，但它使用的关键字是  trait 。定义示例如下：

trait Equal {
  def isEqual(x: Any): Boolean
  def isNotEqual(x: Any): Boolean = !isEqual(x)
}

12. I/O 

    1.使用Java的IO进行文件读写

        Scala可以使用任何Java对象，而java.io.File是Scala编程中可用于读取和写入文件的对象之一。

    2.读取命令行输入：使用Console类

val line = Console.readLine

    3.读取文件内容：

scala.io.Source

    for example：

// 读取文件并按行输出Source.fromFile("Demo.txt" ).foreach(println)

13. 异常处理

Scala 的异常处理和其它语言比如 Java 类似。

Scala 的方法可以通过抛出异常的方法的方式来终止相关代码的运行，不必通过返回值。

抛出异常： throw

捕获异常：

异常捕捉的机制与其他语言中一样，如果有异常发生，catch字句是按次序捕捉的。因此，在catch字句中，越具体的异常越要靠前，越普遍的异常越靠后。 如果抛出的异常不在catch字句中，该异常则无法处理，会被升级到调用者处。

捕捉异常的catch子句，语法与其他语言中不太一样。在Scala里，借用了模式匹配的思想来做异常的匹配，因此，在catch的代码里，是一系列case字句。

下面针对以上介绍的方面实际操作实现code如下：

package com.test

import java.io._

import scala.util.control._
import java.util.Date
import scala.io.Source

object ForExample {
   def addInt(a: Int, b: Int): Int = {
      var sum: Int = 0
      sum = a + b

      return sum
   }

   // 按名调用函数实例
   def time() = {
      println("Getting time in nano seconds")
      System.nanoTime
   }

   def delayed(t: => Long) = {
      println("In delayed method")
      println("Param: " + t)
   }

   // 命名参数的函数
   def printInt(a: Int, b: Int) = {
      println("Value of a : " + a);
      println("Value of b : " + b);
   }

   // 可变参数的函数
   def printStrings(args: String*) = {
      var i: Int = 0;

      for (arg <- args) {
         println("Arg value[" + i + "] = " + arg);
         i = i + 1;
      }
   }

   // 递归函数
   def factorial(n: BigInt): BigInt = {
      if (n <= 1)
         n
      else
         factorial(n - 1) + n
   }

   // 尾递归函数
   def factorial_add(n: BigInt, result: BigInt): BigInt = {
      if (n <= 0) result
      else factorial_add(n - 1, result + n)
   }

   def addInt_1(a: Int = 5, b: Int = 7): Int = {
      var sum: Int = 0
      sum = a + b

      return sum
   }

   // 以函数作为参数
   def apply(f: Int => String, v: Int) = f(v)

   // 以函数
   def layout[A](x: A) = "[" + x.toString() + "]"

   // 匿名函数
   val numtiply = (x: Int, y: Int) => x * y

   // 部分应用函数
   def log(date: Date, message: String) = {
      println(date + "------" + message)
   }

   // 柯里化函数
   def addCurrying(a: Int)(b: Int) = {
      a + b
   }

   // 嵌套函数
   def factorial_addtion(i: Int): Int = {
      def fact_add(i: Int, accumulator: Int): Int = {
         if (i <= 1)
            accumulator
         else
            fact_add(i - 1, i + accumulator)
      }

      fact_add(i, 1)
   }

   // 模式匹配
   def matchTest(x: Int): String = x match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
   }

   // 异常处理
   def exceptionTest(args: String*): Unit = {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      } finally {
         println("Exiting finally...")
      }
   }

   // 文件读写
   def fileReadAndWriter(input: String,output: String): Unit ={
      try{
         val file_data = new PrintWriter(new File(output))
         val file_in = Source.fromFile(input)
         file_in.foreach(file_data.write)
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")
         }
         case ex: IOException => {
            println("IO Exception")
         }
      } finally {
         println("Read file and Write file finished")
      }
   }
   // 计算
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

      val loop = new Breaks;

      loop.breakable {
         for (a <- numList) {
            println("Value of a: " + addInt_1(a));

            if (a == 4) {
               loop.break;
            }
         }
      }
      println("After the loop");
      delayed(time())
      delayed(time())
      printInt(a = numList(0), b = numList(1))
      printInt(b = numList(0), a = numList(1))
      val stringList = List("scala", "spark", "c++", "hadoop", "Linux", "kalfka", "python",
         "tensorflow", "spark-mlib", "Mesos");
      printStrings("scala", "spark", "c++")
      println("匿名函数：" + numtiply(4, 6))

      // 部分应用
      val date = new Date()
      val logWithMess = log(date, _: String)

      logWithMess("message_1")
      Thread.sleep(1000)

      logWithMess("messgae_2")
      Thread.sleep(1000)

      logWithMess("message_3")
      Thread.sleep(1000)

      println(matchTest(1))
      println(matchTest(2))
      println(matchTest(3))
      exceptionTest("fas")
   }
}