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

การสืบทอดและพหุสัณฐาน

สำรวจหลักการเชิงวัตถุ เช่น การสืบทอด คลาสนามธรรม และพหุสัณฐานใน Scala

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

การสืบทอดคืออะไร

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

ลองนึกภาพว่าเป็นความสัมพันธ์แบบ “พ่อแม่-ลูก” คลาส “ลูก” (คลาสย่อย) นำโค้ดจากคลาส “พ่อแม่” (คลาสฐาน) มาใช้ซ้ำ ช่วยประหยัดเวลาและทำให้มีความสอดคล้องกัน

  • ส่งเสริมการนำโค้ดกลับมาใช้ซ้ำ
  • สร้างความสัมพันธ์แบบ “เป็น” (เช่น Dog เป็น Animal)
  • ช่วยจัดระเบียบโค้ดให้เป็นลำดับชั้น

คลาสฐานแรกของคุณ

มากำหนดคลาส Animal อย่างง่ายกัน คลาสนี้จะเป็นคลาสฐาน หรือเรียกอีกอย่างว่าคลาสเหนือหรือคลาสพ่อแม่ โดยมีพฤติกรรมพื้นฐานคือการส่งเสียง

เรียกใช้โค้ดเพื่อดูสัตว์ทั่วไปของเราทำงาน!

class Animal {
  val name: String = "Generic Animal"
  def speak(): Unit = {
    println(s"$name makes a sound.")
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val myAnimal = new Animal()
    myAnimal.speak()
  }
}

การขยายคลาสด้วย `extends`

ตอนนี้มาสร้างสัตว์ที่เฉพาะเจาะจงมากขึ้น นั่นคือ Dog กัน Dog เป็น Animal ดังนั้นจึงสามารถสืบทอดจากคลาส Animal โดยใช้คีย์เวิร์ด extends

เรายังสามารถ เขียนทับ เมธอด speak เพื่อให้ Dog มีเสียงเฉพาะของตัวเองได้ โปรดสังเกตคีย์เวิร์ด override

class Animal {
  val name: String = "Generic Animal"
  def speak(): Unit = {
    println(s"$name makes a sound.")
  }
}

class Dog extends Animal {
  override val name: String = "Dog"
  override def speak(): Unit = {
    println(s"$name barks!")
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val myAnimal = new Animal()
    val myDog = new Dog()
    myAnimal.speak() // Generic Animal makes a sound.
    myDog.speak()    // Dog barks!
  }
}

พลังของ `override`

คีย์เวิร์ด override มีความสำคัญใน Scala ด้วยเหตุผลหลายประการ:

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

โปรดใช้ override ทุกครั้งเมื่อกำหนดสมาชิกที่สืบทอดมาใหม่!

พหุรูปแบบ: หลายรูปแบบ

พหุรูปแบบ หมายถึง “หลายรูปแบบ” ใน OOP แนวคิดนี้อนุญาตให้อ็อบเจกต์จากคลาสต่างกันถูกปฏิบัติเสมือนเป็นอ็อบเจกต์ของคลาสเหนือร่วมกัน

หมายความว่าคุณสามารถมีตัวแปรชนิด Animal ที่เก็บอ็อบเจกต์ Dog อ็อบเจกต์ Cat หรือคลาสย่อยอื่นใดของ Animal ได้ เมื่อเรียกใช้เมธอดผ่านตัวแปรนั้น ระบบจะเรียกใช้เมธอดที่ถูกต้องตามชนิดจริงของอ็อบเจกต์

  • ทำให้โค้ดยืดหยุ่นและขยายต่อได้
  • อนุญาตให้ใช้ส่วนติดต่อเดียวกับชนิดข้อมูลต่าง ๆ
  • เกิดขึ้นได้ผ่านการเขียนทับเมธอด

พหุรูปแบบในทางปฏิบัติ

มาดูพหุรูปแบบในการทำงานกัน เราจะสร้างคลาส Cat ที่คล้ายกับ Dog จากนั้นเราสามารถใส่สัตว์หลายชนิดลงในรายการที่มีชนิดเหนือร่วมกันคือ Animal และเรียกใช้เมธอด speak ของแต่ละตัวได้

สังเกตว่าสัตว์แต่ละชนิดส่งเสียงในแบบเฉพาะของตัวเอง แม้ว่าในรายการจะถูกปฏิบัติเสมือนเป็นชนิด Animal ทั้งหมด

class Animal {
  val name: String = "Generic Animal"
  def speak(): Unit = {
    println(s"$name makes a sound.")
  }
}

class Dog extends Animal {
  override val name: String = "Dog"
  override def speak(): Unit = {
    println(s"$name barks!")
  }
}

class Cat extends Animal {
  override val name: String = "Cat"
  override def speak(): Unit = {
    println(s"$name meows!")
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val animals: List[Animal] = List(
      new Animal(),
      new Dog(),
      new Cat()
    )

    animals.foreach(_.speak())
  }
}

การแนะนำคลาสนามธรรม

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

คลาสนามธรรม:

  • ไม่สามารถสร้างอินสแตนซ์ได้โดยตรง (คุณไม่สามารถสร้างอ็อบเจกต์จากคลาสนามธรรม)
  • สามารถมีเมธอดนามธรรม (เมธอดที่ไม่มีการทำงาน) และเมธอดรูปธรรม (เมธอดที่มีการทำงาน)
  • ทำหน้าที่เป็นพิมพ์เขียวที่คลาสย่อยต้องเติมเต็ม

การสร้างพิมพ์เขียวนามธรรม

มากำหนด abstract class Shape กัน รูปร่างทุกชนิดมีพื้นที่ แต่สูตรคำนวณจะแตกต่างกันไปตามรูปร่างแต่ละชนิด (วงกลม สี่เหลี่ยมผืนผ้า และอื่น ๆ)

ดังนั้นเราจึงประกาศ area เป็น เมธอดนามธรรม โปรดสังเกตว่าเมธอดนี้ไม่มีส่วนตัวเมธอด (ไม่มี = { ... }) คลาสย่อยจะเป็นผู้จัดเตรียมการทำงานให้เมธอดนี้

abstract class Shape {
  def area: Double // Abstract method, no implementation
  
  def describe(): Unit = {
    println("This is a geometric shape.")
  }
}

// You cannot do: new Shape() - it's abstract!

object Main {
  def main(args: Array[String]): Unit = {
    println("Abstract class Shape defined.")
    println("Cannot instantiate Shape directly.")
  }
}

การนำไปใช้งานแบบรูปธรรม

ตอนนี้มาสร้างคลาสย่อยแบบรูปธรรม เช่น Circle และ Rectangle ที่ขยายจาก abstract class Shape กัน คลาสย่อยเหล่านี้ต้องจัดเตรียมการทำงานให้เมธอดนามธรรม area

คลาสย่อยเหล่านี้ยังสืบทอดเมธอดรูปธรรม describe() จาก Shape ด้วย

abstract class Shape {
  def area: Double
  def describe(): Unit = {
    println("This is a geometric shape.")
  }
}

class Circle(radius: Double) extends Shape {
  override def area: Double = math.Pi * radius * radius
}

class Rectangle(width: Double, height: Double) extends Shape {
  override def area: Double = width * height
}

object Main {
  def main(args: Array[String]): Unit = {
    val circle = new Circle(5)
    val rectangle = new Rectangle(4, 6)

    println(s"Circle area: ${circle.area}")
    circle.describe()
    println(s"Rectangle area: ${rectangle.area}")
    rectangle.describe()
  }
}

ตรวจสอบการสืบทอดและพหุรูปแบบ

ข้อความใดต่อไปนี้เกี่ยวกับการสืบทอดและพหุรูปแบบใน Scala เป็น TRUE?

ทบทวน: การสืบทอดและพหุรูปแบบ

ทำได้ดีมาก! ในบทเรียนนี้ เราได้สำรวจแนวคิดหลักของ OOP ใน Scala:

  • การสืบทอด: วิธีที่คลาสย่อยนำโค้ดกลับมาใช้ซ้ำและสร้างความสัมพันธ์แบบ “เป็น” กับคลาสเหนือโดยใช้ extends
  • คีย์เวิร์ด override: จำเป็นสำหรับการกำหนดเมธอดและฟิลด์ที่สืบทอดมาใหม่อย่างชัดเจน ช่วยให้มั่นใจด้านความปลอดภัยของชนิดข้อมูลและความชัดเจน
  • พหุรูปแบบ: ความสามารถในการปฏิบัติต่ออ็อบเจกต์จากคลาสย่อยต่าง ๆ เสมือนเป็นอ็อบเจกต์ของคลาสเหนือร่วมกัน ทำให้โค้ดยืดหยุ่นและขยายต่อได้
  • คลาสนามธรรม: พิมพ์เขียวที่ไม่สามารถสร้างอินสแตนซ์ได้โดยตรง ใช้กำหนดส่วนติดต่อร่วมและสมาชิกนามธรรมที่คลาสย่อยต้องนำไปใช้งาน

แนวคิดเหล่านี้สำคัญอย่างยิ่งต่อการสร้างแอปพลิเคชัน Scala ที่มีโครงสร้างดีและดูแลรักษาได้ง่าย!

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

บทเรียน “การสืบทอดและพหุสัณฐาน” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การสืบทอดและพหุสัณฐาน”

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

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

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

บทเรียน “การสืบทอดและพหุสัณฐาน” ใช้เวลานานแค่ไหน

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

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

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

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

  1. คลาส ออบเจ็กต์ และการจัดแพ็กเกจ
  2. การสืบทอดและพหุสัณฐาน
← กลับไปที่ Scala for Backend Engineering & Functional Programming