scala 系列之 09scala 单例对象和伴生对象

11 单例对象

在scala中没有像java一样的static关键字；

在scala中是没有静态方法和静态字段的，但是可以使用object关键字加类名的语法结构实现同样的功能；

在scala中用object修饰的为单例对象，单例对象中主要存放常量和工具方法；

上面代码通过反编译发现：

结论： 可以利用这一点来实现初始化逻辑。

定义单例对象，实现连接池的操作， 提供获取可用连接个数、获取连接、释放连接

package day03
import scala.collection.mutable.ArrayBuffer
object ConnFactory {
  // 利用初始化代码来初始化连接池里面的连接
  // 连接池最大连接3个
  private val maxNum:Int = 3
  //
  private val conns = new ArrayBuffer[Conn]
  for(i <- 1 to 3){
    conns += new Conn(i)
  }
  // 获取可用连接个数
  def getConnSize = this.conns.size
  //获取连接
  def getConn:Conn = {
    if(this.conns.size == 0){
      null
    }else{
      val conn = this.conns.remove(0)
      conn
    }
  }
  // 释放连接
  def releaseConn(conn:Conn):Boolean = {
    if(conn == null || this.conns.size == this.maxNum){
      false
    }else{
      this.conns += conn
      true
    }
  }
}
object ConnFactoryTest{
  def main(args: Array[String]): Unit = {
    println(ConnFactory.getConnSize)
    val conn1 = ConnFactory.getConn
    val conn2 = ConnFactory.getConn
    val conn3 = ConnFactory.getConn
    val conn4 = ConnFactory.getConn
    println(s"${conn1}, ${conn2}, ${conn3}, ${conn4}")
    val res4 = ConnFactory.releaseConn(conn4)
    val res3 = ConnFactory.releaseConn(conn3)
    val res2 = ConnFactory.releaseConn(conn2)
    val res1 = ConnFactory.releaseConn(conn1)
    val res0 = ConnFactory.releaseConn(conn1)
    println(s"${res4}, ${res3}, ${res2}, ${res1}, ${res0}")
  }
}
// 连接对象
class Conn(val id:Int){
  override def toString: String = s"Conn[${id}]"
}

12 伴生对象

在Scala中，单例对象分为两种，一种是并未自动关联到特定类上的单例对象，称为独立对象 ；

另一种是关联到一个类上的单例对象，该单例对象与该类共有相同名字，则这种单例对象称为伴生对象，对应类称为伴生类。

一个单例对象未必是一个伴生对象，但是一个伴生对象一定是一个单例对象；

每个类都可以有伴生对象，伴生类与伴生对象必须写在同一个文件中；

与类名相同并且用Object修饰的对象叫做伴生对象，类和伴生对象之间可以互相访问对方的私有方法和属性

ip.txt

192.168.88.189 op.hadoop

192.168.88.195 nn2.hadoop

利用类和伴生对象，解析ip对应的主机名

package day03
import scala.io.Source
// 伴生类
class Parser(val ip:String) {
  def parse = {
    // 调用伴生对象的map获取对应ip的主机名
    Parser.map.getOrElse(ip, "无该主机")
  }
}
// 伴生对象
object Parser{
  // 读取文件并转成map
  private val list = Source.fromFile("/tmp/scala/ip.txt").getLines().toList
  private val list2 = list.map(_.split(" "))
  private val list3 = list2.map(f => (f(0), f(1)))
  private val map = list3.toMap
  println(map)
}
object ParserTest{
  def main(args: Array[String]): Unit = {
    val parser = new Parser("192.168.88.180")
    println(parser.parse)
  }
}