Category: Java

Things to consider when calling Kotlin from Java.

import academy.learnprogramming.kotlincode.*;

import static academy.learnprogramming.kotlincode.CarKt.topLevel;
import static academy.learnprogramming.kotlincode.StaticCar.anotherTopLevel;

public class Main {

    public static void main(String[] args) {
  // So how do we call the top-level function from the Car.kt file?
        topLevel(); // If we type the function name the IDE suggests an import (see above). Compiler will quietly generate static class for all top-level items and will give the class the same name as the Kotlin file name.
        // So if we want to refer to a class we use the file name:
        CarKt.topLevel();
        //To demonstrate how we can deal with naming conflicts:
//        anotherTopLevel(); // Without using JvmName to rename file IDE cannot locate this function
        anotherTopLevel(); //Once JvmName has been implemented the IDE will suggest an import under the 'StaticCar' file name
        CarKt.print("Print this Java string"); // We cannot invoke extension function like we would in Kotlin. Need to use standard call
        Car car = new Car("blue", "BMW", 2011);
        System.out.println(car.getModel()); // We call getters and setters from Java as standard as compiler has produced these for Kotlin class properties by default (val only generates getters). Wouldn't work if properties private
        Car2 car2 = new Car2("red", "Ferrari", 2017, false);
        car2.setColour("purple"); // If custom sets and gets are created Java will access those
//        car2.setModel("A3"); // But not if setter is private
//        car2.setYear(1999); // Doesn't exist as setters only generated for var not val
        System.out.println(car2.getColour());
        System.out.println(car2.isAutomatic()); // When dealing with Booleans generates getter name beginning with 'is'
        // If we want Java to access the property directly without going through getter or setter, we can add an @JvmField annotation to the property:
        int year = car2.year; // Can't use @JvmField with private properties or one that overrides another property or can be overridden, or one with const keyword
        // How do we access functions within companion objects? Same for non-anonymous object instances (instances we create using the object keyword)?
        // Must use @JvmStatic annotation. Results in two version being created. One in instance as normal, but also one as a Java static function.
        Car2.Companion.carComp(); // Without @JvmStatic we're accessing the instance method generated by the compiler, not the static version. So we can't type Car2.carComp()
        Car2.carComp2(); // With the @JvmStatic annotation. Means we're accessing the static version of the method.
        // This could be necessary if carComp() was accessing static properties
        // For named object instances i.e. Singletons:
        SingletonObj.INSTANCE.doSomething(); // We can go through the INSTANCE object to access the functions within. Compiler creates an instance and assigns INSTANCE to it
        SingletonObj2.doSomething2(); // If we annotate the function with @JvmStatic we can access it directly
        // Fields, if they're not private:
        System.out.println("is 4WD = " + Car2.Companion.is4WD()); // Without @JvmField
        System.out.println("is pimped out = " + Car2.isPimpedOut); // With @JvmField
        // If the field is a const you don't need to annotate it - automatically converted to static field:
        System.out.println("a constant = " + Car2.constant);
        // Also true for late initialised properties (whatever they are)

        // Null safety
        // Nothing stopping Java passing a null object to a nonNullable function parameter - Kotlin will generate an exception:
//        car2.printMe(null);
        // Kotlin doesn't require functions to declare what exceptions they can throw, whereas Java does.  What happens when we call an exception-able Kotlin function from Java?
//        CarKt.doIO(); // Throws IOException. Can we catch it?
//        try {
//            CarKt.doIO();
//        } catch (IOException e) { // Error - 'IOException is never thrown' - Java can't see the potential exception
//
//        }
        try {
            CarKt.doIO2();
        } catch (IOException e) { // @Throws annotation solves the problem
            System.out.println("IOException!");
        }
        // What happens when we've defined default parameters in a Kotlin function?
        CarKt.defaultArgs("The number is: ", 40);
//        CarKt.defaultArgs("The number is: "); // Error even though second argument should be optional
        // When a Kotlin function with default values is called, only one version is generated for Java (requires all parameters). Annotate with @JvmOverloads:
        CarKt.defaultArgs2("The number is: "); // All better
    }
}

fun topLevel() = println("I'm in the car file")

fun main() {
    "Print this".print() // Calling the extension function from within the Kotlin class, as standard
}

object SingletonObj {
    fun doSomething() = println("I'm doing something in the Singleton object")
}

object SingletonObj2 {
    @JvmStatic fun doSomething2() = println("I'm doing something in the second Singleton object")
}

fun doIO() {
    throw IOException()
}

@Throws(IOException::class)
fun doIO2() {
    throw IOException()
}

fun defaultArgs(str: String, num: Int = 25) {}

@JvmOverloads fun defaultArgs2(str: String, num: Int = 25) {}

class Car(val colour: String, var model: String, val year: Int) {

}

class Car2(colour: String, model: String, @JvmField val year: Int, val isAutomatic: Boolean) { // year property has been designated for direct access through Java

    companion object {
        const val constant = 25
        val is4WD = false
        @JvmField val isPimpedOut = true
        fun carComp() = println("I'm in car's companion object")
        @JvmStatic fun carComp2() = println("I'm also in car's companion object")
    }

    fun printMe(text: String) {
        println("I don't expect a null value: $text")
    }

    var colour: String = colour
    set(value) { // example custom setter which always produces same output
        field = "always green"
    }
    var model: String = model
    private set(value) {
        field = "Focus"
    }
}

fun String.print() { // Extension function
    println(this)
}