scala-13 对象

Object

• scala中没有静态成员。如果想使用static变量、static方法，可以使用scala中的单例对象object
  • 在object中定义变量和方法，再通过object去调用，可以达到java中的静态的效果
• java中的Object是所有类的超类，而scala中的object相当于java中的单例对象

object的定义
定义单例对象和定义类很像，只需要将class换为object即可

示例

object scalaBase {

  // 在object中定义的成员变量，相当于Java中定义一个静态变量
  // 定义一个SimpleDateFormat日期时间格式化对象
  val simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm")

  // 构造代码
  println("构造代码1")
  println("构造代码2")
  
  // 相当于Java中定义一个静态方法
  def format(date:Date) = simpleDateFormat.format(date)

  // main是一个静态方法，所以必须要写在object中
  def main(args: Array[String]): Unit = {

    println { scalaBase.format(new Date()) };
  }
}

#输出
构造代码
构造代码2
2020-07-17 08:39

注意

• 在单例对象中定义的变量和方法，类似于java中的static变量和方法
• 使用object定义的单例对象，可以用作工具类或者存放常量
• 调用单例对象的方法，直接使用单例对象名.方法名，访问单例对象的成员变量也是使用单例对象名.变量名
• 单例对象只能有一个无参的主构造器，不能添加其他参数
• object单例对象的构造代码可以直接写在花括号中

伴生对象

在同一个scala文件中，有一个object和class具有相同的名字。则

• 该object是该class的伴生对象
• 该class是该object的伴生类

伴生类和伴生对象的最大特点是可以互相访问（包含私有方法和变量）

示例

class classObject{
  val id = 1
  private var name  = "hello scala"
  def printName():Unit={
    println("object:"+ classObject.CONSTANT + " " + "class:"+ name)
  }
}

object classObject {
  private val CONSTANT = "scala class"

  def main(args: Array[String]): Unit = {
    val p = new classObject
    p.name = "changed name"
    p.printName()
  }
}

输出

object:scala class class:changed name

注意：

• 伴生类和伴生对象的名字必须一致
• 伴生类和伴生对象必须在同一scala源文件中
• 伴生类和伴生对象可以互相访问private属性

apply方法

• 使用伴生对象的apply方法可以快速地创建一个伴生对象
• 当对象（伴生对象）以函数的方式进行调用时，scala 会隐式地将调用改为在该对象上调用apply方法。

例如

// 创建一个Array对象
val a = Array(1,2,3,4)
// 这个列子中，object就是array。
// object.apply()调用Object中的 new Array，最终返回Array

源码

• Array中重载了很多apply()方法，根据不同的参数调用不同的apply方法
  

示例

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

  override def toString = s"Person($name, $age)"
}

object Person {
  // 实现apply方法
  // 返回的是伴生类的对象
  def apply(name:String, age:Int): Person = new Person(name, age)

  // apply方法支持重载
  def apply(name:String):Person = new Person(name, 20)

  def apply(age:Int):Person = new Person("某某某", age)

  def apply():Person = new Person("某某某", 20)
}

object Main2 {
  def main(args: Array[String]): Unit = {
      //根据传入的参数个数和参数类型，去伴生对象中找到对应的aplly方法，返回Person对象赋给变量p1.p2.p3.p4
    val p1 = Person("张三", 20)
    val p2 = Person("李四")
    val p3 = Person(100)
    val p4 = Person()

    println(p1)
    println(p2)
    println(p3)
    println(p4)
  }
}

# 输出
Person(张三, 20)
Person(李四, 20)
Person(某某某, 100)
Person(某某某, 20)

注意：

• 当一个有伴生对象的类实现了apply方法时，遇到类名（参数1，参数2.。。）会自动调用apply方法来创建对象
• apply方法支持重载
• 定义apply方法时，不能省略括号（），否则是引用伴生对象

scala中的main方法

运行程序必须有一个静态main方法，scala中没有静态方法。

• main方法必须放在object中

object Main1{
  def main(args:Array[String]) = {
    println("hello, scala")
  }
}

• 或者直接把main方法中的业务逻辑放在一个继承了App Trait的object中
• 也就是说extends了 APP Trait的object,可以不写main方法，直接在里面写本来想写在main方法中的业务

object Main2 extends App {
  println("hello, scala")
}

App源码说明

/** The `App` trait can be used to quickly turn objects
 *  into executable programs. Here is an example:
 *  {{{
 *  object Main extends App {
 *    Console.println("Hello World: " + (args mkString ", "))
 *  }
 *  }}}
 *  Here, object `Main` inherits the `main` method of `App`.
 *
 *  `args` returns the current command line arguments as an array.