Scala入门第一篇-基础

这次我们主要介绍Scala的入门简介

Scala的入门
Scala的安装

Scala的入门

什么是 Scala

Scala 是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。 Scala 运行于 Java 平台（Java 虚拟机），并兼容现有的Java 程序。

为什么要学 Scala

优雅：这是框架设计师第一个要考虑的问题，框架的用户是应用开发程
序员， API 是否优雅直接影响用户体验。
速度快： Scala 语言表达能力强，一行代码抵得上 Java 多行，开发速度
快； Scala 是静态编译的，所以和 JRuby,Groovy 比起来速度会快很多。
能融合到 Hadoop 生态圈： Hadoop 现在是大数据事实标准， Spark 并不是要取代 Hadoop，而是要完善 Hadoop 生态。 JVM 语言大部分可能会想到 Java，但Java 做出来的 API 太丑，或者想实现一个优雅的 API 太费劲。

在这里插入图片描述

Scala 编译器安装

安装 JDK

因为 Scala 是运行在 JVM 平台上的，所以安装 Scala 之前要安装 JDK。

Windows 安装 Scala 编译器

访问 Scala 官网 http://www.scala-lang.org/下载 Scala 编译器安装包，目
前最新版本是 2.12.x，这里下载 scala-2.11.8.msi 后点击下一步就可以了（自
动配置上环境变量）。也可以下载 scala-2.11.8.zip，解压后配置上环境变量
就可以了。

Linux 安装 Scala 编译器

下载 Scala 地址 https://www.scala-lang.org/download/2.11.8.html
然后解压 Scala 到指定目录
tar -zxvf scala-2.11.8.tgz -C /usr/java
配置环境变量，将 scala 加入到 PATH 中

vi /etc/profile
export JAVA_HOME=/usr/java/jdk1.8
export PATH=$PATH:$JAVA_HOME/bin:/usr/java/scala-2.11.8/bin

Scala 开发工具安装

目前 Scala 的开发工具主要有两种： Eclipse 和 IDEA，这两个开发工具都有
相应的 Scala 插件，如果使用 Eclipse ，直接到 Scala 官网下载即可
点击下载
由于 IDEA 的 Scala 插件更优秀，大多数 Scala 程序员都选择 IDEA，可以到
点击这里下载下载，点击下一步安装即可，安装
时如果有网络可以选择在线安装 Scala 插件。
这里我们使用离线安装 Scala 插件：

安装 IDEA，点击下一步即可。
下载 IEDA 的 scala 插件
插件地址：点击下载
安装 Scala 插件： Configure -> Plugins -> Install plugin from disk -> 选
择 Scala 插件 -> OK -> 重启 IDEA

Scala基础

声明变

scala声明变量要使用关键字val，和var

val,相当于Java中的final，引用不可变，指定一个变量后，变量不可以被赋值。
var,变量可变，可以更改引用。
一般使用val来定义变量。


object VariableDemo {
  def main(args: Array[String]) {
    //使用val定义的变量值是不可变的，相当于java里用final修饰的变量
    val i = 1
    //使用var定义的变量是可变得，在Scala中鼓励使用val
    var s = "hello"
    //Scala编译器会自动推断变量的类型，必要的时候可以指定类型
    //变量名在前，类型在后
    val str: String = "itcast"
  }
}

常用类型

Scala 和 Java 一样，有 7 种数值类型 Byte、 Char、 Short、 Int、 Long、 Float、 Double类型和 1 个 Boolean 类型。
类型关系图如下：

所有类型的父类是Any，相当于Java中的Object类
值的类型的父类是AnyVal，引用类型的父类是AnyRef
在AnyVal中，Unit标识空值，相仿于Java中的void
AnyRef的子类有集合类collections,自定义类，Java中的类。
Null是引用类AnyRef的所有的子类
Nothing是所有类型的子类。

在这里插入图片描述

条件表达式

Scala的条件表达式比较简洁，定义变量时加上if else判断条件。例如：



object ConditionDemo {
  def main(args: Array[String]) {
    val x = 1
    //判断x的值，将结果赋给y
    val y = if (x > 0) 1 else -1
    //打印y的值
    println(y)

    //支持混合类型表达式
    val z = if (x > 1) 1 else "error"
    //打印z的值
    println(z)

    //如果缺失else，相当于if (x > 2) 1 else ()
    val m = if (x > 2) 1
    println(m)

    //在scala中每个表达式都有值，scala中有个Unit类，用作不返回任何结果的方法的结果类型,相当于Java中的void，Unit只有一个实例值，写成()。
    val n = if (x > 2) 1 else ()
    println(n)

    //if和else if
    val k = if (x < 0) 0
    else if (x >= 1) 1 else -1
    println(k)
  }
}

块表达式

定义变量时用 {} 包含一系列表达式，其中块的最后一个表达式的值就是块的值。



object BlockExpressionDemo {
  def main(args: Array[String]) {
    val a = 10
val b = 20
    //在scala中{}中包含一系列表达式，块中最后一个表达式的值就是块的值
    //下面就是一个块表达式
    val result = {
val c=b-a
val d=b-c
d   //块中最后一个表达式的值
}
 //result的值就是块表达式的结果
  println(result)
}
}

循环

在scala中有for循环和while循环，用for循环比较多
for循环语法结构：for (i <- 表达式/数组/集合)

scala中没有提供break和continue语句来退出循环，而是采用

boolean型控制变量法
使用函数嵌套，从函数中return
使用break中的break方法


object ForDemo {
  def main(args: Array[String]) {
    //for(i <- 表达式),表达式1 to 10返回一个Range（区间）
    //每次循环将区间中的一个值赋给i
    for (i <- 1 to 10)
      println(i)

    //for(i <- 数组)
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)

    //高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号
    for(i <- 1 to 3; j <- 1 to 3 if i != j)
      print((10 * i + j) + " ")
    println()

    //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i * 10
    println(v)

  }

}

函数

Scala可以通过=右边的表达式，推断出函数的返回值类型，如果函数需要多个表达式，可以使用代码块{}
可以把return当做函数版本的break语句
递归函数一定要指定返回类型
边长参数通过* 来指定，返回参数会转化为一个seq序列

object chapter02{

  def main(args: Array[String]): Unit = {

    //定义一个函数
    def abs(x:Double)= if (x > 0) x else -x

    println(abs(2.3))  //运行结果 2.3
    println(abs(-3))   //运行结果 3

    //定义函数
    def fac(n :Int) ={
      var r =1
      for (i <- 1 to n ) r= r * i
      r  //最后一个表达式为返回值
    }

    println(fac(10)) //运行结果：3628800

    //递归调用必须指定返回值类型

    def digui(n :Int) :Int = if (n <= 0) 1 else n * digui(n-1)

    println(digui(10)) //运行结果：3628800
    }

懒值

懒值
当val 被声明为lazy的时候，他的初始化就会被推迟，知道我们首次对此取值
需要注意：

用于初始化开销比较大的语句
可以解决循环依赖问题
是开发懒数据结构的基础

object Lazy {

  //提前加载
  def main(args: Array[String]): Unit = {
    def  init():String = {
      println("call init()")
      return ""
    }

    def noLazy(): Unit ={
      val property = init();//没有使用lazy修饰
      println("after init()")
      println(property)
    }

    //使用的时候才加载
    def lazyed(): Unit ={
      lazy val property = init();
      println("after init()")
      println(property)
    }

    noLazy()

    lazyed()
  }
}

异常

scala的异常的工作机制和Java中的一样，但是Scala没有"受验"异常，不需要声明说明函数或者方法可能抛出的异常。收检异常再编译期被检查

抛出异常：使用throw关键字，抛出异常的对象，所有异常都是Throwable的子类型。throw表达式是有类型的，就是Nothing,因为Nothing是所有类的子类，所以throw表达式可以用在需要类型的地方。
异常捕捉：和Java中是一样的

package com.scala.demo

import scala.math._
object MyException {


  def main(args: Array[String]): Unit = {
    def root(x :Double)=
      if (x > 0) {sqrt(x)}
      else throw new IllegalArgumentException("x shuold not be negative")

    try{
      println(root(4))
      println(root(-4))
    }catch {

      case e: Exception => println(e)

    }finally {
      println("finally......")
    }
  }
}