รูปแบบคลาสของชนิด
พหุสัณฐานแบบเฉพาะกิจ
รูปแบบคลาสของชนิด เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- รูปแบบคลาสของชนิด
- การกำหนดอินสแตนซ์
- คลาสของชนิดที่พบบ่อย
- การอนุมานคลาสของชนิด