Kotlin maintains seamless compatibility with the JVM ecosystem, allowing direct invocation of existing Java libraries. When invoking a Java method that declares a void return type, the Kotlin compiler automatically translates this into kotlin.Unit. Any attempt to capture this return value will simply bind to Unit. Conversely, Java methods returning primitive or reference types are handled natively without conversion overhead.

Handling Return Types

Java Method with Void Return

// JavaUtility.java
public class JavaUtility {
    public static void computeTotal(int a, int b) {
        int sum = a + b;
        System.out.println("Computed total: " + sum);
    }
}

// MyKotlinSource.kt
fun main() {
    val result = JavaUtility.computeTotal(5, 10)
    println("Captured unit: $result")
}

Output:

Computed total: 15
Captured unit: kotlin.Unit

Java Method Returning Integers

// GeometryCalculator.java
public class GeometryCalculator {
    public static int calculateRectangleArea(int width, int height) {
        return width * height;
    }
}

// MyKotlinSource.kt
fun main() {
    val area = GeometryCalculator.calculateRectangleArea(3, 4)
    println("Area returned: $area")
}

Output:

Area returned: 12

Cross-Package Access

Invoking Java components defined in external packages requires standard Kotlin import statements. The compiler resolves these references at build time, enabling unrestricted access to public members regardless of package boundaries.

// com/example/kotlinapp/AppRunner.kt
package com.example.kotlinapp
import com.external.library.JavaUtility

fun main() {
    val area = JavaUtility.calculateRectangleArea(3, 4)
    println("Cross-package result: $area")
}

Accessing Getters and Setters

Kotlin's property accessors map directly to Java bean conventions. Developers can utilize dot notation for fields backed by getters/setters, while also retaining the ability to invoke the original accessor methods explicitly.

// UserProfile.java
package com.demo;
public class UserProfile {
    protected String givenName;
    protected String familyName;

    public String getGivenName() { return givenName; }
    public void setGivenName(String name) { this.givenName = name; }
    public String getFamilyName() { return familyName; }
    public void setFamilyName(String name) { this.familyName = name; }
}

// AppRunner.kt
import com.demo.UserProfile

fun main() {
    val user = UserProfile()
    
    // Kotlin property-style assignment
    user.familyName = "Doe"
    user.givenName = "John"

    // Direct method invocation remains valid
    user.setFamilyName("Smith")
    user.setGivenName("Jane")

    println("Via properties: ${user.givenName} ${user.familyName}")
    println("Via methods: ${user.getGivenName()} ${user.getFamilyName()}")
}

Output:

Via properties: Jane Smith
Via methods: Jane Smith

Passing Arrays as Arguments

Standard Java array parameters are accepted directly by Kotlin. The language passes the array reference transparently, eliminating the need for wrapper conversions.

// NumericProcessor.java
package com.math;
public class NumericProcessor {
    public int aggregateValues(int[] inputs) {
        int total = 0;
        for (int num : inputs) total += num;
        return total;
    }
}

// AppRunner.kt
import com.math.NumericProcessor

fun main() {
    val processor = NumericProcessor()
    val dataset = intArrayOf(1, 2, 3, 4, 5)
    val total = processor.aggregateValues(dataset)
    println("Aggregated sum: $total")
}

Output:

Aggregated sum: 15

Handling Varargs

Java's varible-length argument lists (varargs) are exposed as arrays in Kotlin. To pass a pre-existing Kotlin array into a vararg parameter, the spread operator (*) must be applied during the functon call. This applies to both single vararg methods and mixed-parameter signatures.

Single Vararg Example

// OutputLogger.java
public class OutputLogger {
    public void logEntries(int... numbers) {
        for (int n : numbers) System.out.println(n);
    }
}

fun main() {
    val logger = OutputLogger()
    val batch = intArrayOf(0, 1, 2, 3)
    logger.logEntries(*batch)
}

Mixed Parameters Example

// MixedService.java
public class MixedService {
    public void processBatch(String prefix, int... ids) {
        System.out.println("Prefix: " + prefix);
        for (int id : ids) System.out.println(id);
    }
}

fun main() {
    val service = MixedService()
    val ids = intArrayOf(0, 1, 2, 3)
    service.processBatch("hello", *ids)
}

Output:

Prefix: hello
0
1
2
3

Type System Mapping

The Kotlin compiler automatically bridges type discrepancies between the two languages. These translasions occur exclusively at compile time; the runtime bytecode remains identical to standard JVM execution.

Java Primitive	Kotlin Equivalent
byte	kotlin.Byte
short	kotlin.Short
int	kotlin.Int
long	kotlin.Long
char	kotlin.Char
double	kotlin.Double
boolean	kotlin.Boolean

Java Reference Type	Nullable Kotlin Type
java.lang.Object	kotlin.Any!
java.lang.String	kotlin.String!
java.lang.Number	kotlin.Number!
java.lang.Throwable	kotlin.Throwable!
java.util.Iterator<T>	Iterator<T> / MutableIterator<T>
java.util.List<T>	List<T> / MutableList<T>
java.util.Map<K,V>	Map<K,V> / MutableMap<K,V>

Boxed primitives map directly to nullable Kotlin counterparts (e.g., java.lang.Integer becomes kotlin.Int?). Unchecked ! types indicate that the compiler cannot guarantee null-safety at compile time and relies on runtime checks or developer assurance.