ข้อดีของวัตถุสหายของ Scala เทียบกับวิธีการคงที่คืออะไร?

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

ต่อไปนี้เป็นสาเหตุบางประการที่อาจทำให้คุณสนใจมากหรือน้อยขึ้นอยู่กับความชอบของคุณ:

1. อย่าลดราคาเพียงเพราะเป็นน้ำตาลซินแทติกติก ในขณะที่คุณอาจพูดว่ามีอะไรบางอย่างเป็นเพียงน้ำตาล syntactic มันเป็นน้ำตาลที่ทำให้ชีวิตของคุณหวาน - ในฐานะโปรแกรมเมอร์เช่นเดียวกับกาแฟหรือดื่มชา

2. Singletons - Scala ทุกอันobjectมีอยู่ในตัวเดียว เมื่อพิจารณาว่าในโลก Java ผู้คนกำลังใช้งานซิงเกิลตันในหลากหลายรูปแบบและบ่อยครั้งที่ไม่ได้ทำผิดพลาดในการติดตั้งพวกเขาคุณไม่สามารถทำผิดพลาดง่าย ๆ แบบ Scala ได้ การเขียนobjectแทนที่จะclassทำให้เป็นซิงเกิลและเสร็จแล้ว

3. การเข้าถึงวิธีการคงที่: วิธีการคงที่ใน Java สามารถเข้าถึงได้จากวัตถุ ตัวอย่างเช่นสมมติว่าคุณได้เรียนCด้วยวิธีการแบบคงที่fและวัตถุประเภทc Cจากนั้นคุณควรโทรC.fแต่ Java อนุญาตให้คุณ (แม้ว่าจะมีคำเตือน) ให้ใช้c.fซึ่งเมื่อคุณมาจากพื้นหลังของสกาล่าก็ไม่สมเหตุสมผลเลยเพราะวัตถุไม่มีวิธีfจริงๆ

4. การแยกชัดเจน: ใน Java คุณสามารถผสมคุณลักษณะและวิธีการคงที่และไม่คงที่ในชั้นเรียน หากคุณทำงานอย่างมีวินัยสิ่งนี้จะไม่เป็นปัญหา แต่ถ้าคุณ (หรือคนอื่นสำหรับเรื่องนั้น) ทำไม่ได้คุณจะจบลงด้วยส่วนที่คงที่และไม่คงที่และคุณสามารถบอกได้อย่างรวดเร็ว มีอะไรคงที่และสิ่งที่ไม่ ใน Scala ทุกสิ่งที่อยู่ภายในวัตถุที่แสดงร่วมนั้นไม่ได้เป็นส่วนหนึ่งของออบเจกต์รันไทม์ของคลาสที่เกี่ยวข้อง แต่สามารถใช้ได้จากบริบทแบบสแตติก ในทางกลับกันถ้ามันถูกเขียนในชั้นเรียนจะมีให้กับอินสแตนซ์ของชั้นเรียนนั้น แต่ไม่ได้มาจากบริบทคงที่ สิ่งนี้จะกลายเป็นภาระโดยเฉพาะอย่างยิ่งใน Java เมื่อคุณเริ่มเพิ่มบล็อกเริ่มต้นคงที่และไม่คงที่ในชั้นเรียนของคุณ นี่อาจเป็นเรื่องยากที่จะเข้าใจในเรื่องของคำสั่งการเรียกใช้แบบไดนามิก

5. โค้ดที่น้อยลง: คุณไม่จำเป็นต้องเพิ่มคำว่าstaticให้กับแต่ละแอททริบิวต์หรือเมธอดทุกรายการในobjectดังนั้นจึงทำให้โค้ดมีความรัดกุมยิ่งขึ้น

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

ข้อดีอีกอย่างหนึ่งคือobjectสามารถใช้อินเตอร์เฟส / ลักษณะซึ่งแตกต่างจากวิธีการคงที่

วัตถุร่วมเป็นสถานที่แรกที่ค้นหา implicits หลังจากนั้น scala ดูที่ Predef และจากนั้นในคำสั่ง "นำเข้า" อย่างชัดเจนในไฟล์ต้นฉบับนั้น

ฉันยังไม่เพียงพอที่จะรู้ได้ว่าภาษาจาวาหรือไลบรารีมีกลไกที่เทียบเคียงได้หรือไม่