Scala教程（一）

简介：
Scala是一门多范式(multi-paradigm)的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。
Scala运行在Java虚拟机上，并兼容现有的Java程序。
Scala源代码被编译成Java字节码，所以它可以运行于JVM上，并可以调用现有的Java类库。
联邦理工学院的马丁·奥德斯基于2001年开始设计Scala，他是编译器及编程的狂热爱好者，长时间的编程之后，希望发明一种语言，能够让写程序这样的基础工作变得高效，简单。所以当接触到JAVA语言后，对JAVA这门便携式，运行在网络，且存在垃圾回收的语言产生了极大的兴趣，所以决定将函数式编程语言的特点融合到JAVA中，由此发明了两种语言(Pizza & Scala)
Pizza和Scala极大推动了Java编程语言的发展。

• jdk5.0的泛型，增强for循环，自动类型转换等，都是从Pizza引入的新特性。
• jdk8.0的类型推断，Lambda表达式就是从Scala引入的特性。
• Jdk5.0和Jdk8.0的编译器就是马丁·奥德斯基写的

Scala和Java关系
一般来说，学习Scala的人，都会Java，而Scala是基于Java的，因此我们需要将Scala和Java以及JVM之间的关系搞清楚。

1.Scala环境搭建
1）安装步骤
(1)首先确保jdk1.8安装成功
(2)下载对应的Scala安装文件scala-2.11.8.zip
(3)解压scala-2.11.8.zip
(4)配置Scala的环境变量


2）测试
定义两个变量n 和 n2，并计算 n 和 n2两个变量的和。

2.Scala插件安装
默认情况下IDEA不支持Scala的开发，需要安装Scala插件。
我们可以直接在线安装即可。
file–>setting–>Plugins–>Scala
安装之后重启IDEA

3.Scala案列

Scala程序基本结构

class Hello {

  /*
  定义变量：
  val/var 变量名:变量类型 = 变量值
  */
  val a: Int = 1

  /*
  定义方法：
  def 函数名(参数名:参数类型):返回值类型={方法体}
  */
  def hello(arg: String): Unit = {
    println(arg)
  }
}

object Hello {

  /*
  Scala程序的入口
  */
  def main(args: Array[String]): Unit = {
    println("hello,scala")
  }

  /*
  完全面向对象：scala完全面向对象，故scala去掉了java中非面向对象的元素，如static关键字，void类型
  1.static
  scala无static关键字，由object实现类似静态方法的功能（类名.方法名），object关键字和class的关键字定义方式相同，但作用不同。class关键字和java中的class关键字作用相同，用来定义一个类；object的作用是声明一个单例对象，object后的“类名”可以理解为该单例对象的变量名。
  2.void
  对于无返回值的函数，scala定义其返回值类型为Unit类
  */
}

• Scala程序反编译

1)object在底层会生成两个类 Hello,Hello$
2)Hello中有个main函数，调用Hello$类的一个静态对象 MODULES$
3)Hello$.MODULE$ 对象是静态的，通过该对象调用Hello$的main函数
4)可以理解我们在main中写的代码在放在Hello$的main，在底层执行Scala编译器做了一个包装
（1）Hello源代码

object Hello {
def main(args: Array[String]): Unit = {
		  //4. 可以理解我们在main中写的代码在放在Hello$的main,在底层执行scala编译器做了一个包装
        println("hello,scala")
    }
}

（2）Hello.class类

//package com.atguigu.chapter01

//1. object在底层会生成两个类 Hello , Hello$
//2. Hello中有个main函数，调用 Hello$ 类的一个静态对象 MODULES$
public final class Hello
{
    public static void main(String[] paramArrayOfString)
    {
        Hello$.MODULE$.main(paramArrayOfString);
    }
}

（3）Hello$.class类

public final class Hello$
{
    public static final  MODULE$;

    static
    {
    	  new ();
    }

    public void main(String[] args)
    {
		  //3. Hello$.MODULE$. 对象是静态的，通过该对象调用Hello$的main函数
    	  Predef..MODULE$.println("hello,scala");
    }

    private Hello$()
    {
    	  MODULE$ = this;
    }
}

说明：
（1）Scala中如果使用object关键字声明类，在编译时，会同时生成两个类：当前类，当前类$
（2）使用当前类$的目的在于模拟静态语法，可以通过类名直接访问方法。
（3）Scala将当前类 $这个对象称之为“伴生对象”，伴随着类所产生的对象，这个对象中的方法可以直接使用。

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

【数据类型关系】

Scala数据类型关系总结
1）Scala中一切数据都是对象，都是Any的子类
2）Scala中数据类型分为两大类：数值类型(AnyVal)、引用类型(AnyRef)，不管是值类型还是引用类型都是对象。
3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换(隐式转换)
4）Scala特殊的类型之Null，它只有一个实例就是Null,它是所有引用类型(AnyRef)的子类。
5）Scala特殊类型之Nothing，是所有数据类型的子类，主要在一个函数没有正常返回值使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

• 数据类型
  【整数类型】Byte,Shot,Int,Long
  Scala的整数类型就是用于存放整数值得，比如12,30,3456等。
  1）整型分类

数据类型	描述
Byte【1】	8位有符号补码整数。数值区间为 -128到 127
Short【2】	16位有符号补码整数。数值区间为 -32768到 32767
Int【4】	32位有符号补码整数。数值区间为-2147483648 到 2147483647
Long【8】	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 = 2的(64-1)次方-1

2）案例实操
（1）Scala各整数类型有固定的表数范围和字段长度，不受具体操作的影响，以保证Scala程序的可移植性。

object Scala04 {
  def main(args: Array[String]): Unit = {
    var n1 : Byte = 127
    var n2 : Byte = -128
    var n3 : Short = 128
    var n4 : Int = 128
    var n5 : Long = 128
    //-----------------------
    //TODO 错误
    // var n6 : Byte = 128
    // var n7 : Byte = -129
    //-----------------------
    
  }
}

（2）Scala的整型，默认为Int类型，声明Long类型，须后加 “l”或“L”
（3）Scala程序中变量常声明为Int型，除非不足以表示大数，才使用Long

【浮点类型】(Float、Double)
Scala的浮点类型可以表示一个小数，比如123.4f ，7.8 ,0.12等等。
1）浮点型分类

数据类型	描述
Float【4】	32位，IEEE754标准的单精度浮点数
Double【8】	64位IEEE754标准的双精度浮点数

2）案例实操
（1）Scala的浮点型常量默认为Double型，声明Float型常量，须后加 “f”或“F”

object TestDataType {

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

        // 建议，在开发中需要高精度小数时，请选择Double
        var n7 = 2.2345678912f
        var n8 = 2.2345678912

        println("n7=" + n7)
        println("n8=" + n8)
    }
}

//运行的结果

n7 = 2.2345679
n8 = 2.2345678912

【字符类型】（Char）
1）基本说明
字符类型可以表示单个字符，字符类型是Char，16位无符号Unicode字符（2个字节），区间值为U+0000到U+FFFF。
2）案例实操
（1）字符常量是用单引号 ’ ’ 括起来的单个字符
（2）可以直接给Char赋一个整数，然后输出时，会按照对应的unicode字符输出

object TestCharType {

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

        //（1）字符常量是用单引号 ' ' 括起来的单个字符。
        var c1: Char = 'a'

        println("c1=" + c1)

        //（2）可以直接给Char赋一个整数，然后输出时，会按照对应的unicode字符输出
        println("c1码值=" + c1.toInt)
    }
}

（3）Char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。

object TestCharType {

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

        var c2: Char = 98 // 正确，因为直接将一个数值给char，编译器只判断是否越界
        var c3: Char = 'a' + 1 // 错误，Int高->char低，编译器判断类型

        var c4: Char = ('a' + 1).toChar
    }
}

（4）\t :一个制表位，实现对齐的功能
（5）\n：换行符
（6）\ : 表示
（7）" :表示 "

object TestCharType {

    def main(args: Array[String]): Unit = {
        //（4）\t ：一个制表位，实现对齐的功能
        println("姓名\t年龄")
        
        //（5）\n ：换行符
        println("西门庆\n潘金莲")
        
        //（6）\\ ：表示\
        println("c:\\岛国\\avi")
        
        //（7）\" ：表示"
        println("同学们都说：\"大海哥最帅\"")
    }
}

【布尔类型】Boolean
1）基本说明
（1）布尔类型也叫Boolean类型，Boolean类型数据只允许取值true和false
（2）boolean类型占1个字节
2）案例实操

object Scala07 {
  def main(args: Array[String]): Unit = {
    var isResult : Boolean = false
    var isResult2 : Boolean = true
  }
}

Unit类型、Null类型和Nothing类型
1）基本说明

数据类型	描述
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()
Null	null,Null类型只有一个实例值null
Nothing	Nothing类型在Scala的类层级的最低端，它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值(异常)赋给其他的函数或者变量(兼容性)

2）案列实操
（1）Null类只有一个实例对象，Null类似于Java中的null引用。Null可以赋值给任意引用类型(AnyRef)，但是不能赋值给值类型（AnyVal）

object TestDataType {

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

        //null可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
        var n1: Int = null // 错误
        println("n1:" + n1)

        var cat = new Cat();
        cat = null	// 正确
    }
}

class Cat {

}

（2）Unit类型用来标识过程，也就是没有明确返回值的函数。
由此可见，Unit类似于Java里的void。Unit只有一个实例 ----()，这个实例也没有实质意义

object TestSpecialType {

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

        def sayOk : Unit = {// unit表示没有返回值，即void
            println("say ok")
        }
        sayOk
    }
}

（3）Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。

object TestSpecialType {

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

        def test() : Nothing={
            throw new Exception()
        }
        test
    }
}

• 数值类型间转换
  【数值类型自动转换】
  当Scala程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这个就是自动类型转换(隐式转换)。数据类型按精度(容量)大小排序为：
  
  1）基本说明
  （1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
  （2）当我们把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
  （3）(byte,short)和char之间不会相互自动转换。
  （4）byte,short，char他们三者可以计算，在计算时首先转换为Int类型。
  2）案例实操

object TestValueTransfer {

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

        //（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
        var n = 1 + 2.0
        println(n)  // n 就是Double

        //（2）当我们把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
        var n2 : Long = 1L
        //var n3 : Int = n2 //错误，原因不能把高精度的数据直接赋值和低精度。

        //（3）（byte，short）和char之间不会相互自动转换。
        var n4 : Byte = 1
        //var c1 : Char = n4  //错误

        //（4）byte，short，char他们三者可以计算，在计算时首先转换为int类型。
        var n5 : Byte = 1
        var c2 : Char = 1
        // var n : Short = n5 + c2 //当n5 + c2 结果类型就是int
        // var n6 : Short = 10 + 90 //错误
        var n7 : Short = 100 //正确
    }
}

注意：Scala还提供了非常强大的隐式转换机制(隐式函数，隐式类等)。
【强制类型转换】
1)基本说明
自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转换函数，但可能造成精度降低或溢出，格外要注意。

java : int num = (int) 2.5
scala : var num : Int = 2.7.toInt

2）案例实操
（1）当进行数据的从大------>小，就需要使用到强制转换
（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

object Scala08 {
  def main(args: Array[String]): Unit = {
    //（1）当进行数据的从大——>小，就需要使用到强制转换
    var n1: Int = 2.5.toInt // 这个存在精度损失
    println("n1=" + n1)  // n1= 2
    //（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
    var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt  // 10 *3 + 6*1 = 36
    var r2: Int = (10 * 3.5 + 6 * 1.5).toInt  // 44.0.toInt = 44

    println("r1=" + r1 + " r2=" + r2)
  }
}

（3）Char类型可以保存Int的常量值，但不能保存Int的变量值，需要强转
（4）Byte 和 Short类型在进行运算时，当做Int类型处理。

object TestForceTransfer {

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

        //（3）Char类型可以保存Int的常量值，但不能保存Int的变量值，需要强转
        var c2: Char = 98 // 正确，因为直接将一个数值给char，编译器只判断是否越界
        var c3: Char = 'a' + 1 // 错误，Int高->char低，编译器判断类型
        var c4: Char = ('a' + 1).toChar


        //（4）Byte和Short类型在进行运算时，当做Int类型处理。
        var a : Short = 5
        // a = a-2 // 错误， Int->Short

        var b : Byte = 3
        // b = b + 4 // 错误，Int->Byte
    }
}

数值类型和String类型间转换
1）基本说明
在程序开发中，我们经常需要将基本数值类型转成String类型。或者将String类型转成基本数值类型
2）案例实操
（1）基本类型转String类型（语法：将基本类型的值 + " " 即可）
（2）String类型转基本数值类型(语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort)

object TestStringTransfer {

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

        //（1）基本类型转String类型（语法：将基本类型的值+"" 即可）
        var str1 : String = true + ""
        var str2 : String = 4.5 + ""
        var str3 : String = 100 +""

        //（2）String类型转基本数值类型（语法：调用相关API）
        var s1 : String = "12"

        var n1 : Byte = s1.toByte
        var n2 : Short = s1.toShort
        var n3 : Int = s1.toInt
        var n4 : Long = s1.toLong
    }
}

（3）注意事项
在将String类型转成基本数值类型时，要确保String类型能够转成有效的数据，比如我们可以把"123"，转成一个整数，但是不能把"hello"转成一个整数。