「Scala语言」（四）scala基础语法规则--粉丝服务平台-粉丝头条-fensifuwu.com

「Scala语言」（四）scala基础语法规则

科技 07-15 来源：橙红尘

本文仅仅只是个人学习的笔记，不代表一定就是对的，仅供参考。

1、java的static与scala的object。

java中有一个概念叫做static。static静态里面的数据可以共享。

在scala中，将java中的static的作用与对象分开了，它删除了static关键字，却添加了一个叫做object的概念，在object中，是不需要new出它的对象就可以直接使用，在class中，是必须new才可以使用对象。

同一个文件中，可以有多个object。object约等于static，是一个单例对象。object不允许new出来，但是class必须new出来才能使用。object里面的属性和函数可以直接使用，不需要new，从某种程度上说，object约等于static，但是object正统的解释是单例。

2、scala代码中的类名与文件名 VS java中的类名与文件名。

在java中，类名与文件名是绑定的，必须是重名的；但是在scala中，文件名与类名没有必然的关系，可以相同也可以不同。

在同一个包的目录下，如果有两个Scala文件，首先，这两个文件名不可以是一样的，其次，这两个文件中不可以有相同名字的class或者object（如果在一个scala文件当中已经定义了class Code01，可以在同一个文件中定义一个object Code01，但是不可以在相同的包的目录下再定义一个class Code01；同样的，如果有了object Code01，那么就不可以再有一个object Code01）。

scala的代码编译后，是以类名出现独立的文件的，与原本的文件名是无关的。

在同一个scala文件中，如果出现了一个class的名字与一个object的名字相同的情况，比如说有“class Code01”与“object Code01”，这两者的关系叫做“伴生”。

3、scala代码书写与java代码书写的异同。

在scala中，分号“;”可以不写了，但是在一行写多段代码的时候必须写分号“;”。

java中严禁在方法外写代码逻辑，比如说在java的main方法外，不定义别的方法，直接在类里面写输出语句，会出现错误，如下所示：

不能在方法外直接写

但是在scala中，可以直接在方法或函数外书写代码逻辑。

object Code01_Scala02 {
  println("----------up-----------------")
  def main(args: Array[String]): Unit = {
    println("Hello World")
  }
  println("----------down-----------------")
}

执行结果

裸露的语句“up”与“down”优先于main执行。

以下是解释，但不一定就正确，很可能是错的。

“实际上裸露的语句是在这个object的构造方法之中的，在单例模式下首先要new，所以首先执行的是构造方法，然后才是其它的要调用的方法（比如main）。”

以下是一些示例：

（1）执行代码01（没有new出来class，所以只执行了object里面的代码）：

object Code01_Scala03 {
  println("----------up-----------------")
  def main(args: Array[String]): Unit = {
    println("Code01_Scala03 Hello World")
  }
  println("----------down-----------------")
}

class Code01_Scala{
  var i=1
  println(s"----------up$i-----------------")
  def testDef01(): Unit = {
    println("Code01_Scala Hello World")
  }
  println(s"----------down${i+1}-----------------")
}

（1）执行代码02（new了class里面的，所以执行了class里面“裸露”的代码）：

object Code01_Scala03 {
  //将class类new出来
  private val code01_Scala: Code01_Scala = new Code01_Scala()
  println("----------up-----------------")
  def main(args: Array[String]): Unit = {
    println("Code01_Scala03 Hello World")
  }
  println("----------down-----------------")
}

class Code01_Scala{
  var i=1
  println(s"----------up$i-----------------")
  def testDef01(): Unit = {
    println("Code01_Scala Hello World")
  }
  println(s"----------down${i+1}-----------------")
}

（3）执行代码03（new了class并且调用了class里面的函数，所以全部执行了）：

object Code01_Scala03 {
  private val code01_Scala: Code01_Scala = new Code01_Scala()
  println("----------up-----------------")
  def main(args: Array[String]): Unit = {
    println("Code01_Scala03 Hello World")
    //执行这个函数
    code01_Scala.testDef01()
  }
  println("----------down-----------------")
}

class Code01_Scala{
  var i=1
  println(s"----------up$i-----------------")
  def testDef01(): Unit = {
    println("Code01_Scala Hello World")
  }
  println(s"----------down${i+1}-----------------")
}

4、函数的返回值。

scala中没有基本类型，它是纯面向对象的语言，所有函数必须有返回值，Unit与java中的void相似，但是Unit也是有返回值的，它的返回值是一个空的括号“()”。

5、常量与变量的定义。

scala中定义变量只能使用“var”，定义常量使用“val”。

常量相当于java中的final，不可以被修改（例如：如果常量等于一个集合，集合里面可以被修改，但是常量的指向不可以被修改）。

6、构造器。

在scala的类里面，裸露的代码是构造的。所以，是有默认构造的。

开发者需要关心的是个性化构造（自己写的构造器）。

（1）个性化构造的参数必须由开发者明文给出类型，因为函数和构造器的参数类型不能推断。

（2）个性化构造器必须调用默认构造，调用默认构造“this()”，就是说必须在自定义构造器中写下 “ this() ” 这行代码。

class Code01_Scala{

  var name="xx"

  def this(nameThis:String){
    //必须调用默认构造
    this()
    //将传进来的参数赋值给name这个变量
    name=nameThis
  }

  var i=1
  println(s"----------up$i-----------------")
  def testDef01(): Unit = {
    println(s"Code01_Scala Hello World $name")
  }
  println(s"----------down${i+1}-----------------")
}


object Code01_Scala03 {
  private val code01_Scala: Code01_Scala = new Code01_Scala()
  //调用个性化构造器
  private val code01_Scala02: Code01_Scala = new Code01_Scala("XX")
  println("----------up-----------------")
  def main(args: Array[String]): Unit = {
    println("Code01_Scala03 Hello World")
    code01_Scala.testDef01()
    code01_Scala02.testDef01()
  }
  println("----------down-----------------")
}

（3）类名构造器

类名构造器中的参数就是类的成员属性，并且默认它为val类型，并且默认是private。

object Code01_Scala004 {
  private val scala0: Code01_Scala04 = new Code01_Scala04("nan")
  def main(args: Array[String]): Unit = {
    println("Code01_Scala004 Hello World")
  }
}

//类名构造器中的参数就是类的成员属性，并且默认它为val类型，并且默认是private
class Code01_Scala04(sex:String){
  def this(){
    //必须调用默认构造，类名构造器中有了参数，所以默认构造器也就有了参数
    this(sex)
  }
  def testDef01(): Unit = {
    println(s"Code01_Scala04 Hello World")
  }
}

只有“类名构造器”中的参数可以被定义为var类型，其它方法函数中的参数类型都是val类型的，并且不允许设置成var类型，类名构造器中的参数只能手动设置成var，默认是val类型的。

//代码会报错
//类名构造器中的参数就是类的成员属性，并且默认它为val类型，并且默认是private
class Code01_Scala04(sex:String){
  def this(){
    //必须调用默认构造，类名构造器中有了参数，所以默认构造器也就有了参数
    this(sex)
    sex="nv"
  }
  def testDef01(): Unit = {
    println(s"Code01_Scala04 Hello World")
  }
}

//类名构造器中的参数就是类的成员属性，并且默认它为val类型，并且默认是private
//sex设置为了var类型，所以可以在自定义的构造器中被修改
class Code01_Scala04(var sex:String){
  def this(){
    //必须调用默认构造，类名构造器中有了参数，所以默认构造器也就有了参数
    this(sex)
    sex="nv"
  }
  def testDef01(): Unit = {
    println(s"Code01_Scala04 Hello World")
  }
}

7、伴生关系。

class Code01_Scala020 {
  var name="XX"
  println(s"name=${Code01_Scala020.name}")
}

object Code01_Scala020 {
  private val name="XXX"
  private val scala02: Code01_Scala020 = new Code01_Scala020()
  def main(args: Array[String]): Unit = {
    println("Hello World")
  }
}

参考文献：

[1] Scala官网：https://www.scala-lang.org/

[2] 马士兵教育：https://www.mashibing.com/subject/1

[3] CSDN博客：https://blog.csdn.net/qq_36383623/article/details/99288638