2017-12-05 6 views
7

वहाँ एक सील बंद वर्ग है:सील वर्ग के वस्तुओं रहस्यमय तरीके से अशक्त बनता जा रहा है जब अन्य साथी वस्तु द्वारा संदर्भित

sealed class Alphabet(val name: String) { 
    object A : Alphabet("A") 
    object B : Alphabet("B") 
    object C : Alphabet("C") 
    object D : Alphabet("D") 
    object E : Alphabet("E") 

    companion object { 
    val array = arrayOf(A, B, C, D, E) 
    val list = listOf(A, B, C, D, E) 
    } 

    override fun toString(): String { 
    return name 
    } 
} 

और वहाँ साथी वस्तु के साथ एक और वर्ग है:

class AlphabetMap { 

    companion object { 
    val map = mapOf(
     Alphabet.A to 1, 
     Alphabet.B to 2, 
     Alphabet.C to 3, 
     Alphabet.D to 4, 
     Alphabet.E to 5 
    ) 
    } 
} 

और अगर मैं प्रिंट करना चाहते हैं सरणी (या सूची):

class AlphabetTest { 

    @Test 
    fun printValues() { 
    Alphabet.array.forEach { print("$it ") };println() 
    Alphabet.list.forEach { print("$it ") };println() 
    } 
} 

यह सही ढंग से परिणाम प्रिंट करता है:

A B C D E 
A B C D E 

लेकिन अगर मैं कोड में AlphabetMap प्रारंभ:

class AlphabetTest { 

    val m = AlphabetMap() 

    @Test 
    fun printValues() { 
    Alphabet.array.forEach { print("$it ") };println() 
    Alphabet.list.forEach { print("$it ") };println() 
    } 
} 

परिणाम रहस्यमय तरीके से हो जाता है:

null B C D E 
null B C D E 

पहला तत्व (ए) हो जाता है अशक्त

अगर मैं परिभाषित करें

val m = AlphabetMap 

परिणाम वही है।

अगर मैं समारोह में AlphabetMap init:

@Test 
    fun printValues() { 
    val m = AlphabetMap() // or val m = AlphabetMap 
    Alphabet.array.forEach { print("$it ") };println() 
    Alphabet.list.forEach { print("$it ") };println() 
    } 

परिणाम एक ही है:

null B C D E 
null B C D E 

लेकिन अगर मैं इस तरह init:

@Test 
    fun printValues() { 
    Alphabet.array.forEach { print("$it ") };println() 
    val m = AlphabetMap() // or val m = AlphabetMap 
    Alphabet.list.forEach { print("$it ") };println() 
    } 

सब कुछ अब ठीक काम करता है :

A B C D E 
A B C D E 

अगर मैं

class AlphabetMap { 
    companion object { 
    val map = mapOf(
     //Alphabet.A to 1, 
     Alphabet.B to 2, 
     Alphabet.C to 3, 
     Alphabet.D to 4, 
     Alphabet.E to 5 
    ) 
    } 
} 

को AlphabetMap पुनर्लेखन परिणाम

A null C D E 
A null C D E 

हो जाता है और अगर AlphebetMap है:

class AlphabetMap { 
    companion object { 
    val map = mapOf(
     Alphabet.E to 5 
    ) 
    } 
} 

परिणाम हो जाता है:

A B C D null 
A B C D null 

क्या गलत हो सकता है? क्या यह एक बग है? या भाषा सुविधा?

वातावरण: jdk1.8।0_144, ओएस एक्स

<kotlin.version>1.2.0</kotlin.version> 
<kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget> 
<kotlin.compiler.incremental>false</kotlin.compiler.incremental> 
<dependency> 
    <groupId>org.jetbrains.kotlin</groupId> 
    <artifactId>kotlin-stdlib</artifactId> 
    <version>${kotlin.version}</version> 
</dependency> 

<dependency> 
    <groupId>org.jetbrains.kotlin</groupId> 
    <artifactId>kotlin-stdlib-jdk8</artifactId> 
</dependency> 
<dependency> 
    <groupId>org.jetbrains.kotlin</groupId> 
    <artifactId>kotlin-reflect</artifactId> 
</dependency> 
<dependency> 
    <groupId>org.jetbrains.kotlinx</groupId> 
    <artifactId>kotlinx-coroutines-core</artifactId> 
</dependency> 
<dependency> 
    <groupId>org.jetbrains.kotlin</groupId> 
    <artifactId>kotlin-test-junit</artifactId> 
    <scope>test</scope> 
</dependency> 
<dependency> 
    <groupId>org.jetbrains.kotlin</groupId> 
    <artifactId>kotlin-test</artifactId> 
    <scope>test</scope> 
</dependency> 
+1

मुझे संदेह है कि यह जावा में स्थिर प्रारंभिक आदेश समस्या का एक रूप है। –

+0

@smallufo: कृपया उत्तर के रूप में अपना अंतिम अपडेट पोस्ट करें, यह प्रश्न में शामिल नहीं है। –

+0

@WilliMentzel ठीक है, किया। – smallufo

उत्तर

1

इस समस्या को हल पाने के लिए एक ही रास्ता कक्षा के बाहर नक्शा परिभाषा स्थानांतरित करने के लिए है:

val map = mapOf(
    Alphabet.A to 1, 
    Alphabet.B to 2, 
    Alphabet.C to 3, 
    Alphabet.D to 4, 
    Alphabet.E to 5 
) 

class AlphabetMap { 
    companion object { 

    } 
} 

JetBrain के reply on youtrack और reddit के अनुसार, इस है के रूप में डिजाइन, इसे हल करने का कोई तरीका नहीं है।

प्रारंभ में चक्रों की समस्या का कोई सामान्य समाधान नहीं है। ऑब्जेक्ट का प्रारंभकर्ता, यदि ऑब्जेक्ट बी एक्सेस करता है और ऑब्जेक्ट बी का प्रारंभकर्ता ऑब्जेक्ट ए एक्सेस करता है, तो उनमें से एक अनियमित स्थिति में दूसरे को देख पाएगा।

संबंधित मुद्दे