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

รูปแบบคลาสของชนิด

พหุสัณฐานแบบเฉพาะกิจ

รูปแบบคลาสของชนิด เป็นบทเรียน 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 บทเรียน

คลาสประเภทคืออะไร

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

แนวคิดนี้มาจาก Haskell และถูกใช้อย่างแพร่หลายในไลบรารี Scala เช่น Cats

ปัญหาที่คลาสประเภทช่วยแก้

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

ขั้นที่ 1: กำหนด Trait

คลาสประเภทคือ trait ที่รับชนิดข้อมูลเป็นพารามิเตอร์ ในที่นี้ Show[A] อธิบายวิธีแสดงค่า A ใด ๆ เป็น String

trait Show[A] {
  def show(value: A): String
}

@main def run(): Unit = {
  println("Show trait defined")
}

ขั้นที่ 2: จัดหาอินสแตนซ์

สำหรับชนิดข้อมูลรูปธรรมแต่ละชนิดที่ต้องการรองรับ ให้สร้าง instance ของ trait อินสแตนซ์เหล่านี้เรียกว่าอินสแตนซ์ของคลาสประเภท

trait Show[A] { def show(value: A): String }

object Main {
  val intShow: Show[Int] = (v: Int) => s"Int($v)"
  val strShow: Show[String] = (v: String) => s"Str($v)"

  def main(args: Array[String]): Unit = {
    println(intShow.show(7))
    println(strShow.show("hi"))
  }
}

ขั้นที่ 3: ใช้อินสแตนซ์

ฟังก์ชันจะรับอินสแตนซ์เป็นพารามิเตอร์ ฟังก์ชัน render เดียวกันจึงทำงานกับชนิดข้อมูลใด ๆ ที่มีอินสแตนซ์ Show

trait Show[A] { def show(value: A): String }

object Main {
  def render[A](value: A, s: Show[A]): String = s.show(value)

  val intShow: Show[Int] = (v: Int) => s"<$v>"

  def main(args: Array[String]): Unit = {
    println(render(99, intShow))
  }
}

ทำให้เป็นอิมพลิซิต

การส่งอินสแตนซ์ด้วยตนเองนั้นยุ่งยาก การกำหนดอินสแตนซ์เป็น implicit และพารามิเตอร์เป็น implicit (หรือ using ใน Scala 3) ช่วยให้คอมไพเลอร์จัดหาอินสแตนซ์ให้โดยอัตโนมัติ

trait Show[A] { def show(value: A): String }

object Main {
  implicit val intShow: Show[Int] = (v: Int) => s"<$v>"

  def render[A](value: A)(implicit s: Show[A]): String = s.show(value)

  def main(args: Array[String]): Unit = {
    println(render(42))
  }
}

พหุรูปแบบเฉพาะกิจ

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

trait Show[A] { def show(value: A): String }

object Main {
  implicit val intShow: Show[Int] = (v: Int) => s"int:$v"
  implicit val boolShow: Show[Boolean] = (v: Boolean) => s"bool:$v"

  def render[A](value: A)(implicit s: Show[A]): String = s.show(value)

  def main(args: Array[String]): Unit = {
    println(render(5))
    println(render(true))
  }
}

การทำงานกับชนิดข้อมูลที่กำหนดเอง

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

trait Show[A] { def show(value: A): String }

case class User(name: String, age: Int)

object Main {
  implicit val userShow: Show[User] = (u: User) => s"${u.name} (${u.age})"

  def render[A](value: A)(implicit s: Show[A]): String = s.show(value)

  def main(args: Array[String]): Unit = {
    println(render(User("Ada", 36)))
  }
}

คลาสประเภทกับอินเทอร์เฟซ

อินเทอร์เฟซผูกพฤติกรรมเข้ากับนิยามของชนิดข้อมูล ส่วนคลาสประเภทจะแยกทั้งสองสิ่งออกจากกัน

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

องค์ประกอบสามส่วน

คลาสประเภททุกคลาสมีสามส่วน:

  • trait (การดำเนินการนามธรรม)
  • อินสแตนซ์ (การนำไปใช้งานสำหรับแต่ละชนิดข้อมูล)
  • อินเทอร์เฟซ (ฟังก์ชันที่ต้องใช้อินสแตนซ์)

คุณจะได้สำรวจแต่ละส่วนในบทเรียนถัดไป

ตัวอย่างขนาดเล็กที่สมบูรณ์

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

trait Show[A] { def show(value: A): String }

object Main {
  implicit val intShow: Show[Int] = (v: Int) => s"#$v"
  implicit val strShow: Show[String] = (v: String) => '"' + v + '"'

  def printAll[A](xs: List[A])(implicit s: Show[A]): Unit =
    xs.foreach(x => println(s.show(x)))

  def main(args: Array[String]): Unit = {
    printAll(List(1, 2, 3))
    printAll(List("a", "b"))
  }
}

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจรูปแบบคลาสประเภทของคุณ

สรุปทบทวน

คุณได้เรียนรู้รูปแบบคลาสประเภท:

  • trait ที่รับพารามิเตอร์จะอธิบายการดำเนินการ
  • อินสแตนซ์นำไปใช้งานสำหรับแต่ละชนิดข้อมูล
  • พารามิเตอร์ implicit ช่วยให้คอมไพเลอร์จัดหาอินสแตนซ์
  • ทำให้เกิดพหุรูปแบบเฉพาะกิจ และช่วยให้คุณขยายชนิดข้อมูลที่ไม่ได้เป็นเจ้าของได้

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

บทเรียน “รูปแบบคลาสของชนิด” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบคลาสของชนิด”

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

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

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

บทเรียน “รูปแบบคลาสของชนิด” ใช้เวลานานแค่ไหน

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

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

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

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

  1. รูปแบบคลาสของชนิด
  2. การกำหนดอินสแตนซ์
  3. คลาสของชนิดที่พบบ่อย
  4. การอนุมานคลาสของชนิด
← กลับไปที่ Scala for Backend Engineering & Functional Programming