0Pricing
Scala for Backend Engineering & Functional Programming · บทเรียน

คลาส Case

ตัวเก็บข้อมูลที่แก้ไขไม่ได้

คลาส Case เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน

คลาสกรณีคืออะไร

คลาสกรณี คือคลาสชนิดพิเศษที่ออกแบบมาเพื่อเก็บข้อมูลที่เปลี่ยนแปลงไม่ได้ โดยประกาศด้วย case class

Scala จะสร้างโค้ดที่มีประโยชน์จำนวนมากให้โดยอัตโนมัติ ทำให้คลาสกรณีเป็นวิธีหลักที่ใช้สร้างแบบจำลองข้อมูล

การประกาศคลาสกรณี

เพียงระบุฟิลด์ต่าง ๆ ในรายการพารามิเตอร์ พารามิเตอร์แต่ละรายการจะกลายเป็นฟิลด์ที่เปลี่ยนแปลงไม่ได้

ไม่จำเป็นต้องใช้คีย์เวิร์ด new เพื่อสร้างอินสแตนซ์

case class Point(x: Int, y: Int)
object Main {
  def main(args: Array[String]): Unit = {
    val p = Point(3, 4)
    println(p.x)
    println(p.y)
  }
}

toString อัตโนมัติ

คลาสกรณีจะได้รับ toString ที่อ่านง่ายโดยไม่ต้องเขียนเอง ซึ่งแสดงชื่อคลาสและค่าของฟิลด์

จึงช่วยให้การแก้ไขข้อบกพร่องและการบันทึกข้อมูลการทำงานทำได้ง่าย

case class Point(x: Int, y: Int)
object Main {
  def main(args: Array[String]): Unit = {
    val p = Point(1, 2)
    println(p)
  }
}

ความเท่าเทียมตามค่า

คลาสกรณีเปรียบเทียบกันตามค่า ไม่ใช่การอ้างอิง อินสแตนซ์สองรายการที่มีฟิลด์เหมือนกันจะถือว่าเท่ากัน

ส่วนคลาสทั่วไปจะเปรียบเทียบตามเอกลักษณ์ของอินสแตนซ์

case class Point(x: Int, y: Int)
object Main {
  def main(args: Array[String]): Unit = {
    val a = Point(1, 2)
    val b = Point(1, 2)
    println(a == b)
  }
}

ฟิลด์ที่เปลี่ยนแปลงไม่ได้

ฟิลด์ของคลาสกรณีจะเป็น val โดยค่าเริ่มต้น จึงไม่สามารถกำหนดค่าใหม่ได้

หากต้องการเวอร์ชันที่แก้ไขแล้ว ให้สร้างอินสแตนซ์ใหม่แทนการเปลี่ยนแปลงอินสแตนซ์เดิม

case class Point(x: Int, y: Int)
object Main {
  def main(args: Array[String]): Unit = {
    val p = Point(1, 2)
    println(p.x)
  }
}

เมธอด copy

คลาสกรณีทุกคลาสมีเมธอด copy ซึ่งสร้างอินสแตนซ์ใหม่และเปิดให้คุณเปลี่ยนเฉพาะฟิลด์ที่ระบุ

นี่เป็นวิธีมาตรฐานในการอัปเดตข้อมูลที่เปลี่ยนแปลงไม่ได้

case class Point(x: Int, y: Int)
object Main {
  def main(args: Array[String]): Unit = {
    val p = Point(1, 2)
    val moved = p.copy(y = 99)
    println(p)
    println(moved)
  }
}

การรองรับการจับคู่รูปแบบ

คลาสกรณีทำงานร่วมกับ match ได้อย่างราบรื่น คุณสามารถแยกโครงสร้างโดยตั้งชื่อฟิลด์ในรูปแบบ

นี่คือเหตุผลสำคัญประการหนึ่งที่ควรเลือกใช้คลาสกรณี

case class Point(x: Int, y: Int)
object Main {
  def describe(p: Point): String = p match {
    case Point(0, 0) => "origin"
    case Point(x, 0) => s"on x-axis at $x"
    case Point(x, y) => s"point ($x, $y)"
  }
  def main(args: Array[String]): Unit = {
    println(describe(Point(0, 0)))
    println(describe(Point(5, 0)))
    println(describe(Point(2, 3)))
  }
}

ค่าเริ่มต้นของพารามิเตอร์

เช่นเดียวกับคลาสทั่วไป คลาสกรณีสามารถกำหนดค่าเริ่มต้นให้พารามิเตอร์ได้ จึงไม่จำเป็นต้องระบุพารามิเตอร์เหล่านั้นเมื่อสร้างอินสแตนซ์

case class User(name: String, active: Boolean = true)
object Main {
  def main(args: Array[String]): Unit = {
    val u1 = User("Ada")
    val u2 = User("Bo", false)
    println(u1)
    println(u2)
  }
}

การเพิ่มเมธอด

คลาสกรณีสามารถมีเมธอดของตัวเองในเนื้อหาคลาสได้เช่นเดียวกับคลาสทุกชนิด เมธอดเหล่านั้นทำงานกับฟิลด์ที่เปลี่ยนแปลงไม่ได้

case class Rect(w: Int, h: Int) {
  def area: Int = w * h
}
object Main {
  def main(args: Array[String]): Unit = {
    val r = Rect(3, 4)
    println(r.area)
  }
}

เหตุใดจึงใช้คลาสกรณี

คลาสกรณีมอบสิ่งต่อไปนี้ให้โดยไม่ต้องเขียนเอง:

  • ตัวสร้างแบบกระชับพร้อมฟิลด์ที่เปลี่ยนแปลงไม่ได้
  • toString ที่อ่านง่าย
  • equals และ hashCode ที่อิงตามค่า
  • เมธอด copy
  • การรองรับการจับคู่รูปแบบอย่างเต็มรูปแบบ

คลาสกรณีเป็นพื้นฐานสำหรับการสร้างแบบจำลองข้อมูลใน Scala

นำทุกอย่างมารวมกัน

ตัวอย่างนี้สร้างคลาสกรณี คัดลอก เปรียบเทียบ และจับคู่รูปแบบภายในตัวอย่างเดียว

case class Money(amount: Int, currency: String)
object Main {
  def main(args: Array[String]): Unit = {
    val price = Money(10, "USD")
    val sale = price.copy(amount = 8)
    println(price == sale)
    sale match {
      case Money(a, "USD") => println(s"$a dollars")
      case Money(a, c)     => println(s"$a $c")
    }
  }
}

ตรวจสอบอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับคลาสกรณี

สรุปทบทวน

คุณได้เรียนรู้ว่า คลาสแบบ case ใช้สร้างแบบจำลองข้อมูลที่เปลี่ยนแปลงไม่ได้ พร้อมตัวช่วยที่สร้างขึ้นให้อัตโนมัติ:

  • สร้างได้โดยไม่ต้องใช้ new และฟิลด์เป็น val ที่เปลี่ยนแปลงไม่ได้
  • มี toString ให้ใช้ฟรี และมี equals/hashCode ที่เปรียบเทียบตามค่า
  • copy ใช้สร้างสำเนาที่แก้ไขแล้ว
  • รองรับการจับคู่รูปแบบในตัว
  • กำหนดค่าเริ่มต้นและเมธอดแบบกำหนดเองได้

คำถามที่พบบ่อย

บทเรียน “คลาส Case” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “คลาส Case” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “คลาส Case”

ตัวเก็บข้อมูลที่แก้ไขไม่ได้ คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “คลาส Case” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. คลาส Case
  2. Trait แบบปิดผนึก
  3. ชนิดข้อมูลเชิงพีชคณิต
  4. การจับคู่ที่ครบถ้วน
← กลับไปที่ Scala for Backend Engineering & Functional Programming