继承与多态 #

class Animal(val name: String):
  def speak(): String = "Some sound"

class Dog(name: String) extends Animal(name):
  def fetch(): String = s"$name fetches the ball"

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

class Vehicle(val brand: String, val year: Int)

class Car(brand: String, year: Int, val model: String) 
  extends Vehicle(brand, year):
  def info: String = s"$brand $model ($year)"

val car = Car("Toyota", 2024, "Camry")
println(car.info)

class A
class B extends A

class Animal:
  def speak(): String = "Some sound"

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

class Cat extends Animal:
  override def speak(): String = "Meow!"

val dog = Dog()
val cat = Cat()
println(dog.speak())
println(cat.speak())

class Animal:
  def speak(): String = "Some sound"

class Dog extends Animal:
  override def speak(): String = s"${super.speak()} and Woof!"

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

class Parent:
  val name: String = "Parent"

class Child extends Parent:
  override val name: String = "Child"

val child = Child()
println(child.name)

class Parent:
  def name: String = "Parent"

class Child extends Parent:
  override val name: String = "Child"

val child = Child()
println(child.name)

class Animal
class Dog extends Animal
class Cat extends Animal

val animal: Animal = Dog()

if animal.isInstanceOf[Dog] then
  println("It's a dog")

if animal.isInstanceOf[Cat] then
  println("It's a cat")

val animal: Animal = Dog()

if animal.isInstanceOf[Dog] then
  val dog = animal.asInstanceOf[Dog]
  println("Converted to Dog")

def describe(animal: Animal): String = animal match
  case dog: Dog => "It's a dog"
  case cat: Cat => "It's a cat"
  case _ => "Unknown animal"

describe(Dog())
describe(Cat())

val animal: Animal = Dog()
println(animal.getClass.getSimpleName)

abstract class Shape:
  def area: Double

class Circle(val radius: Double) extends Shape:
  override def area: Double = math.Pi * radius * radius

class Rectangle(val width: Double, val height: Double) extends Shape:
  override def area: Double = width * height

def printArea(shape: Shape): Unit =
  println(s"Area: ${shape.area}")

printArea(Circle(5))
printArea(Rectangle(10, 20))

val shapes: List[Shape] = List(
  Circle(5),
  Rectangle(10, 20),
  Circle(3)
)

val totalArea = shapes.map(_.area).sum
println(s"Total area: $totalArea")

class Calculator:
  def add(a: Int, b: Int): Int = a + b
  def add(a: Double, b: Double): Double = a + b
  def add(a: Int, b: Int, c: Int): Int = a + b + c

val calc = Calculator()
calc.add(1, 2)
calc.add(1.5, 2.5)
calc.add(1, 2, 3)

abstract class Animal:
  def name: String
  def speak(): String
  
  def info: String = s"$name says: ${speak()}"

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

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

abstract class Shape:
  def area: Double
  
  def describe: String = s"Area is $area"

class Circle(val radius: Double) extends Shape:
  override def area: Double = math.Pi * radius * radius

val circle = Circle(5)
println(circle.describe)

abstract class 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)

final class FinalClass:
  def method: String = "Cannot override"

class SubClass extends FinalClass

class Parent:
  final def cannotOverride: String = "Final method"

class Child extends Parent:
  override def cannotOverride: String = "Error"

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

def describe(animal: Animal): String = animal match
  case Dog(name) => s"Dog: $name"
  case Cat(name) => s"Cat: $name"

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

class Employee(name: String, age: Int, val salary: Double) 
  extends Person(name, age):
  def info: String = s"$name, $age years old, salary: $salary"

val emp = Employee("Alice", 30, 50000)
println(emp.info)

class Person(val name: String, val age: Int):
  def this(name: String) = this(name, 0)

class Employee(name: String, age: Int, val salary: Double) 
  extends Person(name, age):
  def this(name: String) = this(name, 0, 0)

val emp = Employee("Alice")
println(s"${emp.name}, ${emp.age}, ${emp.salary}")

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

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

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)
    }

sealed trait Result[+T]
case class Success[T](value: T) extends Result[T]
case class Failure(message: String) extends Result[Nothing]

def handle(result: Result[Int]): String = result match
  case Success(value) => s"Success: $value"
  case Failure(msg) => s"Error: $msg"