How to access Java Interface Static variable after converted to Kotlin

Question

I have a an Interface in Java with the static variable interfaceValue that I could access as below

public class Experimenting {

    public interface MyInteface {
        int interfaceValue = 10;
    }

    class MyImpl implements MyInteface { }

    MyImpl myImpl = new MyImpl();

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

When I convert to Kotlin, it is as below

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
    }
}

However the myImpl.interfaceValue is showing compile error sign, where by it doesn't recognize the interfaceValue. How could I still access my interfaceValue in Kotlin?

Thanks @Eugene. I'm just experimenting the language feature. — Elye
– Elye, Commented Oct 24, 2018 at 22:06

leonardkraemer · Accepted Answer · 2018-10-24 23:02:56Z

1

The conversion converts the static final interfaceValue to a val in the companion Kotlins equivalent of that. Unfortunately the converter is not perfect and sometimes messes thing up. To access it

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
    } 
}

does the trick.

also does:

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
    }
}

A third way would be to copy the value of interfaceValue into the implementing class:

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
    }
}

Basically you access it like you would access a static variable in java.

edited Oct 24, 2018 at 23:02

answered Oct 24, 2018 at 12:47

leonardkraemer

6,8931 gold badge36 silver badges59 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Elye Over a year ago

Thanks. I like your answer, but that makes the interfaceValue no longer accessible from the implementor, which makes it different from what it was originally intended. I still give you a vote for the syntactically correctness of it. Thanks!

Elye Over a year ago

I have another answer, which I think mimic the original behavior. stackoverflow.com/a/52978332/3286489 Do check it out and let me think what your thought is. Thanks.

leonardkraemer Over a year ago

Your answer loosens the constraints on interfaceValue from final to open. Also It will no longer be static.

Elye Over a year ago

Agree, it is no longer syntatically correct. Though it is not final, it is not mutable too. Hence in practical, the usage would be more similar to the original Java version.

leonardkraemer Over a year ago

final in the sense that you cannot override or change it. You can not change the value of interfaceValue in the java interface either

Elye · Accepted Answer · 2018-10-24 21:46:19Z

0

I guess the right conversion of such Java code to Kotlin code should be as below

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
    }
}

Though syntactically they are different, i.e. interfaceValue not really a static variable anymore, but practicality the same.

answered Oct 24, 2018 at 21:46

Elye

61.3k72 gold badges271 silver badges570 bronze badges

8 Comments

leonardkraemer Over a year ago

What this lets you do is override the interfaceValue. If this is what you want go for it. It really depends if the interfaceValue is constant for all MyInterfaces (my answer and the behaviout as it is in java) or should be able to be overridden (this).

leonardkraemer Over a year ago

consider internal inner class MyMyImpl : MyInteface{ override val interfaceValue : Int get() = 11 }

Elye Over a year ago

I see, one could override it. You have the point, that the subtle different.

leonardkraemer Over a year ago

This is the kind of difference that causes hard to fix bugs. So if you do this do not assume it to be equal to the java code.

Elye Over a year ago

I guess in short Java != Kotlin, and Kotlin != Java. Both have its pro con.

|

Collectives™ on Stack Overflow

How to access Java Interface Static variable after converted to Kotlin

2 Answers 2

5 Comments

8 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

8 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related