आगे वर्ग संदर्भ?

Question

मैं स्काला के एक नौसिखिया के रूप में एक मानक समस्या में चल रहा हूँ: मैं कैसे इस तरह से दो वर्गों परिभाषित करते हैं कि मैं एक का एक उदाहरण बना सकते हैं सदस्य चर, जो बारी अंक में पहले उदाहरण के लिए वापस के रूप में अन्य कि ?

मैं खेल का एक उदाहरण है जो प्रकार डीलर जो के प्रकार के खेल के एक सदस्य है, जो वास्तव में मूल खेल उदाहरण

तो इस मामले में प्रत्येक के एक सदस्य के साथ खत्म करना चाहते हैं उदाहरण (गेम, डीलर) में एक सदस्य है जो दूसरा उदाहरण है। क्या कोई मुझे इस के लिए सही तरीके से मार्गदर्शन कर सकता है?

Answer 1

मुझे लगता है कि आप "दो तरह" निर्भरता के बारे में बात कर रहे हैं, और यह करना आसान है यदि इकाइयों में से एक अधिकतम अपरिवर्तनीय है (यदि आप दोनों अपरिवर्तनीय होना चाहते हैं तो आपको मूविज़ समाधान देखना चाहिए)।

मेरे उदाहरण में मैं Game अपरिवर्तनीय इकाई रहने दो। एक डीलर एक खेल में शामिल नहीं हो सकता है।

class Dealer(val name: String){ 
    var game: Option[Game] = None 
} 

case class Game(name: String, dealer: Dealer) 

// Instanciate the game and the dealer 
val olle = new Dealer("Olle") 
val ollesGame = Game("Olles Game", olle) 
olle.game = Some(ollesGame) 

Answer 2

आप यहाँ दो विकल्प हैं:

1. , अपने वस्तुओं परिवर्तनशील बनाओ तो केवल आपके जावा में होगा के रूप में बिल्कुल एक ही तकनीक का उपयोग करें।
2. , उन्हें अपरिवर्तनीय बनाओ तो दो तरह से उनकी निर्भरता को दे।

यह देखने के लिए, क्यों (अपरिवर्तनीय) पेड़ों के बीच निम्नलिखित परिवर्तन पर विचार करें। ये दोनों हर माता-पिता नोड बच्चे नोड्स की एक सूची पकड़े साथ परिभाषित कर रहे हैं, लेकिन बच्चों को उनके माता-पिता पता नहीं है:

a    (a) 
    b    (b) 
    c    c 
    d  -->  (d) 
    e    e 
    f    f 
    g    g 

विशेष रूप से, नोड d नए मान के साथ क्लोन किया गया था। ऐसा करने के लिए, हमें सभी अभिभावक नोड्स (ब्रैकेट में दिखाए गए) को क्लोन करना पड़ा।

हैं नोड्स उनके माता पिता का आयोजन किया है, तो c नई b नोड प्रतिबिंबित करने के लिए "अद्यतन" करना होगा, और e, f, g नई a नोड के साथ अपडेट किया होगा। अर्थात पूरे पेड़ कॉपी किया जा करने के लिए होगा!

केवल एक दिशा में, माता-पिता से बच्चे तक संबंधों को पकड़कर, संरचना के लगातार संस्करणों में c, e, f, g का पुन: उपयोग करना संभव हो जाता है। यह एक शक्तिशाली अनुकूलन है, और कुशल कार्यात्मक एल्गोरिदम लिखने की कुंजी है।

Answer 3

तुम सच में कक्षाएं अपरिवर्तनीय अपने ही एकमात्र विकल्प निर्माता में नाम मापदंडों से उपयोग करने के लिए और हमेशा आलसी val रों के रूप में उदाहरण बना है बनाने के लिए की जरूरत है:

class Dealer(val name: String, g: => Game) { 
    lazy val game = g 
    override def toString = "Dealer(name=%s, game=%s)".format(name, game.name) 
} 

class Game(val name: String, d: => Dealer) { 
    lazy val dealer = d 
    override def toString = "Game(name=%s, dealer=%s)".format(name, dealer.name) 
} 

lazy val game: Game = new Game("Doppelkopf", new Dealer("Peter", game)) 
lazy val dealer: Dealer = new Dealer("Tina", new Game("Poker", dealer)) 

ध्यान दें कि आप पर प्रकार जोड़ना जरूरत आलसी vals या यह संकलन नहीं होगा।