「Java から Kotlin に移行すべきか？」「Kotlin って結局何が違うの？」—— 多くの開発者が抱く疑問です。特に Android 開発では、2017 年に Google が Kotlin を公式言語として採用して以来、新規プロジェクトの多くが Kotlin で書かれるようになりました...
しかし、Kotlin は Java の置き換えではなく、Java と共存しながら進化した言語です。既存の Java ライブラリをそのまま使えるため、段階的な移行が可能で、リスクを最小限に抑えながら生産性を向上させることができます。
本記事では、Java と Kotlin の関係性から文法面での違いを深掘りします！
Kotlin Fest 2025 行きたかったです...
Java と Kotlin の関係性
Java と Kotlin は、一見すると競合する言語に見えますが、実は補完的な関係にあります。まずは両者の関係性を理解することで、なぜ Kotlin が生まれたのか、なぜ Java と共存できるのかが明確になるのではないでしょうか？
共通基盤としての JVM
Javaとkotlinの最大の共通点は、JVM（Java Virtual Machine）上で動作することです。Java も Kotlin も最終的には同じバイトコードにコンパイルされ、同じランタイム環境で実行されます。つまり、実行時のパフォーマンスには大きな差がありません。Kotlin/Native や Kotlin/JS といったマルチプラットフォーム対応もありますが、本記事では主に JVM を前提として説明します。
100% の相互運用性
Kotlin は「Java の代替」ではなく「Java の進化形」として設計されています。その証拠に、Kotlin から Java のライブラリを呼び出すのは、Kotlin のライブラリを呼び出すのと全く同じようにできます。逆に、Java から Kotlin のコードを呼び出すことも可能です。これは、既存の Java プロジェクトに Kotlin を段階的に導入できることを意味します。
例えば、Spring Framework や Android SDK などの既存の Java ライブラリを、Kotlin のコードからそのまま使えます。移行を急ぐ必要はなく、「新しい機能は Kotlin で書く」「ユーティリティクラスから Kotlin に移行する」といった段階的なアプローチが可能です。
Android 開発における公式採用
2017 年、Google は Android 開発における Kotlin の公式サポートを発表しました。それ以降、Jetpack ライブラリや Jetpack Compose（モダンな UI フレームワーク）など、Kotlin を前提とした API が次々と登場しています。現在、新規の Android プロジェクトでは Kotlin が事実上の標準となっており、Google の公式サンプルコードも Kotlin で書かれています。
表現力と安全性の向上
Kotlin は、Java の「より良い部分」を抽出し、言語仕様として組み込んでいます。null 安全、型推論、拡張関数、コルーチンなど、Java ではライブラリやボイラープレートコードで実現していた機能が、言語レベルでサポートされています。これにより、コード量を削減し、バグを減らし、可読性を向上させることができます。
特に、NullPointerExceptionは Java 開発者にとって最も厄介なバグの一つですが、Kotlin の型システムにより、コンパイル時に null の危険性を検出できます。これだけで、多くの実行時エラーを防ぐことができます。
基本文法の比較（できるだけ網羅）
ここからは、実際のコードを見ながら Java と Kotlin の違いを詳しく解説していきます。最初は Hello World から始まり、変数宣言、null 安全、関数定義、クラス、コレクション、非同期処理まで、できるだけ多くの文法を網羅的に比較します。
それぞれの例では、なぜ Kotlin が簡潔になるのか、どのような場面で役立つのかを説明しながら進めます。Java 経験者であれば、コードを見るだけで違いが理解できるはずです。
Hello World
最小実行例の比較です。Kotlin はトップレベル関数 main をそのまま定義でき、クラス定義が不要です。これはスクリプトや小さなユーティリティの作成を容易にします。一方 Java はエントリポイントとして public static void main(String[] args) を持つクラスを定義する必要があります。
// Java
public class Main {
public static void main(String[] args) {
System.out.println("Hello, World");
}
}
// Kotlin
fun main() {
println("Hello, World")
}
変数宣言（不変/可変・型推論）
Kotlin は再代入不可の val と再代入可能な var を明確に区別します。イミュータビリティをデフォルトにすることで設計を安全にし、副作用を減らします。さらに強力な型推論により右辺から型を決定します。Java では final で不変意図を示しますが、参照の不変とオブジェクト内部の不変は別物である点は Kotlin でも同様です。
// Java
int i = 1; // 基本型
Integer n = null; // 参照型
final String name = "A"; // 不変にしたい場合は final
String city = "Tokyo"; // 可変
// Kotlin
val name: String = "A" // 不変（再代入不可）
var city = "Tokyo" // 可変（型推論で String）
val i = 1 // Int に推論
val n: Int? = null // nullable 型は ? が必須
Null 安全（nullable / エルビス / セーフコール / 非 null 断言）
Kotlin は型に null 許容性を持ち込み（String?）、コンパイル時に null 取り扱いを強制します。?.（セーフコール）は null の場合に式全体を null に短絡し、?:（エルビス）はデフォルト値を与えます。!! は「ここは絶対 null ではない」という開発者の主張ですが、失敗時は KotlinNullPointerException を投げるため最小限の使用に留めます。Java では言語機能としての null 安全がないため、手動チェックやアノテーションに依存します。
// Java（null 安全は言語機能にないため、手動でチェック）
String s = mayReturnNull();
int len = (s != null) ? s.length() : 0;
// Kotlin
val s: String? = mayReturnNull()
val len1 = s?.length // セーフコール（null なら null）
val len2 = s?.length ?: 0 // エルビス演算子（null なら 0）
val len3 = s!!.length // 非 null 断言（null の場合は例外）
関数定義・デフォルト引数・名前付き引数
Kotlin はデフォルト引数と名前付き引数でオーバーロードの爆発を抑えます。小さなユーティリティでは式ボディ（=）で簡潔に書けます。Java はデフォルト引数がないため、代わりにメソッドオーバーロードを用意するのが一般的です。
// Java（デフォルト引数なし。メソッドオーバーロードで代替）
class MathUtil {
public static int add(int a, int b) { return a + b; }
public static int add(int a) { return add(a, 0); }
}
// Kotlin（デフォルト・名前付きが標準）
fun add(a: Int, b: Int = 0) = a + b
val x = add(10)
val y = add(b = 2, a = 3) // 名前付き引数
クラス・プロパティ・データクラス
Kotlin のプロパティはフィールド + アクセサ（get/set）のシンタックスシュガーです。data class は equals/hashCode/toString/copy/componentN を自動生成し、DTO・値オブジェクト表現が簡潔になります。Java で同等の機能を得るには多くのボイラープレートや Lombok 等のツールが必要です。
// Java
public class User {
private final String id;
private String name;
public User(String id, String name) {
this.id = id;
this.name = name;
}
public String getId() { return id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}
// Kotlin（主コンストラクタ + プロパティ、データクラスで equals/hashCode/toString）
data class User(
val id: String,
var name: String
)
データクラスで自動生成されるメソッド
data class を宣言すると、コンパイラが以下のメソッドを自動生成します。
これらは主コンストラクタで宣言されたすべてのプロパティに基づいて生成されます。
-
equals()/hashCode(): プロパティの値に基づく等価性とハッシュコードを生成します。Java では手動で実装する必要があり、IDE の生成機能を使っても数十行のコードが必要ですが、Kotlin では一行で完了します。 -
toString():User(id=123, name=John)のような形式で文字列表現を生成します。デバッグ時に非常に便利です。 -
copy(): 既存のインスタンスをコピーし、指定したプロパティだけを変更した新しいインスタンスを作成します。イミュータブルなデータ構造を扱う際に強力です。 -
componentN(): 分解宣言（destructuring declaration）で使用されます。val (id, name) = userのように、オブジェクトを個々の変数に分解できます。
以下に使用例を示します：
val user1 = User("001", "Alice")
val user2 = User("001", "Alice")
val user3 = User("002", "Bob")
// equals() - プロパティの値が同じなら true
println(user1 == user2) // true
println(user1 == user3) // false
// hashCode() - equals() が true なら同じハッシュコード
println(user1.hashCode() == user2.hashCode()) // true
// toString() - 読みやすい文字列表現
println(user1) // User(id=001, name=Alice)
// copy() - 一部のプロパティだけを変更した新しいインスタンスを作成
val user4 = user1.copy(name = "Alice Updated")
println(user4) // User(id=001, name=Alice Updated)
// componentN() - 分解宣言
val (id, name) = user1
println("ID: $id, Name: $name") // ID: 001, Name: Alice
可視性修飾子・トップレベル関数/プロパティ
Kotlin はトップレベルに関数やプロパティを定義でき、ユーティリティをオブジェクト指向の枠に無理に押し込む必要がありません。internal はモジュール内公開であり、Java の package-private に近いがモジュール単位で制御されます。
// Java（すべてクラス内。可視性: public/protected/(package private)/private）
public class Util {
public static String greet = "hi";
public static void hello() {}
}
// Kotlin（ファイル直下に定義可能。可視性: public/internal/protected/private）
val greet = "hi"
fun hello() {}
static の代替（companion object）
Kotlin には static 修飾子がなく、クラスに紐づくメンバーは companion object 内に定義します。Java から静的メソッドとして見せたいときは @JvmStatic を付けます。トップレベル関数を使う設計も有効です。
class Logger {
companion object {
@JvmStatic fun d(msg: String) = println(msg)
}
}
継承とオーバーライド（open/override/final）
Kotlin のクラスとメソッドはデフォルトで final（継承不可）です。明示的に拡張可能にしたいときに open を付け、オーバーライド時は override を必須にして意図を明確化します。これは設計の偶発的な継承や破壊的変更を防ぎます。
open class Animal { open fun speak() {} }
class Dog : Animal() { override fun speak() { println("woof") } }
インターフェース（プロパティ/デフォルト実装）
Kotlin のインターフェースはプロパティを宣言でき、ゲッターにデフォルト実装を与えられます。メソッドのデフォルト実装も可能で、多重継承時の衝突は明示的に解決します。Java 8+ でも default メソッドがありますが、プロパティ表現は Kotlin の方が自然です。
// Java 8+ で default メソッド可
interface Printer { default void print(String s) { System.out.println(s); } }
interface Printer {
val prefix: String get() = ""
fun print(s: String) { println(prefix + s) }
}
ラムダ・関数型・SAM 変換
両言語ともラムダを持ちますが、Kotlin は関数型が第一級で、拡張関数・高階関数・inline によるオーバーヘッド削減などが標準です。Java の関数型インターフェース（SAM）には Kotlin のラムダをそのまま渡せます。コレクション操作では Kotlin の拡張関数 API が簡潔です。
// Java
List<Integer> xs = Arrays.asList(1, 2, 3);
xs.stream().map(x -> x * 2).forEach(System.out::println);
// Kotlin（コレクションは拡張関数が豊富）
listOf(1, 2, 3).map { it * 2 }.forEach(::println)
コレクション（不変/可変）
Kotlin の List は「読み取り専用ビュー」を表し、ミュータブルコレクションは MutableList と明示します。実装が不変である保証ではない点に注意（listOf の戻り値は通常変更不可の実装）。API 設計時に意図を型で表現できます。
val imm = listOf(1, 2, 3) // 読み取り専用
val mut = mutableListOf(1, 2, 3) // 変更可能
拡張関数・拡張プロパティ
既存型にメソッドを追加するための仕組みです。静的ディスパッチであり、本当のメソッド追加ではありませんが、呼び出し側はメソッドと同様に書け、DSL 風の API 設計に有効です。名前衝突や可読性に注意して適用範囲を限定しましょう。
fun String.title(): String = replaceFirstChar { it.uppercase() }
val size: Int get() = 42
スマートキャスト（is で型チェック→自動キャスト）
is で型チェック後に同スコープ内で自動的にキャストされた型として扱えます。可変参照や並行更新がある場合はスマートキャストが無効になるため、val を好む設計と相性が良いです。
fun len(x: Any): Int = if (x is String) x.length else 0
when 式（switch の強化版）
when は式として値を返せ、条件は値だけでなく型・条件式・範囲にも対応します。sealed 階層と併用すると網羅性チェックが働き、分岐漏れをコンパイル時に防げます。Java の switch は近年強化されていますが、総合的な表現力は Kotlin の方が高いです。
// Java（switch は値返却のために工夫が要る）
int code = 200;
String m;
switch (code) {
case 200: m = "OK"; break;
case 404: m = "NotFound"; break;
default: m = "Other";
}
val code = 200
val m = when (code) {
200 -> "OK"
404 -> "NotFound"
else -> "Other"
}
文字列テンプレート
$name や ${expr} で埋め込み可能です。可読性が高く、StringBuilder や String.format のボイラープレートを減らします。複雑な組み立ては buildString {} などの DSL も有効です。
val name = "World"
println("Hello, $name")
println("Length: ${name.length}")
try/catch/finally と式
Kotlin では try も式であり、結果を変数に直接束縛できます。例外設計は Kotlin でも重要で、ドメインエラーは sealed 階層 + Result 型や Either（Arrow など）で表現する選択肢もあります。
val result: Int = try {
risky()
} catch (e: Exception) {
-1
} finally {
// 後処理
}
例外（checked/unchecked の違い）
- Java: checked 例外あり（呼び出し側に宣言/捕捉を強制）。
- Kotlin: すべて unchecked（宣言強制なし）。Java API を呼ぶときは注意（
@Throwsを使うと Java 呼び出し側にシグネチャ付与可能）。
checked 例外は API 仕様の明確化に役立つ一方で、伝播のボイラープレートや形骸化（catch して包み直すだけ）が起きがちです。Kotlin は宣言強制を廃し、必要に応じて戻り値によるエラー表現（Result<T>）やコルーチン内での例外処理パターンの利用を推奨する文化があります。
@Throws(IOException::class)
fun read() { /* ... */ }
等価演算子（== と ===）
Kotlin の == は equals を呼ぶ値の等価、=== は参照等価を表します。Java は逆に == が参照等価、equals が値等価です。コレクションやデータクラスの比較意図を明確にできます。
val a = "x"; val b = String(charArrayOf('x'))
println(a == b) // 値の等価（Java の equals）
println(a === b) // 参照等価（Java の ==）
ループ・レンジ
数値レンジとステップが言語機能で提供され、範囲外/境界の明示が読みやすくなります。イテレーションは for (x in xs) の形式で、インデックスが必要な場合は forEachIndexed など高階関数が便利です。
for (i in 0..3) { print(i) } // 0,1,2,3
for (i in 0 until 3) { print(i) } // 0,1,2
for (i in 3 downTo 1 step 2) { print(i) } // 3,1
パッケージ・インポート
Java と同様のパッケージ構造ですが、Kotlin では同ファイル内に複数のトップレベル宣言を置くのが一般的です。静的インポートは import foo.bar.baz as alias のように別名インポートも可能で、名前衝突の回避に役立ちます。
package com.example
import java.time.LocalDate
enum / sealed class（閉じた階層）
sealed は継承範囲を同一ファイル（またはパッケージ/モジュール、言語バージョン依存）に閉じ、分岐の網羅性チェックを可能にします。状態遷移・結果型・エラーモデルの表現に有効で、when と組み合わせて安全な分岐を書けます。
enum class Direction { NORTH, SOUTH, EAST, WEST }
sealed interface Result
data class Ok(val value: String): Result
data class Err(val cause: Throwable): Result
fun handle(r: Result) = when(r) { // 全列挙で網羅性チェック
is Ok -> println(r.value)
is Err -> println(r.cause.message)
}
ジェネリクス（variance: out/in）
共変（out）と反変（in）を宣言サイトで指定でき、API 設計時に型安全と再利用性の両立を図れます。Java のワイルドカード（? extends/? super）に相当しますが、宣言側に方針を押し込めるため利用側が簡潔になります。
// Producer は out（Java の ? extends）、Consumer は in（? super）
interface Source<out T> { fun get(): T }
interface Sink<in T> { fun put(x: T) }
アノテーション相互運用（@Jvm*）
Kotlin の宣言を Java から自然に使えるようにするためのブリッジです。@JvmName は生成クラス/関数名、@JvmStatic は静的化、@JvmOverloads はデフォルト引数から Java 向けにオーバーロードを自動生成、@JvmField はフィールド公開、@Throws は例外宣言を付与します。
@file:JvmName("Util")
@file:JvmMultifileClass
object IdGen {
@JvmStatic fun next(): String = "id"
}
class Api {
@JvmOverloads fun get(name: String, retry: Int = 0) {}
@JvmField val version = "1.0" // フィールドとして公開
}
コルーチン Coroutine（Java のスレッド/CompletableFuture との対比）
コルーチンは、Kotlin における非同期プログラミングの核心機能です。軽量スレッドのように見えますが、実際にはスレッドプール上で実行される協調的な並行処理の仕組みです。Java の Thread や CompletableFuture、RxJava などの代替として、より直感的で安全な非同期処理を実現します。
コルーチン(Coroutine)とは何か
コルーチンは、実行を中断（suspend）し、後で再開（resume）できる関数です。これにより、非同期処理を同期処理のように直線的に書けるようになります。Java のスレッドと異なり、スレッドをブロックせずに実行を中断できるため、数千から数万のコルーチンを同時に実行できます。
Java との比較
Java の従来のアプローチ:
// Java - CompletableFuture を使った非同期処理
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// バックグラウンド処理
return fetchData();
}).thenApply(data -> {
// 結果の変換
return processData(data);
}).exceptionally(throwable -> {
// エラーハンドリング
return "Error: " + throwable.getMessage();
});
future.thenAccept(result -> {
// 結果の処理
System.out.println(result);
});
Kotlin のコルーチン(Coroutine):
// Kotlin - コルーチンを使った非同期処理
suspend fun fetchData(): String {
return withContext(Dispatchers.IO) {
// バックグラウンド処理（IO スレッドプールで実行）
delay(1000) // 非ブロッキングな待機
"data"
}
}
suspend fun processData(): String = coroutineScope {
try {
val data = fetchData() // 同期処理のように見えるが、実際は非同期
"Processed: $data"
} catch (e: Exception) {
"Error: ${e.message}"
}
}
// コルーチンの起動
fun main() = runBlocking {
val result = processData()
println(result)
}
主要な概念
-
suspend関数: 中断可能な関数。コルーチン内でのみ呼び出せます。suspendキーワードにより、コンパイラがコルーチン用のコードを生成します。 -
Dispatchers: コルーチンが実行されるスレッドプールを指定します。-
Dispatchers.Main: UI スレッド（Android のメインスレッドなど） -
Dispatchers.IO: ファイル I/O やネットワーク処理用 -
Dispatchers.Default: CPU 集約的な処理用 -
Dispatchers.Unconfined: 特定のスレッドに制約されない
-
-
coroutineScope: コルーチンのスコープを定義し、子コルーチンの完了を待ちます。スコープがキャンセルされると、すべての子コルーチンもキャンセルされます。 -
withContext: 別のDispatcherに切り替えて処理を実行し、完了後に元のコンテキストに戻ります。
実際の使用例
import kotlinx.coroutines.*
// suspend 関数の定義
suspend fun fetchUserData(userId: String): User {
return withContext(Dispatchers.IO) {
// ネットワークリクエスト（実際には Retrofit などを使う）
delay(1000) // シミュレーション
User(id = userId, name = "Alice")
}
}
suspend fun fetchUserPosts(userId: String): List<Post> {
return withContext(Dispatchers.IO) {
delay(800)
listOf(Post("Post 1"), Post("Post 2"))
}
}
// 並列実行
suspend fun loadUserProfile(userId: String): UserProfile {
return coroutineScope {
// async で並列実行
val userDeferred = async { fetchUserData(userId) }
val postsDeferred = async { fetchUserPosts(userId) }
// await で結果を待つ
val user = userDeferred.await()
val posts = postsDeferred.await()
UserProfile(user, posts)
}
}
// コルーチンの起動
fun main() = runBlocking {
val profile = loadUserProfile("123")
println(profile)
}
Flow（リアクティブストリーム）
Flow は、コルーチン版のリアクティブストリームです。RxJava の Observable に相当しますが、Kotlin のコルーチンと完全に統合されています。
import kotlinx.coroutines.flow.*
fun numbersFlow(): Flow<Int> = flow {
for (i in 1..5) {
delay(100)
emit(i) // 値を発行
}
}
fun main() = runBlocking {
numbersFlow()
.filter { it % 2 == 0 }
.map { it * it }
.collect { value -> // 値を消費
println(value)
}
// 出力: 4, 16 (2*2, 4*4)
}
Java の CompletableFuture との主な違い
| 特徴 | Java CompletableFuture | Kotlin コルーチン |
|---|---|---|
| コードの読みやすさ | チェーンが長くなりがち | 同期処理のように直線的 |
| 例外処理 |
exceptionally() で個別に処理 |
try-catch で自然に処理 |
| キャンセル | 手動で実装が必要 | 標準でサポート |
| スレッド効率 | スレッドをブロックする可能性 | スレッドをブロックしない |
| 学習曲線 | やや複雑 | より直感的 |
Android での使用例
// Android Activity での使用例
class MainActivity : AppCompatActivity() {
private val viewModel: MainViewModel by viewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// LifecycleScope でコルーチンを起動
lifecycleScope.launch {
viewModel.userData.collect { user ->
// UI の更新（Main スレッドで実行される）
updateUI(user)
}
}
}
}
// ViewModel での使用例
class MainViewModel : ViewModel() {
private val _userData = MutableStateFlow<User?>(null)
val userData: StateFlow<User?> = _userData.asStateFlow()
fun loadUser() {
viewModelScope.launch {
try {
val user = repository.fetchUser() // suspend 関数
_userData.value = user
} catch (e: Exception) {
// エラーハンドリング
}
}
}
}
コルーチンは、Java の CompletableFuture よりも直線的で例外伝播が自然、キャンセル伝播も標準で備えています。特に Android 開発では、lifecycleScope や viewModelScope により、ライフサイクルに応じた自動キャンセルが可能で、メモリリークを防ぐことができます。
実行・ビルド方法
文法の違いを理解したところで、次は実際にコードを実行する方法を見ていきましょう。Java と Kotlin は、コマンドライン、Gradle、Maven など、多様な手段でビルド・実行できます。
小規模な学習や実験ではコマンドラインから直接コンパイル・実行する方法が簡単ですが、プロダクションや Android 開発では、依存関係管理やビルド自動化のために Gradle や Maven を使うのが一般的です。特に Android 開発では Gradle がデファクトスタンダードとなっています。
ここでは、最小限の環境で試す方法から、実際のプロジェクトで使う方法まで、段階的に説明します。なお、Kotlin のトップレベル main 関数は、デフォルトで MainKt というクラス名に変換される点に注意が必要です。
Java 単体（JDK 必須）
JDK（javac/java）があれば最小実行可能です。依存がある場合はクラスパス指定が必要になります。
javac Main.java
java Main
Kotlin 単体（Kotlin Compiler 必須）
kotlinc は単一ファイルの実行用に -include-runtime -d app.jar で実行 jar を作成できます。kotlin コマンドは REPL と .kts スクリプト実行も提供します。
# .kt → .class へコンパイル
kotlinc main.kt -include-runtime -d app.jar
java -jar app.jar
# もしくは REPL / スクリプト
kotlin
kotlin main.kts
Gradle（推奨）
Kotlin DSL（build.gradle.kts）/ Groovy DSL のどちらでも構いません。アプリケーションプラグインを使えば run タスクでエントリポイントを直接実行できます。マルチモジュールでは internal 可視性が活きます。
// build.gradle.kts（Kotlin DSL）
plugins {
kotlin("jvm") version "1.9.24"
application
}
repositories { mavenCentral() }
dependencies {
implementation(kotlin("stdlib"))
}
application { mainClass.set("MainKt") } // Kotlin のトップレベル main は MainKt
./gradlew run
相互運用（Java ⇄ Kotlin）要点
Kotlin の最大の強みの一つは、Java との完全な相互運用性です。しかし、両言語には設計思想の違いがあるため、相互に呼び出す際にはいくつかの注意点があります。ここでは、混在プロジェクトで実際に遭遇するポイントを整理します。
基本的な相互呼び出し
Kotlin から Java を呼ぶのは非常に簡単です。Java のライブラリをそのままインポートして使えます。逆に、Java から Kotlin を呼ぶ場合も基本的には問題ありませんが、Kotlin の言語機能（デフォルト引数、トップレベル関数など）を Java から自然に使えるようにするには、いくつかのアノテーションが必要になることがあります。
重要なポイント
-
呼び出し: Kotlin から Java をそのまま呼べる。Java から Kotlin を呼ぶ場合、
@JvmName/@JvmStatic/@JvmOverloads/@JvmField/@Throwsで Java フレンドリーに。 -
プロパティ: Kotlin のプロパティは Java から
getXxx()/setXxx()として見える。 -
null アノテーション: Java API の
@Nullable/@NotNullがあると Kotlin で null 許容性が推論される。 - SAM: Kotlin から Java の関数型インターフェースへラムダを渡せる。
混在プロジェクトでの注意点
混在プロジェクトでは、共通のビルドツール（Gradle/Maven）で同一モジュールに Java と Kotlin のファイルを配置できます。ビルドシステムが自動的に両方を認識し、適切にコンパイルします。
ただし、相互運用時の落とし穴として以下があります：
- null 許容性（プラットフォーム型）: Java から来た型は、Kotlin では null 許容性が不明確な「プラットフォーム型」として扱われます。明示的に null チェックを行うか、アノテーションを活用しましょう。
-
デフォルト引数: Kotlin のデフォルト引数は、Java からは見えません。
@JvmOverloadsアノテーションを使うと、Java 向けにオーバーロードメソッドが自動生成されます。
バイトコードレベルでは同等なため、パフォーマンス特性は概ね同じです。相互運用によるオーバーヘッドはほとんどありません。
Android 開発での違い（実務観点）
Android 開発において、Kotlin の優位性は特に顕著です。Google が公式に Kotlin を採用して以降、新しい API やフレームワークは Kotlin を前提として設計されています。ここでは、実際の Android 開発で遭遇する具体的な違いと、実務でのベストプラクティスを解説します。
なぜ Android で Kotlin が選ばれるのか
Android 開発では、UI スレッドでのブロッキングを避け、バックグラウンドで処理を行う非同期プログラミングが不可欠です。また、Activity や Fragment のライフサイクル、View の状態管理、データバインディングなど、複雑な状態管理が必要になります。
Java では、これらの問題を解決するために AsyncTask、Handler、Executor、RxJava など、様々なライブラリやパターンが使われてきました。しかし、Kotlin のコルーチンや null 安全、拡張関数などにより、より簡潔で安全なコードが書けるようになっています。
主要な違い
以下に、Android 開発における主要な違いをまとめます：
- 公式スタック: 新規プロジェクトでは Kotlin が事実上の標準。Jetpack/Compose/KTX は Kotlin 最適化。
-
非同期処理: Kotlin のコルーチン（
suspend,Flow）が主流。Java のAsyncTaskは廃止、Executor/CompletableFuture/RxJavaなどから移行しやすい。 - UI 開発: Jetpack Compose は Kotlin DSL。Java から使うより Kotlin で書くのが自然。
-
KTX 拡張:
androidx.core:core-ktxなどで拡張関数が多数（bundleOf,viewModels(),doOnLayout）。 -
データモデル:
data class+@ParcelizeでParcelable実装が一行に。Java ではボイラープレートが多い。 -
依存性注入: Hilt/Dagger は Kotlin での体験が良い。注釈処理は
kapt、高速化や将来性はkspが主流。 -
データベース/バックグラウンド処理: Room/WorkManager は
suspend/Flowを自然に扱える API が用意される（Kotlin 推奨サンプルが豊富）。 - Null 安全: View 参照や Intent Extra 等で Kotlin の型システムがクラッシュを抑制。
- テスト: コルーチン Test, Turbine, MockK など Kotlin 対応ツールが豊富。
-
パフォーマンス: どちらも最終的には JVM バイトコード。Kotlin 多用時は
inline,noinline,crossinline、@JvmInline value classなどでオーバーヘッド抑制が可能。
実務での移行戦略
既存の View/XML + Java プロジェクトでも、段階的な導入が可能です。以下のような順序で移行を進めることで、リスクを最小限に抑えられます：
- ユーティリティクラスから: まずは、ビジネスロジックが少ないユーティリティクラスを Kotlin に移行します。
-
KTX 拡張関数の活用:
androidx.core:core-ktxなどの KTX ライブラリを導入し、既存の Java コードからも使える拡張関数を活用します。 -
コルーチンの導入: 新しい非同期処理はコルーチンで書き、既存の
AsyncTaskやHandlerは段階的に置き換えます。 - 新機能は Kotlin で: 新しく追加する機能は最初から Kotlin で書くことで、徐々に Kotlin のコードベースを増やします。
ビルド時間の観点から、注釈処理は kapt より ksp（Kotlin Symbol Processing）を優先すると、ビルド時間の短縮につながります。
特に効果が大きい領域
実務では、以下の 4 領域で Kotlin の優位性が特に顕著です：
- UI 開発（Jetpack Compose）: 宣言的 UI フレームワークである Compose は、Kotlin DSL で書かれており、Kotlin で書くのが自然です。
- 非同期処理（コルーチン）: コールバック地獄を避け、直線的なコードで非同期処理を書けます。
- 依存性注入（Hilt/Dagger）: Kotlin の言語機能を活用することで、より簡潔なコードになります。
-
データ永続化（Room）:
suspend関数とFlowにより、リアクティブなデータベースアクセスが可能になります。
Android 用 Gradle（Kotlin）例
// build.gradle.kts（Module: app）
plugins {
id("com.android.application") version "8.6.0"
kotlin("android") version "1.9.24"
kotlin("kapt")
}
android {
namespace = "com.example.app"
compileSdk = 35
defaultConfig {
applicationId = "com.example.app"
minSdk = 24
targetSdk = 35
versionCode = 1
versionName = "1.0"
}
}
dependencies {
implementation("androidx.core:core-ktx:1.13.1")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
}
Java と Kotlin の関係性から始まり、文法の違い、実行方法、相互運用、そして Android 開発での実務的な違いまで、幅広く解説してみました！
- Java は堅牢で普及: 長年の実績と豊富なエコシステムを持つ、信頼性の高い言語です。
- Kotlin はより簡潔・安全・表現力豊か: null 安全、型推論、拡張関数、コルーチンなど、言語レベルで多くの機能がサポートされています。
- 段階的移行が可能: 相互運用性により、既存の Java コードと共存しながら、徐々に Kotlin へ移行できます。特に Android 開発では Kotlin が優位です。
言語差分（null 安全、デフォルト/名前付き引数、拡張関数、when、データクラス、コルーチンなど）を押さえることで、Kotlin の真の力を発揮できるようになります。
特に Android 開発者であれば、Kotlin の習得は必須と言えるでしょう。Google の公式サンプルや最新の Jetpack ライブラリは Kotlin で書かれており、Kotlin を理解することで、より良いコードを書けるようになります。