转换成Kotlin后如何访问Java接口静态变量

我有一个Java接口，带有静态变量

interfaceValue

，我可以访问它，如下所示

public class Experimenting {

    public interface MyInteface {
        int interfaceValue = 10;
    }

    class MyImpl implements MyInteface { }

    MyImpl myImpl = new MyImpl();

    void testing() {
        int getInterfaceValue = myImpl.interfaceValue;
    }
}

class Experimenting {

    internal var myImpl = MyImpl()

    interface MyInteface {
        companion object {
            val interfaceValue = 10
        }
    }

    internal inner class MyImpl : MyInteface

    internal fun testing() {
        val getInterfaceValue = myImpl.interfaceValue
    }
}

当我转换成Kotlin时，如下所示

public class Experimenting {

    public interface MyInteface {
        int interfaceValue = 10;
    }

    class MyImpl implements MyInteface { }

    MyImpl myImpl = new MyImpl();

    void testing() {
        int getInterfaceValue = myImpl.interfaceValue;
    }
}

class Experimenting {

    internal var myImpl = MyImpl()

    interface MyInteface {
        companion object {
            val interfaceValue = 10
        }
    }

    internal inner class MyImpl : MyInteface

    internal fun testing() {
        val getInterfaceValue = myImpl.interfaceValue
    }
}

---

但是，

myImpl.interfaceValue

显示编译错误符号，它无法识别

interfaceValue

。我怎么还能在Kotlin中访问我的

interfaceValue

？

转换将转换为

同伴中的
val
。不幸的是，转换器并不完美，有时会把事情搞砸。访问它

import com.your.package.Experimenting.MyInteface.Companion.interfaceValue    
class Experimenting {

    internal var myImpl = MyImpl()

    interface MyInteface {
        companion object {
           const val interfaceValue = 10
        }
    }

    internal inner class MyImpl : MyInteface

    internal fun testing() {
        val getInterfaceValue = interfaceValue
    } 
}

这就是诀窍

还包括：

class Experimenting {

    internal var myImpl = MyImpl()

    interface MyInteface {
        companion object {
           val interfaceValue = 10
        }
    }

    internal inner class MyImpl : MyInteface

    internal fun testing() {
        val getInterfaceValue = MyInteface.interfaceValue
    }
}

第三种方法是将
interfaceValue
的值复制到实现类中：

class Experimenting {

    internal var myImpl = MyImpl()

    interface MyInteface {
        companion object {
            const val interfaceValue = 10
        }
    }

    internal inner class MyImpl : MyInteface{
        val interfaceValue = MyInteface.interfaceValue
    }

    internal fun testing() {
        val getInterfaceValue = myImpl.interfaceValue
    }
}

基本上，您访问它就像访问java中的静态变量一样。
我想这种java代码到Kotlin代码的正确转换应该如下所示

class Experimenting {

    internal var myImpl = MyImpl()

    interface MyInteface {

        val interfaceValue: Int
        get() = 10
    }

    internal inner class MyImpl : MyInteface

    internal fun testing() {
        val getInterfaceValue = myImpl.interfaceValue
    }
}

虽然在语法上它们是不同的，也就是说，
interface evalue
不再是一个真正的静态变量，但实际上是一样的。
在interface中声明变量是丑陋和糟糕的做法hanks@Eugene。我只是在试验语言功能。谢谢。我喜欢你的答案，但是这使得
interfaceValue
不再可以从实现者那里访问，这使得它与最初的意图有所不同。我仍然投票支持它的语法正确性。谢谢我有另一个答案，我认为它模仿了最初的行为。看看吧，让我想想你的想法。谢谢。您的回答将
interfaceValue
的限制从
final
放宽到
open
。它也不再是静态的。同意，它不再是语法正确的。虽然它不是最终的，但也不是可变的。因此，在实际中，该用法将更类似于原始Java版本。
final
，因为您无法覆盖或更改它。您不能在java接口中更改
interfaceValue
的值，因为这样做可以覆盖
interfaceValue
。如果这是你想要的，那就去做吧。它确实取决于<代码> java接口> <代码> >（我的答案和行为是Java中的），或者应该能够被重写（这个）。考虑<代码>内部内部类MyyIMPL：MyPi饰面{OpLimaValItAutoValue:int GET（）= 11 } < /代码>我看到，可以推翻它。你有一点，那就是细微的不同。这种差异会导致难以修复的bug。因此，如果您这样做，不要假设它等于java代码科特林，还有科特林！=JAVA两者都有其利弊。