对象与伴生对象 #

object Counter:
  private var count = 0
  
  def increment(): Int =
    count += 1
    count
  
  def current: Int = count

Counter.increment()
Counter.increment()
println(Counter.current)

object MathUtils:
  val PI = 3.141592653589793
  
  def square(x: Double): Double = x * x
  def cube(x: Double): Double = x * x * x
  
  def factorial(n: Int): Int =
    if n <= 1 then 1
    else n * factorial(n - 1)
  
  def isPrime(n: Int): Boolean =
    if n < 2 then false
    else !(2 to math.sqrt(n).toInt).exists(n % _ == 0)

println(MathUtils.PI)
println(MathUtils.square(5))
println(MathUtils.factorial(5))
println(MathUtils.isPrime(17))

object Config:
  val host = "localhost"
  val port = 8080
  val timeout = 5000
  
  def url: String = s"http://$host:$port"

println(Config.url)

class Person(val name: String, val age: Int):
  def greet(): String = s"Hello, I'm $name"

object Person:
  def apply(name: String): Person = Person(name, 0)
  def create(name: String, age: Int): Person = Person(name, age)

val p1 = Person("Alice")
val p2 = Person.create("Bob", 25)

class Account private (val id: String, var balance: Double):
  def deposit(amount: Double): Unit = balance += amount

object Account:
  private var nextId = 0
  
  def apply(initialBalance: Double): Account =
    nextId += 1
    new Account(s"ACC-$nextId", initialBalance)

val account = Account(1000.0)
println(account.id)

class Temperature(val celsius: Double):
  def fahrenheit: Double = celsius * 9 / 5 + 32
  def kelvin: Double = celsius + 273.15

object Temperature:
  def fromFahrenheit(f: Double): Temperature = Temperature((f - 32) * 5 / 9)
  def fromKelvin(k: Double): Temperature = Temperature(k - 273.15)
  def absoluteZero: Temperature = Temperature(-273.15)

val t1 = Temperature(25)
val t2 = Temperature.fromFahrenheit(77)
val t3 = Temperature.fromKelvin(298.15)
val t4 = Temperature.absoluteZero

println(s"${t1.celsius}°C = ${t1.fahrenheit}°F")

class Person(val name: String, val age: Int)

object Person:
  def apply(name: String): Person = new Person(name, 0)
  def apply(name: String, age: Int): Person = new Person(name, age)

val p1 = Person("Alice")
val p2 = Person("Bob", 25)

object MyList:
  def apply[T](elements: T*): List[T] = elements.toList

val list = MyList(1, 2, 3, 4, 5)
println(list)

class Pair[A, B](val first: A, val second: B)

object Pair:
  def apply[A, B](first: A, second: B): Pair[A, B] = new Pair(first, second)

val pair = Pair("hello", 42)
println(s"${pair.first}: ${pair.second}")

class Person(val name: String, val age: Int)

object Person:
  def apply(name: String, age: Int): Person = new Person(name, age)
  def unapply(person: Person): Option[(String, Int)] =
    Some((person.name, person.age))

val person = Person("Alice", 25)

person match
  case Person(name, age) => println(s"$name is $age years old")

object Even:
  def unapply(n: Int): Boolean = n % 2 == 0

val number = 10

number match
  case Even() => println("Even number")
  case _ => println("Odd number")

object FirstTwo:
  def unapply(seq: Seq[?]): Option[(?, ?)] =
    if seq.length >= 2 then Some((seq(0), seq(1)))
    else None

val list = List(1, 2, 3, 4, 5)

list match
  case FirstTwo(a, b) => println(s"First two: $a, $b")
  case _ => println("Less than two elements")

sealed trait Direction
case object North extends Direction
case object South extends Direction
case object East extends Direction
case object West extends Direction

def turn(direction: Direction): String = direction match
  case North => "Going North"
  case South => "Going South"
  case East => "Going East"
  case West => "Going West"

enum Direction:
  case North, South, East, West

def turn(direction: Direction): String = direction match
  case Direction.North => "Going North"
  case Direction.South => "Going South"
  case Direction.East => "Going East"
  case Direction.West => "Going West"

enum Planet(mass: Double, radius: Double):
  case Mercury extends Planet(3.303e+23, 2.4397e6)
  case Venus extends Planet(4.869e+24, 6.0518e6)
  case Earth extends Planet(5.976e+24, 6.37814e6)
  case Mars extends Planet(6.421e+23, 3.3972e6)
  
  def surfaceGravity: Double = 6.67300E-11 * mass / (radius * radius)
  def surfaceWeight(otherMass: Double): Double = otherMass * surfaceGravity

println(Earth.surfaceGravity)

sealed trait Animal
case class Dog(name: String) extends Animal
case class Cat(name: String) extends Animal

object Animal:
  def create(kind: String, name: String): Option[Animal] = kind match
    case "dog" => Some(Dog(name))
    case "cat" => Some(Cat(name))
    case _ => None

val dog = Animal.create("dog", "Rex")
val cat = Animal.create("cat", "Whiskers")

class Query private (
  val table: String,
  val columns: List[String],
  val where: Option[String],
  val limit: Option[Int]
)

object Query:
  def builder(table: String): QueryBuilder = QueryBuilder(table)
  
  class QueryBuilder(table: String):
    private var columns = List("*")
    private var where: Option[String] = None
    private var limit: Option[Int] = None
    
    def select(cols: String*): QueryBuilder =
      columns = cols.toList
      this
    
    def where(condition: String): QueryBuilder =
      where = Some(condition)
      this
    
    def limit(n: Int): QueryBuilder =
      limit = Some(n)
      this
    
    def build: Query = Query(table, columns, where, limit)

val query = Query.builder("users")
  .select("id", "name", "email")
  .where("age > 18")
  .limit(10)
  .build

object Cache:
  private val store = scala.collection.mutable.Map.empty[String, Any]
  
  def get[T](key: String): Option[T] =
    store.get(key).map(_.asInstanceOf[T])
  
  def put[T](key: String, value: T): Unit =
    store.put(key, value)
  
  def remove(key: String): Unit =
    store.remove(key)
  
  def clear(): Unit =
    store.clear()

Cache.put("user", Map("name" -> "Alice"))
val user = Cache.get[Map[String, String]]("user")

trait Show[A]:
  def show(a: A): String

object Show:
  def apply[A](implicit instance: Show[A]): Show[A] = instance
  
  given Show[Int] with
    def show(a: Int): String = a.toString
  
  given Show[String] with
    def show(a: String): String = a
  
  given Show[Boolean] with
    def show(a: Boolean): String = a.toString

def printShow[A](a: A)(using show: Show[A]): Unit =
  println(show.show(a))

printShow(42)
printShow("hello")
printShow(true)

object StringUtils:
  def isBlank(s: String): Boolean = s == null || s.trim.isEmpty
  def truncate(s: String, max: Int): String = 
    if s.length <= max then s else s.take(max) + "..."

class Connection private (val host: String, val port: Int)

object Connection:
  def apply(host: String, port: Int): Connection = new Connection(host, port)
  def localhost(port: Int = 8080): Connection = new Connection("localhost", port)

sealed trait Status
case object Active extends Status
case object Inactive extends Status
case object Pending extends Status