Scala中的类和Object

Scala和java差不多定义类，使用class关键字

如下：

class CreateClassTest{

  //定义相应的类的字段（fileds）
  var sum = 0
  //定义一个私有的变量,在Scala中公开成员的方法是不显式指定任何访问修饰符。
  //换句话说，在Java中你可以说public，而在Scala中你什么都不说。Public是Scala的默认访问级别
  private var privateVar = "this is a private var"

  //定义相关的方法
  def add(str : String): String ={
    privateVar += str
    return privateVar
  }

  def check(str: String): Boolean ={
    if(privateVar.startsWith(str)) true else false
  }

//这个和上面的check是一样的效果

  def checkR(str: String): Boolean = if(privateVar.startsWith(str)) true else false

}

可以在类中创建类的字段和方法，定义方法使用def 方法名

var acc = new CreateClassTest
var csa = new CreateClassTest

上面两行是对类的引用，如果这里acc声明为val，不能重新分配一个新的对象
//acc.privateVar = "vister private var error"
//println(acc.privateVar)
//这里将报错，因为privateVar是私有的方法，只能在CreateClassTest类中进行访问

Scala中的分号规则：

  对于语句分离的准确规则，它们的工作效果非常简单。简而言之，除非满足下列条件之一，否则将行结尾视为分号：
 1.有问题的行以单词形式结束，该单词作为语句的结尾不合法，例如句点或中缀运算符 。
 2.下一行以一个无法启动语句的单词开头。
 3.该行在括号（...）或括号[...]内结束，因为它们无论如何都不能包含多个语句

Scala中的静态成员

Scala比Java更面向对象的一种方式是Scala中的类不能有静态成员。相反，Scala有单例对象。单例对象定义看起来像类定义，只不过您使用关键字object而不是关键字class

import scala.collection.mutable.Map

class CreateObjectTest{
  private var sum = 0
  def checksum(): Int = ~(sum & 0xFF) + 1
  def add(b: Byte){sum += b}
}

//创建一个静态成员

object CreateObjectTest{
  private val cache = Map[String, Int]()
  def calculate(str: String): Int=
    if(cache.contains(str))
      cache(str)
    else{
      val acc = new CreateObjectTest
      for(c <- str)
        acc.add(c.toByte)
      val cs = acc.checksum()
      cache += (str -> cs)
      cs
    }
}

当单例对象与类共享相同的名称时，它被称为类CreateObjectTest的companion对象。您必须在同一个源文件中定义类及其附属对象。该类被称为singleton对象的companion类。类和它的companion对象可以相互访问其私有成员
println(CreateObjectTest.calculate("hello world tony single object"))
然而，单例对象不仅仅是静态方法的持有者。它是一级对象。因此，可以将单例对象的名称看作是附加到该对象的名称标记
定义单例对象并不定义类型(在Scala抽象级别)。给定对象checksum累加器的定义，就不能创建checksum累加器类型的变量。相反，名为CreateObjectTest的类型是由singleton对象的companion类定义的。然而，单例对象扩展了一个超类，并且可以混合特征，类和单例对象之间的一个区别是单例对象不能接受参数，而类可以。因为不能用new关键字实例化单例对象，
所以无法向其传递参数。每个单例对象都是作为一个从静态变量引用的合成类的实例实现的，
因此它们具有与Java静态相同的初始化语义。特别是，单例对象是在一些代码第一次访问它时初始化的。
一个单例对象不与一个类共享相同的名称，称为独立对象

Scala的程序入口和java的一样，使用main方法，如下定义：

运行一个scala的应用，必须创建一个单例的对象与一个main方法，接受一个Array[String]的参数，
并且返回值为Unit的一个方法。和java基本类似，java为public static void main(String [] aegs){}

import CreateObjectTest.calculate   //引入其他的类

object Summer{
  def main(args: Array[String]){
    for(arg <- args)
      println(arg + " : " + calculate(arg))
  }
}

这里我们需要编译这两个类：CreateObjectTest.scala和Summer.scala

可以使用

1.scalac CreateObjectTest.scala Summer.scala

2.fsc CreateObjectTest.scala Summer.scala 如果出现下面的界面

之后就可以运行了：

scala Summer tony lovess

这将编译源文件，但是在编译完成之前可能会有明显的延迟。原因是每次编译器启动时，它都要花时间扫描jar文件的内容，并在查看提交给它的新源文件之前执行其他初始工作。出于这个原因，Scala发行版还包含一个名为fsc(用于快速Scala编译器)的Scala编译器守护进程.

第一次运行fsc时，它将创建一个本地服务器守护进程，该守护进程连接到计算机上的一个端口。然后，它将通过端口将要编译的文件列表发送给守护进程，守护进程将编译这些文件。下次运行fsc时，守护进程已经在运行了，因此fsc将简单地将文件列表发送给守护进程，该守护进程将立即编译文件。使用fsc，您只需要等待Java运行时第一次启动。如果您想停止fsc守护进程，可以通过fsc -shutdown来完成。运行这些scalac或fsc命令将生成Java类

如果我们不想写main这个方法，可以继承scala.Application这个类，但是这个类在scala版本2.9只有就已经过期了，改为App，如果在新版中使用Application的话，会包如下错误：

之后我们只需要将Applciation改为App，将能编译成功：

import CreateObjectTest.calculate

object FallWinterSpringSummer extends App {
  for(season <- List("fall","Winter","Spring"))
    println(season + " : " + calculate(season))
}

但是如果使用了App的话，将不能取得命令行中的参数，因为命令行参数在这种情况下不可用。其次，由于JVM线程模型中的一些限制，如果您的程序是多线程的，则需要显式main方法。最后，JVM的一些实现不优化由应用程序特征执行的对象的初始化代码。因此，只有当您的程序相对简单且单线程时，才应该从应用程序继承