// 기본 클래스
class Person(name: String, age: Int) {
  def greet(): String = s"안녕하세요, $name 입니다."
}

val person = new Person("김철수", 30)
println(person.greet())  // 안녕하세요, 김철수 입니다.

// name은 외부에서 접근 불가, age는 val 필드
class Person(name: String, val age: Int)

val p = new Person("김철수", 30)
// println(p.name)  // 컴파일 에러
println(p.age)      // 30

// var로 선언하면 변경 가능
class MutablePerson(var name: String, var age: Int)

val mp = new MutablePerson("김철수", 30)
mp.age = 31
println(mp.age)  // 31

class Person(val name: String, val age: Int) {
  // 보조 생성자
  def this(name: String) = this(name, 0)
  def this() = this("Unknown", 0)
}

val p1 = new Person("김철수", 30)
val p2 = new Person("김영희")      // age = 0
val p3 = new Person()              // name = "Unknown", age = 0

// 보조 생성자보다 기본값이 더 깔끔함
class Person(val name: String = "Unknown", val age: Int = 0)

val p1 = new Person("김철수", 30)
val p2 = new Person("김영희")
val p3 = new Person()

object DatabaseConnection {
  private var connection: String = _

  def connect(url: String): Unit = {
    connection = url
    println(s"Connected to $url")
  }

  def getConnection: String = connection
}

// new 없이 직접 사용
DatabaseConnection.connect("jdbc:mysql://localhost/db")
println(DatabaseConnection.getConnection)

object MathUtils {
  def square(x: Int): Int = x * x
  def cube(x: Int): Int = x * x * x
  val PI: Double = 3.14159
}

println(MathUtils.square(5))  // 25
println(MathUtils.PI)         // 3.14159

class Circle(val radius: Double) {
  import Circle._  // 컴패니언 객체의 멤버 import

  def area: Double = PI * radius * radius
  def circumference: Double = 2 * PI * radius
}

object Circle {
  val PI: Double = 3.14159

  // 팩토리 메서드
  def apply(radius: Double): Circle = new Circle(radius)

  def fromDiameter(diameter: Double): Circle = new Circle(diameter / 2)
}

// apply 덕분에 new 없이 생성 가능
val c1 = Circle(5)
val c2 = Circle.fromDiameter(10)

println(c1.area)  // 78.53975

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

object Person {
  def create(name: String, age: Int): Option[Person] =
    if (age >= 0) Some(new Person(name, age))  // private 생성자 접근
    else None
}

val person = Person.create("김철수", 30)  // Some(Person)
val invalid = Person.create("오류", -5)   // None

trait Greeter {
  def greet(name: String): String
}

class FormalGreeter extends Greeter {
  def greet(name: String): String = s"안녕하십니까, $name 님."
}

class CasualGreeter extends Greeter {
  def greet(name: String): String = s"안녕, $name!"
}

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

  def info(message: String): Unit = log(s"[INFO] $message")
  def error(message: String): Unit = log(s"[ERROR] $message")
}

class MyService extends Logger {
  def doSomething(): Unit = {
    info("작업 시작")
    // 작업 수행
    info("작업 완료")
  }
}

trait Swimmer {
  def swim(): String = "수영 중..."
}

trait Flyer {
  def fly(): String = "비행 중..."
}

// 다중 트레이트 믹스인
class Duck extends Swimmer with Flyer {
  def quack(): String = "꽥꽥!"
}

val duck = new Duck
println(duck.swim())   // 수영 중...
println(duck.fly())    // 비행 중...
println(duck.quack())  // 꽥꽥!

trait Base {
  def process(s: String): String = s
}

trait Uppercase extends Base {
  override def process(s: String): String = super.process(s.toUpperCase)
}

trait Trim extends Base {
  override def process(s: String): String = super.process(s.trim)
}

// 오른쪽에서 왼쪽으로 적용
class TextProcessor extends Base with Trim with Uppercase

val processor = new TextProcessor
println(processor.process("  hello world  "))  // HELLO WORLD

abstract class Animal(val name: String) {
  // 추상 메서드
  def speak(): String

  // 구현된 메서드
  def describe(): String = s"$name 은(는) ${speak()} 소리를 냅니다."
}

class Dog(name: String) extends Animal(name) {
  def speak(): String = "멍멍"
}

class Cat(name: String) extends Animal(name) {
  def speak(): String = "야옹"
}

val dog = new Dog("바둑이")
println(dog.describe())  // 바둑이 은(는) 멍멍 소리를 냅니다.

class MyClass {
  private val privateField = 1      // 이 클래스에서만
  protected val protectedField = 2  // 이 클래스와 하위 클래스에서
  val publicField = 3               // 어디서나

  private[this] val strictPrivate = 4  // 이 인스턴스에서만
}

// 패키지 레벨 접근
class PackageAccess {
  private[mypackage] val packagePrivate = 5  // mypackage 내에서만
}