特质 #

trait Greeting:
  def greet(name: String): String = s"Hello, $name!"

class Person extends Greeting:
  def welcome(): String = greet("World")

val person = Person()
println(person.welcome())

trait Animal:
  def name: String
  def speak(): String

class Dog(val name: String) extends Animal:
  override def speak(): String = "Woof!"

val dog = Dog("Rex")
println(dog.speak())

trait Logging:
  def log(message: String): Unit = println(s"[LOG] $message")

class Service extends Logging:
  def process(): Unit =
    log("Processing...")

val service = Service()
service.process()

trait Logging:
  def log(msg: String): Unit = println(s"[LOG] $msg")

trait Timing:
  def time[T](block: => T): T =
    val start = System.nanoTime()
    val result = block
    val end = System.nanoTime()
    println(s"Time: ${(end - start) / 1e6} ms")
    result

class Service extends Logging with Timing:
  def process(): Unit =
    time {
      log("Processing...")
      Thread.sleep(100)
    }

trait Logging:
  def log(msg: String): Unit = println(s"[LOG] $msg")

class Service:
  def process(): Unit = println("Processing...")

val serviceWithLogging = new Service with Logging:
  override def process(): Unit =
    log("Starting process")
    super.process()
    log("Process completed")

serviceWithLogging.process()

trait Counter:
  var count = 0
  def increment(): Int =
    count += 1
    count

class MyCounter extends Counter

val counter = MyCounter()
println(counter.increment())
println(counter.increment())

trait Config:
  val host: String
  val port: Int
  def url: String = s"http://$host:$port"

class DevConfig extends Config:
  override val host: String = "localhost"
  override val port: Int = 8080

val config = DevConfig()
println(config.url)

trait HeavyResource:
  lazy val data: String =
    println("Loading data...")
    "Heavy data loaded"

class MyResource extends HeavyResource:
  def use(): String = data

val resource = MyResource()
println("Created")
println(resource.use())

trait A:
  def greet(): String = "A"

trait B extends A:
  override def greet(): String = s"B -> ${super.greet()}"

trait C extends A:
  override def greet(): String = s"C -> ${super.greet()}"

class D extends B with C:
  override def greet(): String = s"D -> ${super.greet()}"

val d = D()
println(d.greet())

trait Base:
  def method(): String = "Base"

trait A extends Base:
  override def method(): String = s"A -> ${super.method()}"

trait B extends Base:
  override def method(): String = s"B -> ${super.method()}"

class C extends A with B:
  override def method(): String = s"C -> ${super.method()}"

val c = C()
println(c.method())
println(c.method())

trait Logging:
  def log(msg: String): Unit = println(s"[LOG] $msg")

trait DebugLogging extends Logging:
  override def log(msg: String): Unit =
    super.log(s"[DEBUG] $msg")

trait ErrorLogging extends Logging:
  override def log(msg: String): Unit =
    super.log(s"[ERROR] $msg")

class MyService extends DebugLogging with ErrorLogging:
  def process(): Unit = log("Processing...")

val service = MyService()
service.process()

trait Logger:
  def log(level: String, message: String): Unit

trait ConsoleLogger extends Logger:
  override def log(level: String, message: String): Unit =
    println(s"[$level] $message")

trait FileLogger extends Logger:
  override def log(level: String, message: String): Unit =
    val writer = java.io.FileWriter("app.log", true)
    writer.write(s"[$level] $message\n")
    writer.close()

class Application extends ConsoleLogger:
  def run(): Unit =
    log("INFO", "Application started")
    log("DEBUG", "Processing data")
    log("INFO", "Application finished")

val app = Application()
app.run()

trait Cache[K, V]:
  def get(key: K): Option[V]
  def put(key: K, value: V): Unit
  def remove(key: K): Unit
  def clear(): Unit

trait MemoryCache[K, V] extends Cache[K, V]:
  private val store = scala.collection.mutable.Map.empty[K, V]
  
  override def get(key: K): Option[V] = store.get(key)
  override def put(key: K, value: V): Unit = store.put(key, value)
  override def remove(key: K): Unit = store.remove(key)
  override def clear(): Unit = store.clear()

trait ExpiringCache[K, V] extends Cache[K, V]:
  private val timestamps = scala.collection.mutable.Map.empty[K, Long]
  val ttl: Long = 60000
  
  abstract override def get(key: K): Option[V] =
    timestamps.get(key) match
      case Some(ts) if System.currentTimeMillis() - ts > ttl =>
        remove(key)
        None
      case _ => super.get(key)
  
  abstract override def put(key: K, value: V): Unit =
    timestamps.put(key, System.currentTimeMillis())
    super.put(key, value)
  
  abstract override def remove(key: K): Unit =
    timestamps.remove(key)
    super.remove(key)
  
  abstract override def clear(): Unit =
    timestamps.clear()
    super.clear()

class MyCache extends MemoryCache[String, String] with ExpiringCache[String, String]

trait Observer[A]:
  def update(value: A): Unit

trait Observable[A]:
  private var observers = List.empty[Observer[A]]
  
  def addObserver(observer: Observer[A]): Unit =
    observers = observer :: observers
  
  def notifyObservers(value: A): Unit =
    observers.foreach(_.update(value))

class Sensor extends Observable[Double]:
  def setValue(value: Double): Unit =
    notifyObservers(value)

class Display extends Observer[Double]:
  override def update(value: Double): Unit =
    println(f"Display: $value%.2f")

val sensor = Sensor()
sensor.addObserver(Display())
sensor.setValue(25.5)

trait Logging:
  def log(msg: String): Unit

trait Timing:
  def time[T](block: => T): T

trait Validation:
  def validate[T](value: T)(rules: T => Boolean*): Boolean

trait Repository[K, V]:
  def findById(id: K): Option[V]
  def save(entity: V): Unit
  def delete(id: K): Unit

class Service extends Logging with Timing with Validation:
  def process(): Unit =
    time {
      log("Processing...")
    }

class C extends A with B with C