kotlin get static type of a class property-CodePudding

I'm trying to get the type of some class properties in order to strongly typing my Kotlin Code. In typescript, we can do this (stupid examplebut this is to explain)

class Test {
    private  _prop:string
    constructor(val:Test["_prop"]){
        this._prop = val
    }
     public get prop():Test["_prop"] { return this._prop}
}
const t:Test["_prop"] = "fdds"

The benefit here is that if I need to chnange the type of "_prop", no need to refactor the whole code, as the type is find thanks to Test["_prop"]. Is there a way to do this in Kotlin ?

I've seen reflection functions in Kotlin, but can't get what I want

Kotlin code :

class Test(val prop:Int) {
    fun ppr() {
        println(prop)
    }
    
    fun getProp():Int {
        return prop
    }
}


fun main() {
    println("Hello, world!!!")
    
    
    var t:Test = Test(4)
    t.ppr()
    
    var a:Int = t.getProp()   // how to change :Int by "return type of func Test.prop

}

CodePudding user response：

What you're trying to do is the opposite of strong typing. The point of a strong-typed system is that you're defining exactly what things are, and the system requires you to interact with those things correctly, and prevents you from doing things those types don't support

You're working with specific types and defined type hierarchies, and the way you can interact them is strongly enforced. It's possible to go outside the type system, e.g. with unchecked casts, or by reflection (which can get close to throwing the whole thing out completely) - but that's losing the benefits of strong typing, the guarantees and assistance it can provide, and makes errors a lot more likely

Basically if you want to change the type, you're supposed to refactor it. That lets the system handle it all for you systematically, and it will point out any problems that change might introduce, so you can resolve and handle them. This is another benefit of a strongly typed system - it can help you in this way

If you want to stay within the type system, but just want to update a type and avoid creating changes in a bunch of files, then @Sweeper's typealias approach will work - kinda abstracting a type definition away to one place (and you can give it a more meaningful name that doesn't reflect the specific type it happens to be right now). But if you meaningfully change what that underlying type is, your code will probably have to handle it anyway, unless you're just doing a common call on it like toString().

I might have got what you're asking for wrong, but I wanted to point this stuff out just in case, since you were talking about reflection and all!

CodePudding user response：

You can't do it exactly like that in Kotlin, but you can declare a type alias, which sort of achieves the same result - enabling you to change the type of multiple things by editing only one place.

typealias PropType = Int

class Test(val prop: PropType) {
    fun prop(): PropType {
        return prop
    }
}

To change the type of both, just change the typealias PropType = Int line.

However, note that you don't actually need to do this if you just want to write a getter. You don't need to explicitly write getters if all it does is just returning the property's value. If you want to do something extra in the getter, you can do:

class Test(prop: Int) {
    val prop = prop
        get() {
            // do something extra in the getter
            println("getting prop!")
            return field // return the underlying field
        }
}

The getter will be called whenever you access Test.prop, and again, you only need to change one place to change the type of the property.