第8章 异常与 Option

class BalanceException(val need: Double)
  extends Exception(s"余额不足，还差 $need 元")

object BankDemo {
  private var balance = 100.0

  def withdraw(amount: Double): Unit = {
    if (amount <= 0) throw new IllegalArgumentException("取款金额必须大于 0")
    if (amount > balance) throw new BalanceException(amount - balance)
    balance -= amount
    println(f"取款 $amount%.1f 元，余额 $balance%.1f 元")
  }

  def main(args: Array[String]): Unit = {
    try withdraw(30)
    catch {
      case e: BalanceException => println(s"业务失败：${e.getMessage}")
      case e: IllegalArgumentException => println(s"参数错误：${e.getMessage}")
    }

    try withdraw(80)
    catch {
      case e: BalanceException => println(s"业务失败：${e.getMessage}")
    }

    try withdraw(-5)
    catch {
      case e: IllegalArgumentException => println(s"参数错误：${e.getMessage}")
    }

    println(f"最终余额：$balance%.1f")
  }
}

object FinallyDemo {
  def parse(s: String): Option[Int] =
    try Some(s.toInt)
    catch {
      case _: NumberFormatException => None
    } finally println(s"清理：解析 $s 结束")

  def classify(): String =
    try {
      throw new IllegalArgumentException("坏参数")
    } catch {
      case _: IllegalArgumentException => "捕获 IllegalArgumentException"
      case _: RuntimeException => "捕获 RuntimeException"
    } finally println("finally 执行")

  def main(args: Array[String]): Unit = {
    println(parse("42"))
    println(parse("abc"))
    println(classify())
  }
}

object OptionBasic {
  def parseScore(s: String): Option[Int] = s.trim.toIntOption

  def main(args: Array[String]): Unit = {
    val raw = List("90", " 82 ", "abc", "75")
    val valid = raw.flatMap(parseScore)
    println(s"有效成绩：$valid")
    println(s"人数：${valid.size}")
    println(s"最高分：${valid.maxOption.getOrElse(0)}")
    println(f"平均分：${valid.sum.toDouble / valid.size}%.1f")
    println(parseScore("abc").getOrElse(-1))
    println(parseScore("66").map(_ + 4).filter(_ >= 70))
    println(parseScore("abc").map(_ + 4))
  }
}

object OptionChain {
  def toInt(s: String): Option[Int] = s.toIntOption
  def reciprocal(n: Int): Option[Double] =
    if (n == 0) None else Some(1.0 / n)

  def main(args: Array[String]): Unit = {
    val nested = toInt("4").map(reciprocal)
    val flat = toInt("4").flatMap(reciprocal)
    println(s"map 结果：$nested")
    println(s"flatMap 结果：$flat")

    val combo = for {
      n <- toInt("5")
      r <- reciprocal(n)
    } yield r * 2
    println(s"for 推导式：$combo")

    println(toInt("abc").flatMap(reciprocal))
    println(toInt("0").flatMap(reciprocal).getOrElse(0.0))
  }
}

object EitherValidation {
  def parseAge(s: String): Either[String, Int] =
    s.toIntOption.toRight("年龄不是整数")

  def check(age: Int): Either[String, Int] =
    if (age < 0) Left("年龄不能为负")
    else if (age > 150) Left("年龄不合理")
    else Right(age)

  def register(name: String, rawAge: String): Either[String, String] =
    for {
      age <- parseAge(rawAge)
      valid <- check(age)
    } yield s"$name 报名成功，年龄 $valid"

  def main(args: Array[String]): Unit = {
    println(register("张三", "20"))
    println(register("李四", "abc"))
    println(register("王五", "-3"))
    println(register("赵六", "200"))

    register("张三", "20") match {
      case Right(msg) => println(s"OK: $msg")
      case Left(err) => println(s"ERR: $err")
    }
  }
}

import scala.util.{Failure, Success, Try}

object TryDemo {
  def readInt(s: String): Try[Int] = Try(s.trim.toInt)

  def describe(s: String): String =
    readInt(s) match {
      case Success(n) => s"成功：$n"
      case Failure(e) => s"失败：${e.getClass.getSimpleName}"
    }

  def main(args: Array[String]): Unit = {
    println(describe("42"))
    println(describe("abc"))
    println(readInt("7").map(_ * 2).getOrElse(0))
    println(readInt("abc").recover { case _: NumberFormatException => -1 }.get)

    val e: Either[String, Int] =
      readInt("abc").toEither.left.map(_ => "输入不是整数")
    println(e)
    println(readInt("9").toOption)
  }
}