การสืบทอดคลาสเคส Scala

ฉันมีแอปพลิเคชันที่ใช้ Squeryl ฉันกำหนดโมเดลของฉันเป็นคลาสเคสส่วนใหญ่เนื่องจากฉันสะดวกที่จะมีวิธีการคัดลอก

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

จนถึงตอนนี้ฉันใช้คลาสเคสเดียวเท่านั้นโดยมีแฟล็กที่แยกแยะประเภทของโมเดลและเมธอดทั้งหมดที่แตกต่างกันตามประเภทของโมเดลเริ่มต้นด้วย if นี่เป็นเรื่องที่น่ารำคาญและไม่ค่อยปลอดภัย

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

อะไรคือปัญหาและข้อผิดพลาดที่ฉันควรทราบในการสืบทอดจากคลาสเคส มันสมเหตุสมผลไหมในกรณีของฉันที่จะทำเช่นนั้น

วิธีที่ฉันต้องการในการหลีกเลี่ยงการสืบทอดคลาสเคสโดยไม่มีการทำซ้ำโค้ดค่อนข้างชัดเจน: สร้างคลาสพื้นฐานทั่วไป (นามธรรม):

abstract class Person {
  def name: String
  def age: Int
  // address and other properties
  // methods (ideally only accessors since it is a case class)
}

case class Employer(val name: String, val age: Int, val taxno: Int)
    extends Person

case class Employee(val name: String, val age: Int, val salary: Int)
    extends Person

หากคุณต้องการละเอียดมากขึ้นให้จัดกลุ่มคุณสมบัติเป็นลักษณะเฉพาะ:

trait Identifiable { def name: String }
trait Locatable { def address: String }
// trait Ages { def age: Int }

case class Employer(val name: String, val address: String, val taxno: Int)
    extends Identifiable
    with    Locatable

case class Employee(val name: String, val address: String, val salary: Int)
    extends Identifiable
    with    Locatable

เนื่องจากนี่เป็นหัวข้อที่น่าสนใจสำหรับหลาย ๆ คนผมขออธิบายตรงนี้

คุณสามารถใช้แนวทางต่อไปนี้:

// You can mark it as 'sealed'. Explained later.
sealed trait Person {
  def name: String
}

case class Employee(
  override val name: String,
  salary: Int
) extends Person

case class Tourist(
  override val name: String,
  bored: Boolean
) extends Person

ใช่คุณต้องทำซ้ำช่อง ถ้าคุณทำไม่ได้มันก็จะเป็นไปไม่ได้ที่จะใช้ความเสมอภาคที่ถูกต้องของปัญหาอื่น ๆ

อย่างไรก็ตามคุณไม่จำเป็นต้องทำซ้ำวิธีการ / ฟังก์ชัน

หากการทำซ้ำคุณสมบัติบางอย่างมีความสำคัญกับคุณมากให้ใช้คลาสปกติ แต่อย่าลืมว่าคุณสมบัติเหล่านี้ไม่เหมาะกับ FP

หรือคุณสามารถใช้องค์ประกอบแทนการสืบทอด:

case class Employee(
  person: Person,
  salary: Int
)

// In code:
val employee = ...
println(employee.person.name)

การจัดองค์ประกอบเป็นกลยุทธ์ที่ถูกต้องและเป็นกลยุทธ์ที่ดีที่คุณควรพิจารณาเช่นกัน

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

val x = Employee(name = "Jack", salary = 50000)

x match {
  case Employee(name) => println(s"I'm $name!")
}

ให้ข้อผิดพลาด:

warning: match is not exhaustive!
missing combination            Tourist

ซึ่งมีประโยชน์จริงๆ. ตอนนี้คุณจะไม่ลืมที่จะจัดการกับประเภทอื่น ๆ ของPersons (คน) นี่คือสิ่งที่Optionชั้นเรียนใน Scala ทำ

หากนั่นไม่สำคัญสำหรับคุณคุณสามารถทำให้มันไม่ปิดผนึกและโยนคลาสเคสลงในไฟล์ของพวกมัน และอาจจะไปกับองค์ประกอบ

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

แต่การใช้งานเท่ากับต่อหน้ามรดกนั้นค่อนข้างซับซ้อน พิจารณาสองคลาส:

class Point(x : Int, y : Int)

และ

class ColoredPoint( x : Int, y : Int, c : Color) extends Point

ดังนั้นตามคำจำกัดความ ColorPoint (1,4, สีแดง) ควรจะเท่ากับ Point (1,4) ซึ่งเป็นจุดเดียวกัน ดังนั้น ColorPoint (1,4, สีน้ำเงิน) ก็ควรจะเท่ากับ Point (1,4) ด้วยใช่ไหม? แต่แน่นอนว่า ColorPoint (1,4, สีแดง) ไม่ควรเท่ากับ ColorPoint (1,4, สีน้ำเงิน) เนื่องจากมีสีต่างกัน เอาล่ะคุณสมบัติพื้นฐานอย่างหนึ่งของความสัมพันธ์ความเท่าเทียมกันเสีย

อัพเดต

คุณสามารถใช้การสืบทอดจากลักษณะการแก้ปัญหามากมายดังที่อธิบายไว้ในคำตอบอื่น ทางเลือกที่ยืดหยุ่นยิ่งขึ้นคือการใช้คลาสประเภท ดูประเภทคลาสใน Scala มีประโยชน์สำหรับอะไร? หรือhttp://www.youtube.com/watch?v=sVMES4RZF-8

ในสถานการณ์เหล่านี้ฉันมักจะใช้การจัดองค์ประกอบแทนการสืบทอดเช่น

sealed trait IVehicle // tagging trait

case class Vehicle(color: String) extends IVehicle

case class Car(vehicle: Vehicle, doors: Int) extends IVehicle

val vehicle: IVehicle = ...

vehicle match {
  case Car(Vehicle(color), doors) => println(s"$color car with $doors doors")
  case Vehicle(color) => println(s"$color vehicle")
}

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