Scala基础

Scala基础

---

---

前言

Scala是一种将面向对象和函数式编程结合在一起的高级语言，旨在以简洁、优雅和类型安全的方式表达通用编程模式。Scala功能强大，不仅可以编写简单脚本，还可以构建大型系统。Scala运行于Java平台，Scala程序会通过JVM被编译成class字节码文件，然后在操作系统上运行。其运行时候的性能通常与Java程序不分上下，并且Scala代码可以调用Java方法、继承Java类、实现Java接口等，几乎所有Scala代码都大量使用了Java类库。

一、CentOs安装Scala

1、下载Scala
到Scala官网https://www.scala-lang.org/download/下载Linux安装包scala-2.12.7.tgz

解压到指定目录：
$ tar -zxvf scala-2.12.7.tgz -C /opt/modules/

2、配置环境变量
export SCALA_HOME=/opt/modules/scala-2.12.7/
export PATH=$PATH:$SCALA_HOME/bin

3、测试
CMD中执行scala -version命令

二、Scala基础

1.变量声明

Scala中变量的声明使用关键字val和var。

声明一个val字符串变量str：
scala> val str="hello scala"
str: String = hello scala

声明变量时指定数据类型：
scala> val str:String="hello scala"
str: String = hello scala

将多个变量放在一起进行声明：
scala> val x,y="hello scala"
x: String = hello scala
y: String = hello scala

2.表达式

Scala中常用的表达式主要有条件表达式和块表达式。

1、条件表达式
条件表达式主要是含有if/else的语句块：
scala> val i=1
i: Int = 1

scala> val result=if(i>0) 100 else -100
result: Int = 100

也可以在一个表达式中进行多次判断：
scala> val result=if(i>0) 100 else if(i==0) 50 else 10
result: Int = 100

3.循环

Scala中的循环主要有for循环、while循环和do while循环三种。
1、for循环

	for循环的语法：
	for(变量<-集合或数组){
	  方法体
	}

2、while循环

	while循环的语法：
	while(条件)
	{
	   循环体
	}

3、do while循环

	do while 循环与while循环类似，但是do while循环会确保至少执行一次循环。语法：
	do {
	   循环体
	} while(条件)

4.方法与函数

Scala中有方法与函数。Scala 方法是类或对象中定义的成员，而函数是一个对象，可以将函数赋值给一个变量。换句话说，方法是函数的特殊形式。
1、方法
方法的定义使用def关键字，语法：

def 方法名 (参数列表):返回类型={
   方法体
}

2、函数
函数的定义与方法不一样，语法：

(参数列表)=>函数体
定义一个匿名函数，参数为a和b，且都是Int类型，函数体为a+b：
( a:Int, b:Int ) =>a+b
如果函数体有多行，可以将函数体放入一对{}中，并且可以通过一个变量来引用函数，变量相当于函数名称：
val f1=( a:Int, b:Int ) =>{ a+b }
对上述函数进行调用：
f1(1,2)
函数也可以没有参数：
val f2=( ) =>println("hello scala")
对上述函数进行调用：
f2()

3、方法与函数的区别
(1)方法是类的一部分，而函数是一个对象并且可以赋值给一个变量。
(2)函数可以作为参数传入到方法中。
(3)方法可以转换为函数
当把一个方法作为参数传递给其它的方法或者函数时，系统将自动将该方法转换为函数。

5.集合、数组、List、Map映射、元组、Set

1. Scala集合分为可变集合和不可变集合。可变集合可以对其中的元素进行修改、添加、移除；而不可变集合，永远不会改变，但是仍然可以模拟添加、移除或更新操作。这些操作都会返回一个新的集合，原集合的内容不发生改变。

2. Scala中的数组分为定长数组和变长数组，定长数组初始化后不可对数组长度进行修改，而变长数组则可以修改

3. Scala中的List分为可变List和不可变List，默认使用的List为不可变List。不可变List也可以增加元素，但实际上生成了一个新的List，原List不变。

4. Scala中的Map也分可变的Map和不可变的Map，默认为不可变Map。
   1、不可变Map
   创建一个不可变Map：

   val mp = Map(
      "key1" -> "value1",
      "key2" -> "value2",
      "key3" -> "value3"
   )
   

   也可以使用以下写法：

   val mp = Map(
      ("key1" , "value1"),
      ("key2" , "value2"),
      ("key3" , "value3")
   )
   

2、可变Map
创建可变Map需要引入类scala.collection.mutable.Map，创建方式与不可变Map相同。访问Map中key1的值，代码：

val mp = Map(
   ("key1" , "value1"),
   ("key2" , "value2")
)

5. 元组是一个可以存放不同类型对象的集合，元组中的元素不可以修改。

6. Set集合存储的对象不可重复。Set集合分为可变集合和不可变集合，默认情况下使用的是不可变集合，如果要使用可变集合，则需要引用 scala.collection.mutable.Set 包。

6.类和对象

1、类的定义
对象是类的具体实例，类是抽象的，不占用内存，而对象是具体的，占用存储空间。Scala中一个最简单的类定义是使用关键字class，类名必须大写。类中的方法用关键字def定义，代码：

class User{
   private var age=20
   def count(){
      age+=1
   }
}

如果一个类不写访问修饰符，则默认访问级别为Public。这与Java是不一样的。关键字new用于创建类的实例。例如，调用上述代码中的count()方法：
new User().count()
2、单例对象
Scala中没有静态方法或静态字段，但是可以使用关键字object定义一个单例对象，单例对象中的方法相当于Java中的静态方法，可以直接使用“单例对象名.方法名”方式进行调用。单例对象除了没有构造器参数外，可以拥有类的所有特性。

例如，定义一个单例对象Person，该对象中定义了一个方法showInfo()： 
object Person{
  private var name="zhangsan"
  private var age=20
  def showInfo():Unit={
    println("姓名："+name+"，年龄："+age)
  }
}

可以在任何类或对象中使用代码Person.showInfo()对方法showInfo()进行调用。
3、伴生对象
当单例对象的名称与某个类的名称一样时，该对象被称为这个类的伴生对象。类被称为该对象的伴生类。类和它的伴生对象必须定义在同一个文件中，且两者可以互相访问其私有成员。例如以下代码：

class Person() {
  private var name="zhangsan"
  def showInfo(){
    println("年龄："+Person.age) //访问伴生对象的私有成员
  }
}
object Person{
  private var age=20
  def main(args: Array[String]): Unit = {
    var per=new Person()
    println("姓名："+per.name) //访问伴生类的私有成员
    per.showInfo()
  }
}

4、get和set方法
Scala默认会根据类的属性的修饰符生成不同的get和set方法，生成原则：
val修饰的属性，系统会自动生成一个私有常量属性和一个公有get方法。
var修饰的属性，系统会自动生成一个私有变量和一对公有get/set方法。
private var修饰的属性，系统会自动生成一对私有get/set方法，相当于类的私有属性，只能在类的内部和伴生对象中使用。
private[this]修饰的属性，系统不会生成get/set方法，即只能在类的内部使用该属性。

在Scala中，get和set方法并非被命名为getName和setName，而是被命名为name和name_=，由于JVM不允许在方法名中出现=，因此=被翻译成$eq。

 private String name = "zhangsan";
  public String name() {
    return this.name;
  }
  public void name_$eq(String x$1) {
    this.name = x$1;
  }

4、get和set方法
除了系统自动生成get和set方法外，也可以手动进行编写：

	class Person {
	  //声明私有变量
	  private var privateName="zhangsan"
	  def name=privateName //定义get方法
	  def name_=(name:String): Unit ={ //定义set方法
	    this.privateName=name
	  }
	 
	}
object Test{
  def main(args: Array[String]): Unit = {
    var per:Person=new Person()
    //访问变量
    per.name="lisi“ //修改
    println(per.name) //读取
  }
}

5、构造器
Scala中的构造器分为主构造器和辅助构造器。
主构造器的参数直接放在类名之后，且将被编译为类的成员变量，其值由初始化类时进行传入：
//定义主构造器，年龄age默认为18

class Person(val name:String,var age:Int=18) {

}
object Person{
  def main(args: Array[String]): Unit = {
    //调用构造器并设置name和age字段
    var per=new Person("zhangsan",20)
    println(per.age)
    println(per.name)
    per.name="lisi"//错误，val修饰的变量不可修改
  }
}
将参数age设置为私有的，参数name设置为不可修改（val）：
class Person(val name:String, private var age:Int) {
}

5、构造器
构造参数也可以不带val或var，此时默认为private[this] val：
class Person(name:String,age:Int) {
}
如果需要将整个主构造器设置为私有的，只需要添加private关键字即可：
class Person private(var name:String,var age:Int) {
}

除了可以有主构造器外，还可以有任意多个辅助构造器。辅助构造器的定义需要注意以下几项：
（1）辅助构造器的方法名称为this。
（2）每一个辅助构造器的方法体中必须首先调用其它已定义的构造器。
（3）辅助构造器的参数不能使用var或val进行修饰。
5、构造器
定义两个辅助构造器：

class Person {
  private var name="zhangsan"
  private var age=20
  //定义辅助构造器一
  def this(name:String){
    this()//调用主构造器
    this.name=name
  }
  //定义辅助构造器二
  def this(name:String,age:Int){
    this(name)//调用辅助构造器一
    this.age=age
  }
}
上述构造器可以使用如下三种方式进行调用：
var per1=new Person//调用无参主构造器
var per2=new Person("lisi")//调用辅助构造器一
var per3=new Person("lisi",28)//调用辅助构造器二