类型转换 #

val byteVal: Byte = 10
val shortVal: Short = byteVal
val intVal: Int = shortVal
val longVal: Long = intVal
val floatVal: Float = longVal
val doubleVal: Double = floatVal

Byte → Short → Int → Long → Float → Double
                  ↓
                Char

val a: Byte = 10
val b: Short = 20
val sum = a + b

val c: Int = 100
val d: Long = 200L
val result = c + d

val doubleVal = 3.14159
val intVal = doubleVal.toInt
val longVal = doubleVal.toLong
val floatVal = doubleVal.toFloat

val longNum = 100L
val intNum = longNum.toInt
val shortNum = longNum.toShort
val byteNum = longNum.toByte

val largeLong = 9223372036854775807L
val intVal = largeLong.toInt
println(intVal)

val doubleVal = 3.99
val intVal2 = doubleVal.toInt
println(intVal2)

val charA = 'A'
val intVal = charA.toInt

val intVal2 = 65
val charVal = intVal2.toChar

val num = 42
val str1 = num.toString
val str2 = s"$num"
val str3 = f"$num"

val intStr = "123"
val intVal = intStr.toInt

val longStr = "123456789012345"
val longVal = longStr.toLong

val doubleStr = "3.14159"
val doubleVal = doubleStr.toDouble

val floatStr = "3.14f"
val floatVal = floatStr.toFloat

val boolStr = "true"
val boolVal = boolStr.toBoolean

val maybeInt = "123".toIntOption
val invalid = "abc".toIntOption

maybeInt match
  case Some(n) => println(s"Number: $n")
  case None => println("Invalid number")

val result = "123".toIntOption.getOrElse(0)

def safeToInt(str: String): Option[Int] =
  try
    Some(str.toInt)
  catch
    case _: NumberFormatException => None

safeToInt("123")
safeToInt("abc")

val x: Any = "Hello"
val str = x.asInstanceOf[String]

val y: Any = 42
val num = y.asInstanceOf[Int]

val x: Any = "Hello"
val num = x.asInstanceOf[Int]

val x: Any = "Hello"

val result = x match
  case s: String => s"String: $s"
  case i: Int => s"Int: $i"
  case d: Double => s"Double: $d"
  case _ => "Unknown type"

val x: Any = 42

if x.isInstanceOf[Int] then
  val num = x.asInstanceOf[Int]
  println(s"Number: $num")

val maxInt = Int.MaxValue
val overflow = maxInt + 1
println(s"Overflow: $overflow")

val safeAdd = Math.addExact(maxInt, 1)

val str: String = "Hello"
val ops: scala.collection.StringOps = str

val intVal: Int = 42
val richInt: scala.runtime.RichInt = intVal

implicit class StringExtensions(val s: String) extends AnyVal:
  def greet: String = s"Hello, $s!"

val name = "Scala"
println(name.greet)

val input = "123"

val result1 = input.toIntOption.getOrElse(0)

val result2 = scala.util.Try(input.toInt).getOrElse(0)

def process(value: Any): String = value match
  case s: String => s"String: $s"
  case i: Int => s"Int: $i"
  case d: Double => s"Double: $d"
  case b: Boolean => s"Boolean: $b"
  case _ => s"Unknown: $value"

val x: Any = "Hello"

val result = x match
  case s: String => s.toUpperCase
  case _ => ""

def parseNumber(str: String): Either[String, Int] =
  str.toIntOption match
    case Some(n) => Right(n)
    case None => Left(s"Cannot parse '$str' as Int")

parseNumber("123")
parseNumber("abc")

val largeLong = 123456789012345L
val intVal = largeLong.toInt
println(intVal)

val doubleVal = 3.99
val truncated = doubleVal.toInt
println(truncated)

val maxInt = Int.MaxValue
val overflow = maxInt + 1
println(overflow)

val checked = Math.addExact(maxInt, 1)

val nullStr: String = null
val upper = nullStr.toUpperCase

val safeUpper = Option(nullStr).map(_.toUpperCase).orNull

val invalid = "abc".toInt

val safe = scala.util.Try("abc".toInt).getOrElse(0)

def safeByteValue(l: Long): Option[Byte] =
  if l >= Byte.MinValue && l <= Byte.MaxValue then
    Some(l.toByte)
  else
    None

safeByteValue(100)
safeByteValue(1000)

def safeAdd(a: Int, b: Int): Option[Int] =
  val result = a.toLong + b.toLong
  if result >= Int.MinValue && result <= Int.MaxValue then
    Some(result.toInt)
  else
    None

safeAdd(Int.MaxValue, 1)
safeAdd(100, 200)

object TypeConverter:
  def toIntSafely(value: Any): Option[Int] = value match
    case i: Int => Some(i)
    case l: Long => if l >= Int.MinValue && l <= Int.MaxValue then Some(l.toInt) else None
    case d: Double => Some(d.toInt)
    case s: String => s.toIntOption
    case _ => None

TypeConverter.toIntSafely(42)
TypeConverter.toIntSafely(42L)
TypeConverter.toIntSafely("42")
TypeConverter.toIntSafely("abc")