Java入門！初心者でもわかる基本構文と便利機能

Javaは、一度書けばどこでも動く「Write once, run anywhere」の理念を掲げる、非常に人気の高いプログラミング言語です。WebアプリケーションからAndroidアプリ、大規模な業務システムに至るまで、その活用範囲は多岐にわたります。初心者の方でもJavaの基本をしっかりと学ぶことで、プログラミングの世界への第一歩を踏み出すことができるでしょう。

この記事では、Javaの核となる基本構文と、コードをより効率的に記述するための便利機能について、分かりやすく解説していきます。最新のJavaバージョンであるJava 21 (LTS) や、次期LTSであるJava 25 (2025年9月リリース予定) の動向も踏まえつつ、モダンなJavaプログラミングの基礎を身につけていきましょう。

Javaの基本：クラス、オブジェクト、そして`new`の役割

Javaはオブジェクト指向プログラミング言語であり、クラスとオブジェクトがその根幹を成します。これらを理解することが、Javaプログラミングを始める上での最初の大きな一歩となります。

クラスとは？：設計図としてのクラス

Javaにおけるクラスとは、ひと言で言えば「オブジェクトの設計図」や「テンプレート」のようなものです。例えば、「車」という概念をプログラムで表現したいとします。車には「色」「速度」といったプロパティ（属性）や、「走る」「止まる」といった振る舞い（操作）がありますよね。クラスは、これらのプロパティや振る舞いをまとめて定義したものです。

クラスを定義することで、そのクラスに基づいて具体的な「もの」（オブジェクト）を作り出すことができます。Javaでは、すべてのコードがクラスの内部に記述されるため、クラスの理解はJavaプログラミングの絶対的な基礎となります。プログラムの構造を整理し、再利用性を高める上で非常に重要な概念です。

“`java
// 車クラスの設計図
class Car {
String color; // 色というプロパティ
int speed; // 速度というプロパティ

// 走るという振る舞いを定義するメソッド
void run() {
System.out.println(color + “の車が時速” + speed + “kmで走っています。”);
}
}
“`

オブジェクトとは？：クラスから生まれた実体

オブジェクトとは、クラスという設計図に基づいて実際に作られた「具体的なもの」や「実体」のことです。先ほどの車の例で言えば、「Car」クラスが車の設計図であるのに対し、「私の赤い車」や「彼の青いスポーツカー」といった具体的な車がオブジェクトに当たります。

各オブジェクトは、それぞれが独自のプロパティ（例: 色が赤、速度が100km/h）を持ち、設計図であるクラスで定義された振る舞い（メソッド）を実行することができます。複数のオブジェクトを生成しても、それぞれが独立した状態を持つため、プログラム内で多くの「もの」を効率的に管理できるようになります。オブジェクト指向プログラミングの魅力は、この具体的な「もの」として捉えることで、現実世界の問題をプログラムで表現しやすくなる点にあります。

“`java
// Carクラスからオブジェクトを生成し、操作する例
public class Main {
public static void main(String[] args) {
// オブジェクトの生成は次の「new」で詳しく説明します
Car myCar = new Car(); // 私の車のオブジェクト
myCar.color = “赤”;
myCar.speed = 60;
myCar.run(); // 「赤の車が時速60kmで走っています。」と表示

Car yourCar = new Car(); // あなたの車のオブジェクト
yourCar.color = “青”;
yourCar.speed = 80;
yourCar.run(); // 「青の車が時速80kmで走っています。」と表示
}
}
“`

`new`演算子の魔法：オブジェクト生成のプロセス

Javaにおいて、クラスの設計図から具体的なオブジェクトを生成する際に使用するのが`new`演算子です。`new`演算子は、メモリ上に新しいオブジェクトのための領域を確保し、そのオブジェクトを初期化する役割を担います。このプロセスを「インスタンス化」と呼び、生成されたオブジェクトのことを「インスタンス」と呼びます。

例えば、`Car myCar = new Car();` という記述は、「Carクラスの設計図を元に、新しいCarのオブジェクトをメモリ上に作り、そのオブジェクトを`myCar`という名前の変数に割り当てる」という意味になります。`new`演算子がなければ、クラスを定義しても具体的なオブジェクトを作ることができません。Javaプログラミングにおいて、`new`はオブジェクト指向の力を最大限に引き出すための、非常に重要なキーワードです。

新しいオブジェクトが必要になるたびに`new`を使用することで、柔軟にプログラムの構成を組み立てることができます。

“`java
// new演算子を使ったオブジェクト生成の例
public class SimpleFactory {
public static void main(String[] args) {
// Carクラスの新しいインスタンスを生成
Car sedan = new Car();
sedan.color = “黒”;
sedan.speed = 100;
sedan.run(); // 黒の車が時速100kmで走っています。

// 別のCarクラスのインスタンスを生成
Car truck = new Car();
truck.color = “緑”;
truck.speed = 50;
truck.run(); // 緑の車が時速50kmで走っています。

// これらsedanとtruckはそれぞれ独立したオブジェクトです。
}
}
“`

Javaの変数：`var`の活用と`null`判定の注意点

プログラムにおいて、データの一時的な保管場所として利用されるのが「変数」です。Javaでは、変数を宣言する際にデータ型を指定する必要がありますが、Java 10以降では`var`キーワードによる型推論も可能になり、より簡潔な記述ができるようになりました。また、変数が何も参照しない状態を示す`null`の扱いには注意が必要です。

型推論`var`でスッキリ記述

Java 10から導入された`var`キーワードは、ローカル変数の型をコンパイラが自動的に推論してくれる機能です。これにより、冗長な型宣言を省略し、コードをより簡潔に、読みやすく記述できるようになりました。特に、Genericsなど複雑な型を扱う場合にその恩恵は大きいです。

例えば、`String message = “Hello”;` と書く代わりに、`var message = “Hello”;` と書くことができます。これにより、開発者は変数名と初期値に集中でき、生産性の向上が期待できます。ただし、`var`は型が明確に推測できる場合にのみ使用でき、コードの可読性を損なわない範囲で適切に活用することが重要です。（参考情報より）

“`java
public class VarExample {
public static void main(String[] args) {
// 従来の型宣言
String conventionalMessage = “こんにちは、Java！”;
System.out.println(conventionalMessage);

// varキーワードによる型推論
var modernMessage = “こんにちは、var！”; // コンパイラがString型と推論
System.out.println(modernMessage);

var count = 100; // int型と推論
System.out.println(count);

// 複雑な型でも簡潔に
var names = new java.util.ArrayList();
names.add(“Alice”);
names.add(“Bob”);
System.out.println(names);
}
}
“`

変数の基本とデータ型

Javaの変数は、数値や文字列などのデータを記憶するための「箱」です。Javaは「静的型付け言語」であり、変数を宣言する際に必ずその変数がどのような種類のデータを格納するのか（つまりデータ型）を指定する必要があります。これにより、プログラムの安全性が高まり、予期せぬエラーを防ぐことができます。

主要なデータ型には、整数を扱う`int`、小数点数を扱う`double`、真偽値を扱う`boolean`、文字を扱う`char`、そして文字列を扱う`String`（これは厳密にはクラスですが、プリミティブ型のように扱われることが多いです）などがあります。これらのデータ型を適切に使い分けることで、効率的かつ正確なデータ処理が可能になります。変数はプログラムのいたるところで使われるため、その基本をしっかりと押さえることが大切です。（参考情報より）

危険な`null`との付き合い方：NullPointerExceptionを避ける

Javaの参照型変数（クラスのインスタンスを格納する変数）には、オブジェクトが割り当てられていない状態を表す特別な値、`null`が存在します。`null`は「何もない」ことを意味し、参照型変数が何も参照していない状態を示します。この`null`を扱う際には細心の注意が必要です。

なぜなら、`null`の参照に対してメソッドを呼び出したり、フィールドにアクセスしようとすると、プログラムはNullPointerException (NPE)という実行時エラーを発生させ、強制終了してしまうからです。これはJavaプログラマーが最も遭遇しやすいエラーの一つです。NPEを避けるためには、参照型変数を使用する前に、必ずその変数が`null`でないことを`if (変数 != null)`などの条件式で確認する習慣をつけることが非常に重要です。

Java 8から導入された`Optional`クラスもNPEを避けるための有効な手段として活用されています。

“`java
public class NullSafetyExample {
public static void main(String[] args) {
String message = null; // message変数は何も参照していない

// 危険なコード：NullPointerExceptionが発生する可能性
// System.out.println(message.length()); // ここでNPE!

// nullチェックを行う安全なコード
if (message != null) {
System.out.println(“メッセージの長さ: ” + message.length());
} else {
System.out.println(“メッセージはnullです。”);
}

String validMessage = “Hello Java”;
if (validMessage != null) {
System.out.println(“有効なメッセージの長さ: ” + validMessage.length());
}
}
}
“`

Javaのメソッド：`void`、`return`、そして`this`

Javaのプログラムは、処理をまとめた「メソッド」の集まりで構成されます。メソッドは、特定のタスクを実行するためのコードブロックであり、プログラムの構造化、再利用性、保守性の向上に貢献します。ここでは、メソッドの基本的な要素である`void`、`return`、そして`this`キーワードについて解説します。

メソッドとは？：処理をまとめる魔法の箱

メソッドとは、特定の処理をまとめて名付けたコードのブロックです。プログラム内で何度も同じ処理を記述する代わりに、一度メソッドとして定義しておけば、そのメソッドを呼び出すだけで処理を実行できます。これにより、コードの重複を避け、可読性を高め、変更があった場合の修正も容易になります。

例えば、計算を行うメソッド、画面にメッセージを表示するメソッドなど、様々な目的に応じてメソッドを作成します。Javaプログラムは、最初に`main`メソッドから実行が開始されるため、`main`メソッドは「プログラムのエントリーポイント」とも呼ばれます。メソッドは引数を受け取ったり、処理結果を返したりすることも可能です。

“`java
public class MethodExample {
// 引数を受け取り、足し算の結果を返すメソッド
public int add(int a, int b) {
int result = a + b;
return result; // 結果を返す
}

// 引数を受け取り、メッセージを表示するだけで値を返さないメソッド
public void greet(String name) {
System.out.println(“こんにちは、” + name + “さん！”);
}

public static void main(String[] args) {
MethodExample calc = new MethodExample();

// addメソッドを呼び出し、結果を変数に格納
int sum = calc.add(5, 3);
System.out.println(“5 + 3 = ” + sum); // 5 + 3 = 8

// greetメソッドを呼び出し
calc.greet(“太郎”); // こんにちは、太郎さん！
}
}
“`

`void`と`return`：戻り値の有無を操る

メソッドには、処理の結果として値を返すものと、値を返さないものがあります。これを指定するのが、メソッドの定義における`void`キーワードと`return`文です。

`void`は「何も返さない」という意味で、メソッドが特定の処理を実行するだけで、呼び出し元に値を返さない場合に宣言します。例えば、画面にメッセージを表示するだけのメソッドなどがこれに該当します。

一方、メソッドが処理結果を呼び出し元に返したい場合は、`void`の代わりに返したい値のデータ型（例: `int`, `String`など）を記述し、メソッドの最後に`return`文を使って値を返します。`return`文は、値を返すだけでなく、メソッドの実行を終了させる役割も持っています。

“`java
public class ReturnAndVoidExample {
// 何も返さない (void) メソッド
public void printMessage(String msg) {
System.out.println(“メッセージ: ” + msg);
// voidなのでreturn文は不要。あってもreturn;のみ。
}

// int型の値を返すメソッド
public int multiply(int num1, int num2) {
int result = num1 * num2;
return result; // 計算結果を返す
}

public static void main(String[] args) {
ReturnAndVoidExample example = new ReturnAndVoidExample();

example.printMessage(“Javaプログラミングは楽しい！”); // メッセージを表示するだけ

int product = example.multiply(4, 5); // 20が返ってくる
System.out.println(“4 * 5 = ” + product);
}
}
“`

`this`キーワードの理解：自分自身を指し示す

Javaの`this`キーワードは、オブジェクト自身（現在のインスタンス）を参照するための特別な参照です。主に、以下の2つの状況で利用されます。

1. **インスタンス変数とローカル変数の区別:** メソッド内で引数名やローカル変数名がインスタンス変数名と同じ場合、`this.インスタンス変数名`と記述することで、そのオブジェクト自身のインスタンス変数を指し示すことができます。これにより、どちらの変数を使っているのかが明確になります。
2. **コンストラクタからの他のコンストラクタの呼び出し:** コンストラクタ（オブジェクト生成時に初期化を行う特殊なメソッド）内で、`this(…)`と記述することで、同じクラス内の別のコンストラクタを呼び出すことができます。

`this`は、オブジェクト指向プログラミングにおいて、自分自身の状態や振る舞いを明確にするために不可欠なキーワードです。

“`java
class Person {
String name;
int age;

// コンストラクタ
public Person(String name, int age) {
// 引数名とインスタンス変数名が同じなので、thisでインスタンス変数を区別
this.name = name;
this.age = age;
}

// 別バージョンのコンストラクタ（this(…)で上記のコンストラクタを呼び出す）
public Person(String name) {
this(name, 0); // ageを0で初期化して、上のコンストラクタを呼び出す
}

public void displayInfo() {
System.out.println(“名前: ” + this.name + “, 年齢: ” + this.age);
}
}

public class ThisKeywordExample {
public static void main(String[] args) {
Person alice = new Person(“Alice”, 25);
alice.displayInfo(); // 名前: Alice, 年齢: 25

Person bob = new Person(“Bob”); // 年齢が0で初期化される
bob.displayInfo(); // 名前: Bob, 年齢: 0
}
}
“`

Javaの制御構文：`switch`と`while`を使いこなす

プログラムは、常に上から順に実行されるだけでなく、特定の条件に応じて処理の流れを変えたり、同じ処理を繰り返したりする必要があります。これを実現するのが「制御構文」です。ここでは、条件分岐に使う`switch`文と繰り返し処理に使う`while`文に焦点を当てて解説します。

`switch`文でスマートな条件分岐

`switch`文は、一つの式の値に基づいて、複数の処理の中から一つを選択して実行する条件分岐の構文です。特に、多くの`if-else if`文が連なるような場合に、`switch`文を使うことでコードをより簡潔に、そして読みやすくすることができます。

`switch`文は、対象の式の値と`case`に指定された値が一致すると、その`case`ブロック内の処理を実行します。各`case`ブロックの最後には、通常`break`文を記述して`switch`文を終了させます。`break`がないと、次の`case`ブロックの処理も実行されてしまう（フォールスルー）ので注意が必要です。どの`case`にも一致しない場合の処理は、`default`ブロックに記述します。

Java 12以降では、より簡潔な「`switch`式」が導入され、Java 21ではさらにパターンマッチング for switch (JEP 441) が標準機能として加わり、`switch`文の表現力が大きく向上しました。（参考情報より）

“`java
public class SwitchExample {
public static void main(String[] args) {
int dayOfWeek = 3; // 1:月, 2:火, …, 7:日
String dayName;

switch (dayOfWeek) {
case 1:
dayName = “月曜日”;
break;
case 2:
dayName = “火曜日”;
break;
case 3:
dayName = “水曜日”;
break;
case 4:
dayName = “木曜日”;
break;
case 5:
dayName = “金曜日”;
break;
case 6:
dayName = “土曜日”;
break;
case 7:
dayName = “日曜日”;
break;
default:
dayName = “不明”;
break;
}
System.out.println(“今日は” + dayName + “です。”); // 今日は水曜日です。

// Java 12以降のswitch式（より簡潔に記述可能）
String dayNameModern = switch (dayOfWeek) {
case 1 -> “月曜日”;
case 2 -> “火曜日”;
case 3 -> “水曜日”;
case 4 -> “木曜日”;
case 5 -> “金曜日”;
case 6 -> “土曜日”;
case 7 -> “日曜日”;
default -> “不明”;
};
System.out.println(“現代版: 今日は” + dayNameModern + “です。”);
}
}
“`

`while`文で繰り返し処理をマスター

`while`文は、特定の条件が真（true）である間、繰り返し処理を実行するループ構文です。ループに入る前に条件を評価し、条件が真であればブロック内の処理を実行し、再び条件を評価するという流れを繰り返します。条件が偽（false）になった時点でループは終了します。

`while`文は、繰り返し回数が事前に決まっていない場合や、何らかの条件が満たされるまで処理を続けたい場合に非常に便利です。例えば、ユーザーからの入力が有効な値になるまで繰り返す、ファイルからデータがなくなるまで読み込む、といったシナリオで活用されます。無限ループに陥らないよう、ループ内の処理で必ず条件が偽になるように変更する（カウンタを増やす、フラグを変更するなど）ことが重要です。

“`java
public class WhileExample {
public static void main(String[] args) {
int count = 0;

// countが5未満の間、処理を繰り返す
while (count < 5) {
System.out.println("現在のカウント: " + count);
count++; // countを1増やす (この行がないと無限ループになります！)
}
System.out.println("ループ終了後のカウント: " + count); // ループ終了後のカウント: 5

// do-while文の例（最低1回は実行される）
int i = 0;
do {
System.out.println("do-whileカウント: " + i);
i++;
} while (i < 3); // do-whileカウント: 0, do-whileカウント: 1, do-whileカウント: 2
}
}
“`

Javaのその他の制御構文（`for`, `if`など）

Javaには`switch`や`while`の他にも、プログラムの実行フローを制御するための様々な構文があります。最も基本的なのが、条件が真の場合にのみ処理を実行する`if`文です。`if-else`や`if-else if-else`を使うことで、複数の条件に基づいた分岐処理を記述できます。

繰り返し処理では、`while`文と並んで広く使われるのが`for`文です。`for`文は、初期化、条件式、増減式を一つにまとめて記述でき、特に繰り返し回数が明確な場合に非常に有効です。拡張for文（foreach文）もあり、配列やコレクションの要素を順に処理する際に簡潔に記述できます。

これらの制御構文に加えて、ループを途中で終了させる`break`文や、現在のイテレーションをスキップして次のイテレーションに移る`continue`文などもあります。これらを適切に組み合わせることで、複雑なロジックも柔軟かつ効率的に表現することが可能です。（参考情報より）

主要な制御構文の概要:

• if文: 条件分岐の基本。if (条件) { ... } else { ... }
• for文: 繰り返し回数が明確なループ。for (初期化; 条件; 更新) { ... }
• for-each文: 配列やコレクションの要素を順に処理。for (型 変数 : コレクション) { ... }
• break文: ループやswitch文を強制終了。
• continue文: ループの現在のイテレーションをスキップし、次のイテレーションへ。

“`java
public class OtherControlFlowExample {
public static void main(String[] args) {
int score = 75;

// if-else if-else文の例
if (score >= 90) {
System.out.println(“A評価”);
} else if (score >= 70) {
System.out.println(“B評価”); // この処理が実行される
} else {
System.out.println(“C評価”);
}

// for文の例
System.out.println(“\nforループ:”);
for (int i = 0; i < 3; i++) {
System.out.println("ループ回数: " + i);
}

// 拡張for文 (for-each) の例
System.out.println("\n拡張forループ (配列):");
String[] fruits = {"りんご", "バナナ", "みかん"};
for (String fruit : fruits) {
System.out.println(fruit);
}
}
}
“`

JavaのString操作：`length`、`printf`、`trim`、`replace`、`valueOf`をマスター

Javaにおいて、文字列（テキストデータ）は`String`クラスのオブジェクトとして扱われます。Webアプリケーションやユーザーインターフェースを持つプログラムでは、文字列の操作は日常的に行われます。ここでは、文字列の長さを取得する`length()`、整形済み出力を行う`printf()`、空白除去や置換を行う`trim()`と`replace()`、そして他のデータ型から文字列への変換を行う`valueOf()`といった、基本的ながら非常に重要な`String`操作メソッドをマスターしましょう。

`String`の基本と文字数取得：`length()`

Javaの`String`クラスは、変更不可能な（immutable）文字列を表現するためのクラスです。一度作成された`String`オブジェクトの内容は変更できません。文字列操作を行うメソッドは、実際には新しい`String`オブジェクトを生成して返します。

文字列の基本的な操作の一つに、その文字数を取得することがあります。これは`length()`メソッドを使って簡単に行えます。`length()`メソッドは、文字列に含まれる文字の総数を`int`型で返します。ただし、これはコードポイントの数ではなく、`char`単位（UTF-16コード単位）の数を返します。ほとんどの一般的な文字では1文字が1`char`ですが、絵文字など一部の文字は2`char`で構成される点には注意が必要です。

“`java
public class StringLengthExample {
public static void main(String[] args) {
String greeting = “Hello Java!”;
int length = greeting.length();
System.out.println(“文字列: \”” + greeting + “\””);
System.out.println(“文字数: ” + length); // 文字数: 11

String emptyString = “”;
System.out.println(“空文字列の文字数: ” + emptyString.length()); // 空文字列の文字数: 0

String japaneseString = “こんにちは世界”;
System.out.println(“日本語文字列の文字数: ” + japaneseString.length()); // 日本語文字列の文字数: 7
}
}
“`

整形済み出力：`printf()`で美しい表示

Java 5から導入された`printf()`メソッド（`System.out.printf()`）は、C言語の`printf`関数と同様に、書式指定子を使って整形された文字列を出力するための非常に便利な機能です。出力する数値や文字列のフォーマット（桁数、小数点以下の精度、左詰め・右詰めなど）を細かく制御できます。

書式指定子は`%`で始まり、型を表す文字（例: `%s`で文字列、`%d`で整数、`%f`で浮動小数点数）が続きます。間にフラグや幅、精度などを指定することで、より詳細なフォーマットが可能です。これにより、ログ出力やレポート生成など、きれいに整形されたテキストを表示したい場合に非常に役立ちます。

“`java
public class PrintfExample {
public static void main(String[] args) {
String name = “Alice”;
int age = 30;
double balance = 1234.567;

// 基本的な書式指定
System.out.printf(“名前: %s, 年齢: %d歳%n”, name, age); // %n は改行コード

// 浮動小数点数の桁数指定
System.out.printf(“残高: %.2f円%n”, balance); // 小数点以下2桁

// 整数値の桁揃え (右詰め)
System.out.printf(“商品コード: %05d%n”, 123); // 0埋め5桁: 00123

// 左詰め
System.out.printf(“品名: %-10s 価格: %d%n”, “ペン”, 100); // 10文字で左詰め
}
}
“`

文字列の加工：`trim()`、`replace()`

文字列は、プログラム内で様々な加工が必要になることがあります。`trim()`メソッドは、文字列の先頭と末尾にある空白文字（スペース、タブ、改行など）をすべて除去した新しい文字列を返します。ユーザーからの入力データなどに余分な空白が含まれている場合、これを整形するのに非常に便利です。

一方、`replace()`メソッドは、文字列内の特定の部分を別の文字列に置き換える際に使用します。例えば、特定の文字を別の文字に置き換えたり、特定の単語を別の単語に置き換えたりできます。`replace()`には、`char`型を引数にとるものと、`CharSequence`（`String`もこれに含まれる）を引数にとるものがあります。これらのメソッドを使うことで、入力データのクリーンアップや文字列の変換処理を効率的に行えます。

“`java
public class StringManipulationExample {
public static void main(String[] args) {
String data = ” Hello Java \n”;

// trim()による空白除去
String trimmedData = data.trim();
System.out.println(“元のデータ: \”” + data + “\””);
System.out.println(“trim後: \”” + trimmedData + “\””);
// 元のデータ: ” Hello Java
// ”
// trim後: “Hello Java”

String sentence = “Javaは素晴らしいプログラミング言語です。Javaを学びましょう。”;

// replace()による文字列置換
String replacedSentence = sentence.replace(“Java”, “Python”);
System.out.println(“元の文: ” + sentence);
System.out.println(“replace後 (Java -> Python): ” + replacedSentence);
// replace後 (Java -> Python): Pythonは素晴らしいプログラミング言語です。Pythonを学びましょう。

// 特定の文字を置換
String replaceChar = “Hello World”.replace(‘o’, ‘a’);
System.out.println(“文字置換: ” + replaceChar); // Hella Warld
}
}
“`

数値と文字列の相互変換：`valueOf()`

プログラムでは、数値と文字列の間でデータを変換する場面が頻繁に発生します。特に、数値を画面に表示する際や、外部から読み込んだ文字列データを数値として計算に利用する際に必要となります。

`String.valueOf()`メソッドは、様々な型の値（`int`, `double`, `boolean`, `char`, `Object`など）を文字列（`String`オブジェクト）に変換するための非常に便利なスタティックメソッドです。例えば、`String.valueOf(123)`は `”123″` という文字列を返します。このメソッドは、`null`が渡された場合でも`”null”`という文字列を返すため、NullPointerExceptionを気にせずに使用できる利点もあります。

逆に、文字列を数値に変換したい場合は、`Integer.parseInt()`（整数）や`Double.parseDouble()`（浮動小数点数）のような各ラッパークラスのメソッドを使用します。これらの相互変換機能を理解しておくことで、データ処理の幅が大きく広がります。

“`java
public class ValueOfExample {
public static void main(String[] args) {
int num = 123;
double price = 98.76;
boolean isActive = true;
char grade = ‘A’;
Object obj = null; // nullも変換可能

// 数値から文字列への変換
String strNum = String.valueOf(num);
String strPrice = String.valueOf(price);
String strBool = String.valueOf(isActive);
String strChar = String.valueOf(grade);
String strNull = String.valueOf(obj);

System.out.println(“int -> String: ” + strNum); // 123
System.out.println(“double -> String: ” + strPrice); // 98.76
System.out.println(“boolean -> String: ” + strBool); // true
System.out.println(“char -> String: ” + strChar); // A
System.out.println(“null -> String: ” + strNull); // null

// (参考) 文字列から数値への変換
String strToParse = “456”;
int parsedInt = Integer.parseInt(strToParse);
System.out.println(“String -> int: ” + parsedInt); // 456

String strToParseDouble = “12.34”;
double parsedDouble = Double.parseDouble(strToParseDouble);
System.out.println(“String -> double: ” + parsedDouble); // 12.34
}
}
“`