Method calling kotlin - kotlin

Question

I'm sure there is already an answer for this, but I'm very new and a lot of the answers I found look overly complicated and well past my experience as a programmer.
I created a class with a method, I wish to call on that method to display after it promts the user for input. I know where to call on the method. But don't know how to in kotlin. PLEASE HELP!
Here's my code
fun main() {
println("Enter degrees in Fahrenheit")
}
class ComputeMethods(){
fun tempConversion(degreesF: Double){
var degreesF = readln().toDouble()
var degreesC = (degreesF - 32.0) * 5.0 / 9.0;
var conversion = "$degreesF degrees Fahrenheit = $degreesC degrees Celsius"
println(conversion)
}
}

Answer 1

It's better to read user input inside main() and pass it to the method
fun main() {
println("Enter degrees in Fahrenheit")
ComputeMethods().tempConversion(readln().toDouble())
}
class ComputeMethods(){
fun tempConversion(degreesF: Double){
var degreesC = (degreesF - 32.0) * 5.0 / 9.0;
var conversion = "$degreesF degrees Fahrenheit = $degreesC degrees Celsius"
println(conversion)
}
}

Answer 2

I think what's confusing you here is you're creating a class and putting the method inside that, as a member function. That means to actually call that method, you need to create an instance of the class:
val methods = ComputeMethods()
and then call the method on that object:
methods.tempConversion(degrees)
Or all in one line, chaining the creation and call together:
ComputeMethods().tempConversion(degrees)
That's something you'll often do, but in this case it makes more sense to just have the function as a top-level function, like main is:
fun main() {
println("Enter degrees in Fahrenheit")
// use a val if you don't need to change the value later
val degreesF = readln().toDouble()
val conversion = tempConversion(degreesF)
println(conversion)
}
fun tempConversion(degreesF: Double) {
var degreesF = readln().toDouble()
var degreesC = (degreesF - 32.0) * 5.0 / 9.0;
var conversion = "$degreesF degrees Fahrenheit = $degreesC degrees Celsius"
}
I've moved things around a bit, but you can see that now you can just call tempConversion like any other function, it's just there (it's visible in the scope, if you want to get technical). Utility functions often work like this, where you don't need an instance of a class to access them.
(the rest of this might be a bit complicated if you're new to this, don't worry about it if it doesn't all make sense - just giving you an idea of things you can do)
If you did want to organise things inside an object like that (as a kind of namespace) you could create an object:
object ComputeMethods {
fun tempConversion(degreesF: Double) {
...
}
}
An object is like a singleton instance of a class - you don't need to create it, and there's only one of them that everything uses. So you can call your function inside it like this:
ComputeMethods.tempConversion(degrees)
You have to access the function through the object, but that can be nice for organisation - you can keep all your compute methods together, and it's clear exactly where that function is when you call it. Nice if your function has a generic name too!
You can also do that on an actual class too, if you want, by putting functions inside its companion object:
class SomeThing {
companion object {
fun coolFunction()
}
}
Then you can call the function through the class itself, SomeThing.coolFunction(). The difference with the object approach up there is that this is a class that you want to create instances of, objects you use. But the companion object allows you to add functions and properties that aren't tied to any specific instance, you can just access them through the class name, as "something related to the class as a whole". The plain object version up there is useful if you don't need the instances at all.