Javaを使ってプログラミングを始めるためには、まず開発環境を整える必要があります。この章では、Javaの開発に必要なツールのインストール方法から、実際に簡単なプログラムを実行するまでの手順を詳しく解説します。初心者がつまずきやすい部分を丁寧にフォローし、スムーズにプログラミングを始められるようにガイドします。

2.1 JDK（Java Development Kit）とは？

Javaの開発には、JDK（Java Development Kit）と呼ばれる開発キットが必要です。JDKは、以下のようなツールを含む一式のソフトウェアで構成されています。

• Javaコンパイラ（javac）: ソースコードをバイトコードに変換するためのツールです。
• Java仮想マシン（JVM）: バイトコードを実行するための仮想マシンです。これにより、プログラムはさまざまなOSで動作します。
• Javaクラスライブラリ: Javaの標準機能を提供するクラス群です。

このJDKをインストールすることで、Javaプログラムの開発、コンパイル、実行が可能になります。

2.2 JDKのインストール

ステップ1: JDKのダウンロード

まず、Javaの公式サイトからJDKをダウンロードする必要があります。Oracleが提供している最新のJDKをダウンロードするためには、以下の手順を実行してください。

1. Oracleの公式サイトにアクセスします。
2. 自分のOS（Windows、Mac、Linux）に対応したJDKを選択し、ダウンロードリンクをクリックします。
3. 利用規約に同意し、ダウンロードを開始します。

ステップ2: JDKのインストール

ダウンロードが完了したら、次はJDKをインストールします。以下の手順に従ってインストールを行います。

Windowsの場合:

1. ダウンロードしたインストーラーを実行します。
2. インストーラーの指示に従い、インストールディレクトリを確認してインストールを完了します。
3. インストールが完了すると、JDKのパスが自動的に設定されます。

Macの場合:

1. ダウンロードした.dmgファイルを開き、インストーラーを実行します。
2. 指示に従ってインストールを進めます。
3. Macの/Library/Java/JavaVirtualMachinesにJDKがインストールされます。

ステップ3: 環境変数の設定（Windowsのみ）

Windows環境では、JDKを正常に動作させるために「環境変数」を設定する必要があります。以下の手順で設定を行います。

1. コントロールパネルを開き、「システムとセキュリティ」から「システム」を選択します。
2. 「システムの詳細設定」をクリックし、「環境変数」を選択します。
3. 「システム環境変数」の中からPathを選択し、「編集」をクリックします。
4. JDKがインストールされているディレクトリ（例: C:\Program Files\Java\jdk-17\bin）を追加します。
5. 「OK」をクリックして設定を保存します。

これで、コマンドプロンプトからjavaやjavacコマンドを実行できるようになります。

2.3 IDE（統合開発環境）のセットアップ

Javaのプログラムを開発する際には、IDE（Integrated Development Environment）と呼ばれる統合開発環境を使用すると便利です。IDEは、プログラムの編集、コンパイル、デバッグ、実行を一つのツール上で行うことができるため、非常に効率的です。

ここでは、Java開発でよく使われる2つの主要なIDEであるEclipseとIntelliJ IDEAのセットアップ手順を紹介します。

Eclipseのセットアップ

1. Pleiades All in One Eclipse ダウンロード にアクセスし、「Windows x64」または「Mac ARM」のjavaまたはをダウンロードします。(Ultimateでも良いです)
2. ダウンロードしたファイルを実行してインストールを進めます。
3. インストールが完了したら、Eclipseを起動し、作業用ディレクトリ（ワークスペース）を指定します。
4. 「New Project」を選択し、「Java Project」を作成します。

これで、Eclipse上でJavaのプログラムを書く準備が整いました。

IntelliJ IDEAのセットアップ

1. JetBrainsの公式サイトからIntelliJ IDEAをダウンロードします。無償版のIntelliJ IDEA Community Editionを選択します。
2. ダウンロードしたインストーラーを実行し、指示に従ってインストールを進めます。
3. インストールが完了したら、IntelliJ IDEAを起動し、「New Project」を選択してJavaプロジェクトを作成します。

IntelliJ IDEAは直感的で使いやすく、特にJava初心者には非常におすすめのIDEです。

2.4 最初のJavaプログラムを書く

Javaの開発環境が整ったところで、実際に簡単なプログラムを書いてみましょう。ここでは、プログラミングの定番である「Hello, World!」プログラムを作成します。

Hello, World! プログラムのコード

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

コードの解説

• public class HelloWorld: これはJavaのクラス定義です。HelloWorldという名前のクラスを作成しています。
• public static void main(String[] args): これはJavaプログラムのエントリーポイントとなるメソッドです。プログラムの実行はこのmainメソッドから始まります。
• System.out.println("Hello, World!");: この行は、標準出力に「Hello, World!」という文字列を表示する命令です。

Eclipseでの実行方法

1. Eclipseで新しいJavaプロジェクトを作成し、その中に新しいクラスを追加します。
2. クラス名をHelloWorldとし、上記のコードを入力します。
3. メインメソッドの中にSystem.out.printlnを追加して、「Hello, World!」を表示させます。
4. クラスファイルを保存したら、右クリックして「Run As」→「Java Application」を選択して実行します。

IntelliJ IDEAでの実行方法

1. IntelliJ IDEAで新しいプロジェクトを作成し、クラスファイルを追加します。
2. HelloWorldというクラスを作成し、コードを入力します。
3. 画面上部にある「再生ボタン（Run）」をクリックしてプログラムを実行します。

実行結果として、コンソールに「Hello, World!」と表示されれば成功です！

2.5 Javaプログラムのコンパイルと実行（コマンドラインでの手順）

Javaのプログラムは、IDEを使わずにコマンドラインから直接コンパイルして実行することも可能です。ここでは、コマンドラインを使った手順も説明します。

ステップ1: コードを書く

テキストエディタ（例: メモ帳やVSCodeなど）を使って、以下のコードをHelloWorld.javaという名前で保存します。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

ステップ2: コンパイル

保存したファイルがあるディレクトリに移動し、以下のコマンドを使ってコンパイルします。

javac HelloWorld.java

javacコマンドは、Javaコンパイラを呼び出してソースコードをバイトコードに変換します。コンパイルが成功すると、HelloWorld.classというファイルが作成されます。

ステップ3: 実行

次に、javaコマンドを使って、コンパイルされたプログラムを実行します。

java HelloWorld

これで、コンソールに「Hello, World!」と表示されるはずです。無事に表示された場合、開発環境は正しく整っており、Javaプログラムを実行できる状態になっています。

2.6 よくあるトラブルシューティング

初心者がJavaの開発環境をセットアップする際に、よく遭遇する問題とその解決方法についても触れておきます。

1. javacコマンドが見つからない

エラー: javac is not recognized as an internal or external command, operable program or batch file.

原因: JDKのパスが環境変数に設定されていないことが原因です。

解決方法: 環境変数にJDKのbinディレクトリへのパスを追加してください（Windowsの場合）。前述の「環境変数の設定（Windowsのみ）」の手順を参考にしてください。

2. プログラムが正しくコンパイルされない

原因: Javaのコードにミスがある場合や、ファイル名がクラス名と一致していない場合があります。

解決方法: エラーメッセージを確認し、コードの誤りを修正します。また、Javaのクラス名はファイル名と一致している必要があるため、クラス名とファイル名が一致しているか確認してください。

Javaの開発環境が整ったところで、次は実際にプログラムを書き始めるために、基本構文を学びます。Javaの構文はシンプルでありながら、非常に強力です。この章では、Javaのプログラムがどのように構成されているかを理解し、基本的な構文を学んでいきます。

この章で取り上げるトピックは次の通りです：

• クラスとメソッドの基本
• Javaのデータ型と変数
• リテラルと定数
• 型変換
• 演算子の種類と使い方

3.1 クラスとメソッドの基本構造

Javaプログラムのすべては「クラス」から始まります。Javaでは、クラスがプログラムの基本単位であり、すべてのプログラムはクラスの中に記述されます。クラスの中には、プログラムの実行時に呼び出される「メソッド」が含まれています。

3.1.1 クラスの定義

Javaのクラスを定義する基本的な書き方は次の通りです。

public class クラス名 {
    // フィールド（変数やデータ）
    // メソッド（処理のまとまり）
}

• public: アクセス修飾子で、他のクラスからアクセスできることを示します。
• class: クラスを定義するためのキーワードです。
• クラス名: クラスの名前です。クラス名は必ず大文字で始めるのが一般的です。

3.1.2 メソッドの定義

メソッドは、特定の処理を行うためのコードのまとまりです。Javaではmainメソッドがプログラムのエントリーポイント（開始地点）となります。以下がmainメソッドを含むクラスの例です。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

• public: 他のクラスからもアクセス可能なメソッドであることを示します。
• static: クラスメソッドとして定義し、インスタンスを作成せずに呼び出せることを示します。
• void: このメソッドが何も値を返さないことを示します。
• main: メソッド名で、Javaプログラムのエントリーポイントとして特別な役割を持つ名前です。
• String[] args: コマンドライン引数を受け取るための配列です。

このmainメソッドの中に処理を書き込むことで、プログラムの実行が開始されます。

3.2 Javaのデータ型と変数

Javaには、プログラム中でデータを扱うために「データ型」が定義されています。データ型は、変数に格納できる値の種類を指定します。変数とは、データを格納するための名前付きの箱のようなものです。

3.2.1 プリミティブ型（基本データ型）

Javaには8つの基本的なデータ型があり、これらは「プリミティブ型」と呼ばれます。

3.2.2 変数の宣言と初期化

変数を使うには、まずその型を指定して宣言し、値を代入します。これを変数の宣言と初期化と言います。

int x = 10;  // 整数型の変数xを宣言し、10を代入
double pi = 3.14159;  // 浮動小数点数型の変数piを宣言し、3.14159を代入

上記の例では、int型の変数xに10を代入し、double型の変数piに3.14159を代入しています。

3.3 リテラルと定数

Javaでは、プログラム中に直接書き込まれる値を「リテラル」と呼びます。リテラルは、変数に格納される具体的な値を指します。

3.3.1 リテラルの種類

• 整数リテラル: int型やlong型の数値。例：10、-5。
• 浮動小数点リテラル: float型やdouble型の数値。例：3.14、2.71828。
• 文字リテラル: 単一の文字を表すリテラル。例：'A'、'1'。
• 文字列リテラル: 文字列全体を表すリテラル。例："Hello"、"Java"。
• 論理リテラル: 真偽値を表すリテラル。例：true、false。

3.3.2 定数

定数は、一度値を代入すると変更することができない変数のことです。Javaでは、finalキーワードを使って定数を定義します。

final double PI = 3.14159;

ここで、PIという定数を宣言し、値を3.14159に設定しています。この値は以降変更できません。

3.4 型変換（キャスト）

Javaでは、異なるデータ型の値を扱うときに型変換が必要になる場合があります。これには、「暗黙の型変換」と「明示的な型変換（キャスト）」の2種類があります。

3.4.1 暗黙の型変換

データ型のサイズが大きい型に自動的に変換されることを暗黙の型変換と言います。例えば、int型の値をdouble型に代入する場合は自動的に変換されます。

int num = 10;
double dNum = num;  // intからdoubleへの暗黙の型変換

3.4.2 明示的な型変換（キャスト）

データ型のサイズが小さい型に変換する場合や、互換性のない型に変換する場合は、明示的に型変換を指定する必要があります。これを「キャスト」と呼びます。

double dNum = 9.99;
int num = (int) dNum;  // doubleからintへのキャスト（小数点以下は切り捨て）

3.5 演算子の種類と使い方

Javaには、さまざまな種類の演算子が用意されています。演算子は、変数やリテラルに対して演算を行うための記号です。ここでは、代表的な演算子の使い方を見ていきます。

3.5.1 算術演算子

算術演算子は、数値に対する基本的な演算を行うための演算子です。

例:

int a = 10;
int b = 5;
int result = a + b;  // 15

3.5.2 比較演算子

比較演算子は、2つの値を比較して結果としてtrueまたはfalseを返します。

例:

int a = 10;
int b = 5;
boolean isEqual = (a == b);  // false

3.5.3 論理演算子

論理演算子は、ブール値（trueまたはfalse）を操作するために使用されます。条件式の結合や論理値の否定に使われます。

例:

boolean a = true;
boolean b = false;
boolean result = a && b;  // false

3.5.4 代入演算子

代入演算子は、変数に値を代入するために使用されます。最も基本的な代入演算子は=ですが、他にも複合代入演算子があります。

例:

int a = 10;
a += 5;  // aは15になる

3.6 Javaの基本構文まとめ

ここまで、Javaのプログラムがどのように構成されているか、そして基本的なデータ型、変数、リテラル、演算子について学びました。Javaの基礎的な構文を理解することで、今後のプログラミングの土台がしっかり築かれます。これからさらに進んで、条件分岐やループといったプログラムの制御構文を学んでいきましょう。

プログラミングにおいて、制御構文は重要な要素です。制御構文を使うことで、プログラムが特定の条件に応じて異なる処理を実行したり、同じ処理を繰り返すことができます。この章では、Javaの条件分岐と繰り返し処理に関連する制御構文を学びます。具体的には、if文、switch文、forループ、whileループ、breakやcontinueなどのキーワードを使った処理の制御方法を詳しく説明します。

4.1 条件分岐 〜if文とelse文〜

まず、Javaプログラムで特定の条件に基づいて処理を分岐させる方法から始めます。これを実現するために使われるのが、if文や**else文**です。

4.1.1 if文の基本構造

if文は、条件式がtrueのときに処理を実行する構文です。

if (条件) {
    // 条件がtrueの場合に実行されるコード
}

例えば、以下のコードでは、xの値が10以上である場合にメッセージが表示されます。

int x = 15;
if (x >= 10) {
    System.out.println("xは10以上です。");
}

4.1.2 if-else文

if-else文を使うことで、条件がfalseである場合に別の処理を実行することができます。

if (条件) {
    // 条件がtrueの場合に実行されるコード
} else {
    // 条件がfalseの場合に実行されるコード
}

次の例では、xの値が10以上かどうかで表示されるメッセージが異なります。

int x = 5;
if (x >= 10) {
    System.out.println("xは10以上です。");
} else {
    System.out.println("xは10未満です。");
}

4.1.3 if-else if-else文

複数の条件を扱いたい場合は、if-else if-else文を使います。

if (条件1) {
    // 条件1がtrueの場合に実行されるコード
} else if (条件2) {
    // 条件2がtrueの場合に実行されるコード
} else {
    // すべての条件がfalseの場合に実行されるコード
}

例えば、以下の例では、xの値に応じて異なるメッセージを表示します。

int x = 20;
if (x > 30) {
    System.out.println("xは30より大きいです。");
} else if (x > 10) {
    System.out.println("xは10より大きく、30以下です。");
} else {
    System.out.println("xは10以下です。");
}

4.2 switch文 〜複数の条件を簡潔に扱う〜

次に、複数の条件に基づいて処理を分岐させる際に便利な**switch文**を見ていきます。switch文は、特定の変数の値に応じて実行する処理を選択するために使用されます。

4.2.1 switch文の基本構造

switch文では、変数の値が特定の値に一致した場合に対応する処理を実行します。

switch (変数) {
    case 値1:
        // 値1の場合に実行されるコード
        break;
    case 値2:
        // 値2の場合に実行されるコード
        break;
    default:
        // どの値にも一致しない場合に実行されるコード
}

例えば、次の例では、dayの値に応じて曜日を表示します。

int day = 3;
switch (day) {
    case 1:
        System.out.println("日曜日");
        break;
    case 2:
        System.out.println("月曜日");
        break;
    case 3:
        System.out.println("火曜日");
        break;
    default:
        System.out.println("不明な曜日です");
        break;
}

4.2.2 Java 12以降のswitch文の新構文

Java 12からは、switch文が「式」としても使えるようになり、より簡潔な記述が可能になりました。

String dayName = switch (day) {
    case 1 -> "日曜日";
    case 2 -> "月曜日";
    case 3 -> "火曜日";
    default -> "不明な曜日です";
};
System.out.println(dayName);

この新しいswitch構文では、caseの後に->を使い、値を返す形で処理を記述します。yieldを使って複雑なロジックを返すこともできます。

4.3 繰り返し処理 〜forループとwhileループ〜

繰り返し処理は、同じ処理を複数回実行するために使います。ここでは、forループと**whileループ**の使い方を学びます。

4.3.1 forループの基本構造

forループは、特定の回数だけ処理を繰り返したい場合に使用します。

for (初期化; 条件; 変化式) {
    // 繰り返す処理
}

例えば、1から5までの数字を順番に表示するプログラムは次のようになります。

for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

• 初期化: ループの最初に1回だけ実行される処理（例: int i = 1）。
• 条件: ループを続けるかどうかを判定する条件（例: i <= 5）。
• 変化式: 各ループの最後に実行される処理（例: i++）。

4.3.2 拡張forループ（for-each）

拡張forループは、配列やコレクションの要素を1つずつ処理するために使います。例えば、配列の全要素を表示する場合に便利です。

int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}

ここでは、配列numbersの各要素を順番に取り出してnumに代入し、その値を表示しています。

4.3.3 whileループの基本構造

whileループは、特定の条件がtrueである間、処理を繰り返す構文です。

while (条件) {
    // 繰り返す処理
}

例えば、iが5以下である間、数字を表示するプログラムは次のようになります。

int i = 1;
while (i <= 5) {
    System.out.println(i);
    i++;
}

4.3.4 do-whileループ

do-whileループは、少なくとも1回は必ず処理を実行してから条件を判定します。

do {
    // 最初に実行される処理
} while (条件);

例えば、iが5以下である間、数字を表示するプログラムは次のようになります。

int i = 1;
do {
    System.out.println(i);
    i++;
} while (i <= 5);

4.4 繰り返し処理の制御 〜break文とcontinue文〜

繰り返し処理の中で、特定の条件が満たされたときにループを終了させたり、スキップしたりしたい場合に、break文や**continue文**を使います。

4.4.1 break文

break文は、ループを強制的に終了させるために使います。例えば、以下のプログラムではiが3になった時点でループが終了します。

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        break;  // ループを終了
    }
    System.out.println(i);
}

4.4.2 continue文

continue文は、ループの残りの処理をスキップして次の繰り返しに移ります。以下の例では、iが3のときだけ表示をスキップします。

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue;  // 3の場合はスキップ
    }
    System.out.println(i);
}

4.5 Javaの制御構文まとめ

この章では、Javaの制御構文について学びました。条件分岐ではif文やswitch文を使って処理を分岐させ、繰り返し処理ではforループやwhileループを使って同じ処理を繰り返すことができるようになりました。また、breakやcontinueを使ってループの制御を柔軟に行うことも可能です。

制御構文はプログラムを論理的に組み立てる上で非常に重要な要素です。次章では、Javaのメソッドについて詳しく学び、再利用可能なコードの書き方を理解していきます。

プログラムを書く上で、同じ処理を何度も繰り返し書くのは効率的ではありません。Javaでは、メソッドを使用して、処理を一箇所にまとめ、必要に応じて何度も呼び出すことができます。メソッドはプログラムを整理し、再利用性を高め、可読性を向上させます。この章では、メソッドの基本から、引数や戻り値、メソッドのオーバーロード、静的メソッドについて詳しく学びます。

5.1 メソッドとは？

メソッドは、特定の処理を一つのまとまりとして定義したものです。メソッドを使うことで、同じコードを繰り返し書く必要がなくなり、プログラムを効率的に記述できます。メソッドは、引数を受け取り、必要に応じて戻り値を返すことができます。

5.1.1 メソッドの基本構造

Javaでメソッドを定義する基本構造は次の通りです。

アクセス修飾子 戻り値の型 メソッド名(引数リスト) {
    // メソッドの処理
    return 戻り値; // 戻り値がある場合
}

• アクセス修飾子: publicやprivateなど、メソッドがどこからアクセスできるかを指定します。
• 戻り値の型: メソッドが返す値の型です。戻り値がない場合はvoidを指定します。
• メソッド名: メソッドを呼び出すための名前です。
• 引数リスト: メソッドに渡すデータ（パラメータ）を定義します。

5.1.2 メソッドの例

次のコードは、addNumbersという名前のメソッドを定義し、2つの整数を引数として受け取り、それらの和を返すメソッドの例です。

public int addNumbers(int num1, int num2) {
    int sum = num1 + num2;
    return sum;
}

このメソッドは、num1とnum2の合計を計算し、その結果を戻り値として返します。

5.2 メソッドの呼び出し

メソッドを定義したら、そのメソッドをプログラムの中で呼び出すことができます。メソッドを呼び出すときは、メソッド名と必要な引数を指定します。

5.2.1 メソッド呼び出しの基本

次に、addNumbersメソッドを呼び出して結果を表示する例を示します。

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        int result = main.addNumbers(5, 10);
        System.out.println("合計は: " + result);
    }

    public int addNumbers(int num1, int num2) {
        int sum = num1 + num2;
        return sum;
    }
}

• メソッドの呼び出し: main.addNumbers(5, 10)でメソッドを呼び出し、5と10を引数として渡します。
• 戻り値の処理: 戻り値は変数resultに代入され、結果が出力されます。

5.2.2 戻り値がないメソッド（voidメソッド）

戻り値がないメソッドでは、void型を指定します。次の例は、挨拶を表示するだけのメソッドです。

public void sayHello() {
    System.out.println("こんにちは！");
}

このメソッドは何も返さず、呼び出すだけでメッセージを表示します。

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.sayHello();
    }

    public void sayHello() {
        System.out.println("こんにちは！");
    }
}

5.3 引数とパラメータ

メソッドにデータを渡すために、引数を使います。引数は、メソッドが必要とするデータを外部から受け取るための仕組みです。引数は、メソッド定義の中でパラメータとして宣言されます。

5.3.1 引数の使い方

以下の例では、2つの引数num1とnum2を受け取り、その合計を表示します。

public void printSum(int num1, int num2) {
    int sum = num1 + num2;
    System.out.println("合計は: " + sum);
}

このメソッドを呼び出すときに、2つの整数を渡します。

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.printSum(5, 15);
    }

    public void printSum(int num1, int num2) {
        int sum = num1 + num2;
        System.out.println("合計は: " + sum);
    }
}

5.3.2 複数の引数を持つメソッド

メソッドは、複数の引数を受け取ることができます。例えば、3つの整数を受け取り、それらの最大値を返すメソッドを考えてみましょう。

public int max(int a, int b, int c) {
    int max = a;
    if (b > max) {
        max = b;
    }
    if (c > max) {
        max = c;
    }
    return max;
}

このメソッドは、3つの引数を受け取り、その中で最大の値を返します。

5.4 メソッドの戻り値

メソッドは処理結果を返すことができます。これを戻り値と呼びます。戻り値の型は、メソッド定義で指定する必要があります。voidメソッドは戻り値を持たないため、この場合は戻り値の型としてvoidを指定します。

5.4.1 戻り値の型を指定する

例えば、整数を返すメソッドでは、int型を指定します。

public int square(int num) {
    return num * num;
}

5.4.2 戻り値が複雑な場合

戻り値が複数のデータを含む場合、オブジェクトや配列として返すことができます。例えば、2つの整数の合計と積を同時に返す方法を見てみましょう。

public int[] sumAndProduct(int a, int b) {
    int[] result = new int[2];
    result[0] = a + b;
    result[1] = a * b;
    return result;
}

戻り値として配列を返し、呼び出し側でそれを処理します。

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        int[] result = main.sumAndProduct(5, 10);
        System.out.println("合計: " + result[0]);
        System.out.println("積: " + result[1]);
    }

    public int[] sumAndProduct(int a, int b) {
        int[] result = new int[2];
        result[0] = a + b;
        result[1] = a * b;
        return result;
    }
}

5.5 メソッドのオーバーロード

Javaでは、メソッドのオーバーロードを利用して、同じ名前のメソッドを複数定義することができます。ただし、メソッドの引数の数や型が異なる必要があります。これにより、異なる引数を受け取るメソッドを統一して定義できます。

5.5.1 オーバーロードの基本

例えば、次の例では、addNumbersメソッドが異なる型の引数を受け取るバージョンをオーバーロードしています。

public int addNumbers(int a, int b) {
    return a + b;
}

public double addNumbers(double a, double b) {
    return a + b;
}

この場合、int型の引数が渡された場合は1つ目のメソッドが、double型の引数が渡された場合は2つ目のメソッドが呼び出されます。

5.5.2 オーバーロードの例

次に、引数の数が異なる場合のメソッドオーバーロードを示します。

public int addNumbers(int a, int b) {
    return a + b;
}

public int addNumbers(int a, int b, int c) {
    return a + b + c;
}

• 2つの整数を受け取るバージョンと、3つの整数を受け取るバージョンが定義されています。
• 呼び出す際に、渡す引数の数に応じて適切なメソッドが自動的に選択されます。

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        System.out.println(main.addNumbers(5, 10));  // 2つの引数を使用
        System.out.println(main.addNumbers(5, 10, 15));  // 3つの引数を使用
    }

    public int addNumbers(int a, int b) {
        return a + b;
    }

    public int addNumbers(int a, int b, int c) {
        return a + b + c;
    }
}

5.6 staticメソッド

staticメソッドは、インスタンス化しなくてもクラスから直接呼び出すことができるメソッドです。staticメソッドは、主にクラス全体に関連する操作を行う場合に使用されます。例えば、MathクラスのMath.pow()などのメソッドはstaticメソッドです。

5.6.1 staticメソッドの定義

次に、staticメソッドを定義し、使用する例を示します。

public class Calculator {
    public static int add(int a, int b) {
        return a + b;
    }
}

このaddメソッドは、Calculatorクラスのインスタンスを作成せずに呼び出すことができます。

public class Main {
    public static void main(String[] args) {
        int sum = Calculator.add(10, 20);
        System.out.println("合計は: " + sum);
    }
}

• staticメソッドの利点: メモリ効率が高く、簡単にアクセスできるため、ユーティリティメソッドなどに適しています。
• 制約: staticメソッド内ではインスタンス変数を使用できません。クラス変数や他のstaticメソッドのみを使用できます。

5.7 Javaのメソッドまとめ

この章では、Javaのメソッドの基本構造から、メソッドの呼び出し、引数と戻り値、メソッドのオーバーロード、staticメソッドについて学びました。メソッドを使うことで、コードの再利用性が高まり、プログラムがより整理され、理解しやすくなります。

メソッドの使い方をマスターすることで、Javaプログラミングはより強力で効率的になります。次章では、オブジェクト指向プログラミングの重要な概念であるクラスとオブジェクトについて学び、Javaのさらなる機能を探求していきます。

Javaはオブジェクト指向プログラミング（OOP）を基盤とした言語であり、その中心にあるのがクラスとオブジェクトの概念です。オブジェクト指向の特徴は、現実世界をモデルにした「オブジェクト」という単位でデータとその処理を管理することにあります。この章では、Javaのオブジェクト指向プログラミングの基礎となるクラスとオブジェクトについて学びます。

具体的には、以下のトピックをカバーします：

• クラスとオブジェクトの基本
• フィールド（インスタンス変数）とメソッド（インスタンスメソッド）
• コンストラクタ
• thisキーワード
• クラスメンバーとインスタンスメンバー
• ガベージコレクション（GC）の仕組み

6.1 クラスとオブジェクトとは？

クラスは、オブジェクトを作成するための「設計図」とも言えます。クラスには、オブジェクトが持つべき属性（データ）と振る舞い（メソッド）が定義されています。このクラスに基づいて作成される実体がオブジェクトです。オブジェクトは、クラスで定義された属性とメソッドを具体的に持つ実際のデータです。

6.1.1 クラスの定義

Javaでクラスを定義するための基本的な構文は次の通りです。

public class クラス名 {
    // フィールド（属性）
    // メソッド（振る舞い）
}

クラス名は通常、大文字で始め、各単語の先頭を大文字にする「キャメルケース」で命名します。以下は、Personというクラスの定義例です。

public class Person {
    String name;   // 名前
    int age;       // 年齢

    // メソッド（振る舞い）
    public void introduce() {
        System.out.println("私の名前は " + name + " です。年齢は " + age + " 歳です。");
    }
}

このクラスは、人を表す属性として名前と年齢（フィールド）を持ち、自己紹介を行うメソッドを持っています。

6.1.2 オブジェクトの生成

クラスが定義されたら、そのクラスからオブジェクトを生成することができます。オブジェクトを生成するためにはnewキーワードを使います。

Person person1 = new Person();

ここで、person1はPersonクラスから作られたオブジェクトです。newキーワードはメモリにオブジェクトを作成し、そのオブジェクトの参照を変数person1に代入します。

6.1.3 オブジェクトの使用

生成したオブジェクトに対しては、そのクラスで定義されたフィールドやメソッドにアクセスできます。次の例では、Personオブジェクトのフィールドに値を代入し、メソッドを呼び出します。

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.name = "太郎";
        person1.age = 25;
        person1.introduce();  // メソッドの呼び出し
    }
}

実行結果は次のようになります。

コードをコピーする私の名前は 太郎 です。年齢は 25 歳です。

6.2 フィールド（インスタンス変数）とメソッド（インスタンスメソッド）

オブジェクト指向プログラミングでは、クラスの中にフィールド（属性）とメソッド（振る舞い）を定義します。オブジェクトが持つデータがフィールド、オブジェクトが行う処理がメソッドです。

6.2.1 フィールド（インスタンス変数）

フィールドは、オブジェクトが持つデータを保持するための変数です。Javaでは、フィールドはクラス内に定義され、オブジェクトごとに固有の値を持つことができます。

public class Car {
    String model;  // モデル名
    int year;      // 製造年
}

上記のCarクラスでは、各オブジェクトがモデル名と製造年を持つことができます。

6.2.2 メソッド（インスタンスメソッド）

メソッドは、オブジェクトが実行する処理の定義です。メソッドはクラス内に定義され、オブジェクトごとに実行される処理を記述します。

public void startEngine() {
    System.out.println("エンジンが始動しました。");
}

上記のstartEngineメソッドは、Carクラスに追加できる処理の一つです。

6.3 コンストラクタ

コンストラクタは、クラスのオブジェクトを生成する際に呼び出される特別なメソッドです。コンストラクタは通常、オブジェクトの初期化を行います。Javaでは、クラスと同じ名前のメソッドがコンストラクタになります。

6.3.1 コンストラクタの定義

コンストラクタの基本的な定義は次の通りです。

public クラス名(引数リスト) {
    // 初期化処理
}

次の例は、Personクラスにコンストラクタを追加したものです。このコンストラクタは、オブジェクト生成時に名前と年齢を設定するために使用されます。

public class Person {
    String name;
    int age;

    // コンストラクタ
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.println("私の名前は " + name + " です。年齢は " + age + " 歳です。");
    }
}

6.3.2 コンストラクタの呼び出し

オブジェクトを生成する際に、コンストラクタに引数を渡すことで、オブジェクトを初期化します。

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("太郎", 25);
        person1.introduce();
    }
}

実行結果：

コードをコピーする私の名前は 太郎 です。年齢は 25 歳です。

6.4 thisキーワード

Javaでは、thisキーワードを使って、現在のオブジェクトを参照することができます。通常、thisはコンストラクタやメソッド内で使われ、インスタンス変数やメソッドにアクセスする際に使用されます。

6.4.1 thisの使用例

次の例では、コンストラクタ内でthisを使って、パラメータとインスタンス変数を区別しています。

public class Person {
    String name;
    int age;

    // コンストラクタ
    public Person(String name, int age) {
        this.name = name;  // thisを使ってインスタンス変数を参照
        this.age = age;
    }

    public void introduce() {
        System.out.println("私の名前は " + name + " です。年齢は " + age + " 歳です。");
    }
}

this.nameは、オブジェクトのインスタンス変数nameを指し、nameだけの場合はコンストラクタのパラメータを指します。

6.5 クラスメンバーとインスタンスメンバー

Javaでは、クラスにはインスタンスメンバーとクラスメンバーの2種類のメンバーが存在します。インスタンスメンバーは、各オブジェクトごとに異なる値を持つことができますが、クラスメンバーは全てのオブジェクト間で共有されます。

6.5.1 インスタンスメンバー

インスタンスメンバーは、各オブジェクトごとに異なるデータを保持するフィールドやメソッドです。これまで紹介してきたフィールドやメソッドは、すべてインスタンスメンバーです。

6.5.2 クラスメンバー（静的メンバー）

クラスメンバーは、クラス全体に関連するデータや処理を定義します。クラスメンバーを定義するには、staticキーワードを使用します。クラスメンバーは、クラスがロードされた時点でメモリに割り当てられ、全てのオブジェクト間で共有されます。

次の例では、Personクラスにstaticメンバーを追加しています。

public class Person {
    String name;
    int age;
    static int population = 0;  // クラスメンバー

    // コンストラクタ
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        population++;  // 人口カウントを増加
    }

    public static void showPopulation() {
        System.out.println("人口は " + population + " 人です。");
    }
}

クラスメンバーは、クラス名を使って直接呼び出すことができます。

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("太郎", 25);
        Person person2 = new Person("花子", 22);

        Person.showPopulation();  // クラスメンバーの呼び出し
    }
}

実行結果：

人口は 2 人です。

6.6 ガベージコレクション（GC）

Javaでは、不要になったオブジェクトを自動的にメモリから解放する仕組みが備わっています。これを**ガベージコレクション（GC）**と呼びます。ガベージコレクションは、開発者がメモリ管理を手動で行う必要がないため、メモリリークのリスクを減らし、プログラムの安全性を向上させます。

6.6.1 ガベージコレクタの動作

Javaのガベージコレクタは、メモリ上で参照されなくなったオブジェクトを自動的に検出し、それらを回収してメモリを解放します。プログラマが明示的に解放処理を行う必要はありません。

6.6.2 ガベージコレクションの仕組み

例えば、以下のように一度作成したオブジェクトをその後参照しなくなった場合、そのオブジェクトはガベージコレクタによって回収されます。

public class Main {
    public static void main(String[] args) {
        Person person = new Person("太郎", 25);
        person = null;  // オブジェクトへの参照を切る
        // ここで、personオブジェクトはガベージコレクションの対象になる
    }
}

6.7 クラスとオブジェクトまとめ

この章では、オブジェクト指向プログラミングの中心であるクラスとオブジェクトの基本的な概念と、その使い方を学びました。フィールドやメソッド、コンストラクタ、thisキーワード、クラスメンバーとインスタンスメンバーの違い、さらにJavaのガベージコレクションの仕組みについても解説しました。これらの知識は、Javaプログラムをオブジェクト指向的に設計し、コードの再利用性とメンテナンス性を向上させるための基盤となります。

次章では、Javaの配列について詳しく学び、複数のデータを効率的に扱う方法を探っていきます。

プログラミングでは、複数のデータを効率的に扱う場面が頻繁にあります。配列は、そのような場合に非常に便利なデータ構造です。Javaにおける配列は、同じ型のデータをまとめて管理するための仕組みであり、要素数が固定されているため、メモリ効率が良いという特徴があります。この章では、Javaの配列に関する基礎知識から、配列の初期化、アクセス方法、そして多次元配列に至るまで、詳しく解説します。

7.1 配列とは？

配列とは、同じ型の複数のデータを1つにまとめて扱うことができるデータ構造です。配列を使うと、データを個別に扱うのではなく、1つの変数で複数のデータを効率的に管理できます。配列内の各データ（要素）はインデックスを使ってアクセスします。

7.1.1 配列の特徴

• 固定長: 配列は作成時に要素の数（サイズ）を指定し、その後変更することはできません。
• 同じデータ型: 配列に格納できるデータはすべて同じ型でなければなりません。
• インデックス: 配列の要素には、0から始まるインデックスを使ってアクセスします。インデックス0は最初の要素、インデックス1は2番目の要素といった具合です。

7.1.2 配列のメリット

• 効率的なメモリ管理: 配列は固定長であるため、メモリが効率的に管理されます。
• 高速なアクセス: インデックスを使った要素へのアクセスは非常に高速です。
• データの整理: 複数のデータを1つにまとめることで、プログラムの可読性や保守性が向上します。

7.2 配列の宣言と初期化

Javaで配列を使用するには、まず配列の宣言と初期化を行う必要があります。配列の宣言は、配列の型を指定して変数を作成し、初期化によって配列のサイズを決定します。

7.2.1 配列の宣言

配列を宣言する基本構文は以下の通りです。

データ型[] 配列名;

例えば、整数型の配列を宣言する場合は次のようになります。

int[] numbers;

この宣言により、numbersという名前の整数型の配列が作成されますが、まだ配列のサイズは決まっていません。

7.2.2 配列の初期化

配列のサイズを指定して初期化を行うには、次のようにします。

int[] numbers = new int[5];

このコードは、5個の整数を格納できる配列を作成し、その配列にnumbersという名前を付けています。配列が作成された時点で、各要素はそのデータ型のデフォルト値で初期化されます。整数型の場合、デフォルト値は0です。

7.2.3 配列の宣言と初期化を同時に行う

配列の宣言と同時に初期値を設定することもできます。

int[] numbers = {1, 2, 3, 4, 5};

この例では、numbersという名前の配列を作成し、初期値として1, 2, 3, 4, 5を代入しています。要素数は5に自動的に決まります。

7.2.4 配列の初期化方法の例

public class Main {
    public static void main(String[] args) {
        // 配列の宣言とサイズの指定
        int[] numbers = new int[3];  // 3つの要素を持つ配列
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;

        // 宣言と同時に初期化
        int[] moreNumbers = {5, 10, 15, 20};
    }
}

7.3 配列へのアクセスと操作

配列の各要素にはインデックスを使ってアクセスします。Javaの配列のインデックスは0から始まることを覚えておきましょう。

7.3.1 配列の要素にアクセスする

配列の要素にアクセスするには、次のようにインデックスを指定します。

int firstElement = numbers[0];  // 配列の最初の要素
int secondElement = numbers[1];  // 2番目の要素

7.3.2 配列の要素を変更する

配列の要素はインデックスを使って値を変更できます。

numbers[0] = 100;  // 最初の要素に新しい値を代入
numbers[2] = 300;  // 3番目の要素に新しい値を代入

7.3.3 配列の長さを取得する

配列の長さ（要素数）は.lengthプロパティを使って取得できます。

int length = numbers.length;  // 配列の要素数を取得

7.3.4 配列の全要素にアクセスする

配列の全要素にアクセスするためには、forループや拡張forループ（for-each）を使います。

// 通常のforループ
for (int i = 0; i < numbers.length; i++) {
    System.out.println("numbers[" + i + "] = " + numbers[i]);
}

// 拡張forループ
for (int num : numbers) {
    System.out.println(num);
}

7.4 配列の利便性とユースケース

配列は様々な場面で役立つ強力なデータ構造です。ここでは、配列がどのようなユースケースで使われるのか、いくつかの具体例を挙げて紹介します。

7.4.1 ユースケース1: 成績管理システム

例えば、学生の試験の成績を記録する場合、配列を使うことで複数の成績をまとめて扱うことができます。

int[] scores = {80, 90, 70, 85, 95};
int total = 0;

for (int score : scores) {
    total += score;
}

double average = (double) total / scores.length;
System.out.println("平均点: " + average);

7.4.2 ユースケース2: 数字の並べ替え

配列を使って、データを効率的に並べ替えることも可能です。Javaには、Arraysクラスのsortメソッドを使って配列を簡単にソートする機能があります。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 1, 9, 2};
        Arrays.sort(numbers);  // 配列を昇順にソート

        for (int num : numbers) {
            System.out.println(num);
        }
    }
}

ソート後の結果は次の通りです。

1
2
3
5
8
9

7.4.3 ユースケース3: 配列の逆順

配列の要素を逆順にする場合も簡単に実装できます。

int[] numbers = {1, 2, 3, 4, 5};

// 配列の逆順にする
for (int i = 0; i < numbers.length / 2; i++) {
    int temp = numbers[i];
    numbers[i] = numbers[numbers.length - 1 - i];
    numbers[numbers.length - 1 - i] = temp;
}

7.5 多次元配列

多次元配列は、配列の中にさらに配列を持つデータ構造です。最も一般的な多次元配列は二次元配列であり、行列のようにデータを整理して扱うことができます。

7.5.1 二次元配列の宣言と初期化

二次元配列を宣言する方法は、次の通りです。

int[][] matrix = new int[3][3];  // 3行3列の二次元配列

各要素には、それぞれ行と列のインデックスを使ってアクセスします。

matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;

7.5.2 二次元配列の宣言と同時に初期化する

二次元配列を宣言と同時に初期化する場合は、次のように書きます。

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

7.5.3 二次元配列のループ処理

二次元配列の要素にアクセスするには、ネストされたループを使います。

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.println("matrix[" + i + "][" + j + "] = " + matrix[i][j]);
    }
}

7.6 配列の応用

配列は、他のデータ構造やアルゴリズムの基礎にもなります。ここでは、Javaにおける配列の応用例をいくつか紹介します。

7.6.1 メソッドに配列を渡す

配列をメソッドの引数として渡すことができます。

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        printArray(numbers);
    }

    public static void printArray(int[] array) {
        for (int num : array) {
            System.out.println(num);
        }
    }
}

7.6.2 メソッドから配列を返す

メソッドから配列を返すことも可能です。

public class Main {
    public static void main(String[] args) {
        int[] numbers = createArray(5);
        for (int num : numbers) {
            System.out.println(num);
        }
    }

    public static int[] createArray(int size) {
        int[] array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = i + 1;
        }
        return array;
    }
}

7.7 Javaの配列まとめ

この章では、Javaの配列について詳しく解説しました。配列は、同じ型のデータをまとめて管理するための強力なツールであり、データの整理やアクセスを効率化することができます。さらに、多次元配列を使えば、より複雑なデータ構造も扱えるようになります。配列は、プログラムを効率よく記述するために欠かせない基本的なデータ構造です。

次章では、Javaの例外処理について学び、プログラム中で発生するエラーにどのように対処するかを詳しく説明していきます。

プログラミングをしていると、必ずといっていいほど予期しないエラーや問題が発生します。Javaでは、これらのエラーを適切に処理し、プログラムが予期せぬクラッシュを引き起こさないようにする仕組みが用意されています。それが例外処理（Exception Handling）です。

この章では、Javaの例外処理について詳しく解説します。具体的には、例外の基本概念、try-catch構文、例外の種類、throwsおよびthrowキーワード、finallyブロックの使用方法について学びます。

8.1 例外とは？

例外（Exception）とは、プログラムの実行中に発生する予期しない問題を指します。例えば、存在しないファイルを開こうとしたり、0で割り算をしようとしたりすると、プログラムが正常に動作できなくなります。このような問題が発生すると、Javaは例外をスローし、それに対処しない限りプログラムはクラッシュします。

例外処理を正しく行うことで、プログラムが予期しない問題に対して適切に対応し、クラッシュを防ぐことができます。

8.1.1 例外の発生例

次のコードでは、0で割ろうとするとArithmeticExceptionが発生します。

public class Main {
    public static void main(String[] args) {
        int result = 10 / 0;  // ここで例外が発生
        System.out.println(result);
    }
}

実行結果は次の通りです。

Exception in thread "main" java.lang.ArithmeticException: / by zero

この例では、0での除算が原因で例外が発生し、プログラムは途中でクラッシュします。このような問題に対処するために、例外処理を行います。

8.2 try-catch構文

Javaでは、例外が発生する可能性がある部分をtryブロックに書き、例外が発生した場合の処理をcatchブロックに記述します。この構文を使って例外をキャッチし、エラーに対して適切な対応を取ることができます。

8.2.1 try-catchの基本構文

try-catch構文の基本的な形は以下の通りです。

try {
    // 例外が発生する可能性のあるコード
} catch (例外クラス 変数名) {
    // 例外が発生した場合の処理
}

次の例では、0での除算をtry-catchでキャッチし、エラーが発生したときにメッセージを表示します。

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;  // 例外が発生する可能性がある部分
        } catch (ArithmeticException e) {
            System.out.println("エラー: 0で割ることはできません。");
        }
    }
}

実行結果：

エラー: 0で割ることはできません。

この例では、ArithmeticExceptionがスローされた際に、catchブロックが実行され、プログラムのクラッシュを防ぎました。

8.2.2 複数の例外をキャッチする

複数の種類の例外が発生する可能性がある場合、catchブロックを複数定義することができます。

public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[10]);  // 配列の範囲外アクセス
            int result = 10 / 0;              // 0での割り算
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("エラー: 配列のインデックスが範囲外です。");
        } catch (ArithmeticException e) {
            System.out.println("エラー: 0で割ることはできません。");
        }
    }
}

実行結果：

エラー: 配列のインデックスが範囲外です。

このように、異なる種類の例外に対して異なる対応をすることができます。

8.2.3 すべての例外をキャッチする

すべての例外をキャッチするには、Exceptionクラスをcatchブロックで指定します。Exceptionクラスは、すべての例外の親クラスです。

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (Exception e) {
            System.out.println("エラーが発生しました: " + e.getMessage());
        }
    }
}

8.3 throwsとthrowキーワード

Javaでは、メソッド内で例外が発生する可能性があることを宣言する方法として、throwsキーワードが使われます。また、プログラム内で手動で例外を発生させるには、throwキーワードを使用します。

8.3.1 throwsキーワード

throwsキーワードを使うことで、そのメソッドが例外をスローする可能性があることを明示できます。メソッドの呼び出し元で例外をキャッチしなければならないことを示すために使われます。

次の例では、divideメソッドが例外をスローする可能性があることをthrowsで宣言しています。

public class Main {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("エラー: 0で割ることはできません。");
        }
    }

    public static int divide(int a, int b) throws ArithmeticException {
        return a / b;
    }
}

8.3.2 throwキーワード

throwキーワードを使うことで、特定の条件下で例外を手動で発生させることができます。

public class Main {
    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void checkAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("年齢が18歳未満です。");
        }
        System.out.println("年齢は適切です。");
    }
}

実行結果：

年齢が18歳未満です。

8.4 finallyブロック

finallyブロックは、例外の有無にかかわらず必ず実行されるコードを記述するために使います。try-catchの後にfinallyを追加することで、ファイルのクローズやデータベース接続の解放など、必ず実行したい処理を記述できます。

8.4.1 finallyの基本構造

try-catch-finallyの基本構造は以下の通りです。

try {
    // 例外が発生する可能性があるコード
} catch (例外クラス 変数名) {
    // 例外が発生した場合の処理
} finally {
    // 常に実行される処理
}

例えば、次のコードでは、例外が発生してもファイルを閉じる処理がfinallyブロックで必ず実行されます。

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("エラー: 0で割ることはできません。");
        } finally {
            System.out.println("プログラム終了時に必ず実行される処理");
        }
    }
}

実行結果：

エラー: 0で割ることはできません。
プログラム終了時に必ず実行される処理

8.4.2 finallyの使用例

次の例では、ファイル操作において、例外が発生した場合でも必ずファイルをクローズする処理を実行しています。

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = null;
        try {
            File file = new File("sample.txt");
            scanner = new Scanner(file);
            while (scanner.hasNextLine()) {
                System.out.println(scanner.nextLine());
            }
        } catch (FileNotFoundException e) {
            System.out.println("ファイルが見つかりません。");
        } finally {
            if (scanner != null) {
                scanner.close();
                System.out.println("ファイルを閉じました。");
            }
        }
    }
}

このプログラムでは、ファイルが見つからない場合でも、finallyブロックで必ずファイルを閉じる処理が実行されます。

8.5 例外の種類

Javaには、多くの種類の例外が用意されており、これらは大きくチェック例外（Checked Exceptions）と非チェック例外（Unchecked Exceptions）に分類されます。

8.5.1 チェック例外

チェック例外は、コンパイル時にチェックされる例外です。これらの例外は、プログラムの正しい実行に必須のリソースや外部環境の操作に関連しています。たとえば、ファイル操作やネットワーク通信などがチェック例外に該当します。チェック例外が発生する可能性があるメソッドは、throwsキーワードでその例外を宣言する必要があります。

主なチェック例外:

• IOException
• SQLException
• FileNotFoundException

8.5.2 非チェック例外

非チェック例外は、コンパイル時にはチェックされない例外であり、主にプログラム内の論理エラーに関連しています。これらは実行時に発生する例外で、例えばNullPointerExceptionやArrayIndexOutOfBoundsExceptionなどがあります。

主な非チェック例外:

• NullPointerException
• ArithmeticException
• ArrayIndexOutOfBoundsException

8.6 カスタム例外の作成

Javaでは、標準の例外クラスだけでなく、独自の例外を定義することも可能です。これをカスタム例外と呼びます。カスタム例外を作成するには、Exceptionクラスを継承します。

8.6.1 カスタム例外の定義

次の例では、InvalidAgeExceptionというカスタム例外を定義しています。

public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

8.6.2 カスタム例外の使用

カスタム例外を使用して、特定の条件で例外をスローすることができます。

public class Main {
    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (InvalidAgeException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void checkAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("年齢が18歳未満です。");
        }
        System.out.println("年齢は適切です。");
    }
}

実行結果：

年齢が18歳未満です。

8.7 Javaの例外処理まとめ

この章では、Javaの例外処理について学びました。try-catch構文による例外のキャッチ方法や、throwsとthrowキーワードの使い方、finallyブロックの使用方法、そしてチェック例外と非チェック例外の違いについて解説しました。また、カスタム例外を定義し、独自のエラーハンドリングを行う方法も紹介しました。

例外処理は、堅牢で安定したプログラムを作る上で非常に重要な要素です。次章では、Javaの標準ライブラリを学び、日常的に使える便利なクラスやメソッドを探っていきます。

Javaの最大の特徴の一つが、オブジェクト指向プログラミング（OOP）です。オブジェクト指向の中心的な概念である継承（Inheritance）とポリモーフィズム（Polymorphism）は、コードの再利用性を高め、システム全体の設計をより柔軟で拡張性の高いものにします。

この章では、オブジェクト指向の要である継承とポリモーフィズムについて詳しく解説します。具体的には、次のトピックをカバーします：

• 継承の基本
• メソッドのオーバーライド
• superキーワードの使い方
• 抽象クラスとインターフェース
• ポリモーフィズムの基本とその応用

10.1 継承とは？

継承（Inheritance）とは、既存のクラスをベースにして新しいクラスを作成する仕組みです。新しいクラス（サブクラスまたは子クラス）は、既存のクラス（スーパークラスまたは親クラス）の属性（フィールド）や振る舞い（メソッド）を引き継ぎます。これにより、コードの重複を避け、より効率的にクラスを設計することができます。

10.1.1 継承の構文

継承を行うには、extendsキーワードを使います。基本構文は以下の通りです。

class サブクラス extends スーパークラス {
    // サブクラスの独自のフィールドとメソッド
}

例えば、Animalという親クラスからDogという子クラスを継承する例を見てみましょう。

// 親クラス
class Animal {
    String name;

    public void makeSound() {
        System.out.println("動物の鳴き声");
    }
}

// 子クラス
class Dog extends Animal {
    public void makeSound() {
        System.out.println("ワンワン");
    }
}

10.1.2 継承のメリット

継承のメリットは、次のような点にあります：

• コードの再利用: 一度定義したクラスを他のクラスで使い回すことができ、コードの重複を避けることができます。
• 拡張性: 親クラスの基本機能を持ちながら、新たな機能を追加することで、サブクラスに特化した動作を実装できます。
• 保守性の向上: 親クラスの変更が子クラスにも反映されるため、保守が容易になります。

10.2 メソッドのオーバーライド

継承を使うと、サブクラスはスーパークラスのメソッドをそのまま利用できますが、メソッドのオーバーライド（Override）を行うことで、親クラスで定義されたメソッドの振る舞いをサブクラスで再定義することも可能です。これにより、サブクラスは親クラスの基本機能を持ちながら、独自の振る舞いを実装できます。

10.2.1 オーバーライドの基本構文

オーバーライドを行うには、サブクラスで親クラスと同じ名前、同じ引数のメソッドを定義します。

@Override
public void メソッド名() {
    // オーバーライドされたメソッドの処理
}

例えば、AnimalクラスのmakeSound()メソッドをDogクラスでオーバーライドする例を示します。

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("ワンワン");
    }
}

10.2.2 オーバーライドのルール

オーバーライドには、いくつかの重要なルールがあります。

• メソッド名、引数、戻り値が一致すること: オーバーライドするメソッドは、親クラスと完全に一致する必要があります。
• アクセス修飾子は緩めることができる: オーバーライドするメソッドは、親クラスのメソッドと同じか、より緩やかなアクセス修飾子を定義できます。例えば、親クラスでprotectedなメソッドは、サブクラスでpublicにすることができますが、逆にprivateにはできません。
• @Overrideアノテーションの使用: オーバーライドされたメソッドに@Overrideアノテーションを付けることで、コンパイラがオーバーライドが正しく行われているかをチェックします。

次の例では、DogクラスでmakeSound()メソッドをオーバーライドし、親クラスのAnimalクラスのmakeSound()メソッドとは異なる振る舞いを実装しています。

class Animal {
    public void makeSound() {
        System.out.println("動物の鳴き声");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("ワンワン");
    }
}

10.3 superキーワード 〜親クラスへのアクセス〜

サブクラスから親クラスのメソッドやコンストラクタを呼び出す際に使用するのがsuperキーワードです。superは、サブクラス内で親クラスの要素にアクセスするための重要なキーワードです。

10.3.1 親クラスのメソッド呼び出し

サブクラスでオーバーライドされたメソッド内から親クラスの同名メソッドを呼び出すには、super.メソッド名()を使用します。これにより、サブクラスが独自の処理を追加したり、親クラスのメソッドを基にした処理を行うことができます。

class Dog extends Animal {
    @Override
    public void makeSound() {
        super.makeSound();  // 親クラスのメソッドを呼び出し
        System.out.println("ワンワン");
    }
}

この例では、DogクラスのmakeSound()メソッドでまず親クラスのAnimalのmakeSound()メソッドを呼び出し、その後に独自の処理を追加しています。

10.3.2 親クラスのコンストラクタ呼び出し

サブクラスのコンストラクタ内で、親クラスのコンストラクタを呼び出す場合にもsuperを使用します。super()を使うと、親クラスの初期化をサブクラスのコンストラクタで行えます。

class Animal {
    String name;

    // 親クラスのコンストラクタ
    public Animal(String name) {
        this.name = name;
    }
}

class Dog extends Animal {
    String breed;

    // 子クラスのコンストラクタ
    public Dog(String name, String breed) {
        super(name);  // 親クラスのコンストラクタを呼び出し
        this.breed = breed;
    }
}

この例では、Dogクラスのコンストラクタが呼び出されると、まずsuper(name)でAnimalクラスのコンストラクタが実行され、その後でDogクラスの初期化が行われます。

10.4 抽象クラスとインターフェース

Javaでは、クラスの設計をさらに柔軟にするために、抽象クラスとインターフェースが用意されています。これらは、共通のインターフェースを定義しつつ、具体的な実装を各サブクラスに委ねる仕組みです。

10.4.1 抽象クラスとは？

抽象クラス（abstract class）は、インスタンス化することができないクラスです。抽象クラスは、共通のプロパティやメソッドを定義し、詳細な実装はサブクラスに任せることを目的としています。

• 抽象メソッド: 実装が定義されていないメソッドで、サブクラスでオーバーライドして実装を提供する必要があります。

abstract class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    // 抽象メソッド
    public abstract void makeSound();

    // 具体的なメソッド
    public void sleep() {
        System.out.println(name + " は眠っています。");
    }
}

上記のAnimalクラスには、makeSound()という抽象メソッドがあり、具体的な実装はサブクラスで行います。

10.4.2 抽象クラスのサブクラス

抽象クラスを継承したサブクラスでは、抽象メソッドを必ず実装する必要があります。

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " はワンワンと鳴きます。");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " はニャーニャーと鳴きます。");
    }
}

これで、DogクラスやCatクラスでmakeSound()をそれぞれの動物に応じて実装できます。

10.4.3 インターフェースとは？

インターフェースは、抽象メソッドの集まりです。クラスがインターフェースを実装（implements）することで、インターフェースに定義されたメソッドをそのクラスで実装することが求められます。インターフェースを使うことで、異なるクラス間で共通の動作を強制的に実装させることができます。

interface Animal {
    void makeSound();  // 抽象メソッド
}

インターフェースを実装するクラスは、implementsキーワードを使います。

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("ワンワン");
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("ニャーニャー");
    }
}

インターフェースは、クラスが複数の異なるインターフェースを実装することも可能であり、Javaにおける多重継承の代替として機能します。

10.4.4 抽象クラスとインターフェースの違い

10.5 ポリモーフィズム 〜柔軟なメソッドの呼び出し〜

ポリモーフィズム（Polymorphism）は、オブジェクト指向プログラミングの重要な概念であり、同じメソッド呼び出しがオブジェクトの型によって異なる振る舞いをすることを指します。つまり、親クラスの型を使って、異なるサブクラスのオブジェクトを扱うことができ、実際のオブジェクトに応じて異なるメソッドが実行されます。

10.5.1 ポリモーフィズムの例

親クラスの型でサブクラスのオブジェクトを参照することで、ポリモーフィズムが実現できます。

class Animal {
    public void makeSound() {
        System.out.println("動物の鳴き声");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("ワンワン");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("ニャーニャー");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();  // DogをAnimal型として扱う
        Animal myCat = new Cat();  // CatをAnimal型として扱う

        myDog.makeSound();  // 実際にはDogのmakeSound()が呼び出される
        myCat.makeSound();  // 実際にはCatのmakeSound()が呼び出される
    }
}

実行結果：

ワンワン
ニャーニャー

このように、Animal型の変数myDogやmyCatは、実際にはDogやCatのインスタンスを指しており、makeSound()メソッドを呼び出すと、それぞれのクラスの実装が実行されます。

10.5.2 ポリモーフィズムのメリット

• 柔軟なコード設計: 親クラスの型で処理を行うことで、異なるサブクラスのオブジェクトを同じ処理で扱うことができます。これにより、コードの柔軟性が向上します。
• コードの簡潔化: 同じ処理を複数のサブクラスで行う際に、ポリモーフィズムを活用すると、処理を統一でき、冗長なコードを避けることができます。

10.6 Javaの継承とポリモーフィズムまとめ

この章では、Javaの継承とポリモーフィズムについて詳しく学びました。継承を利用することで、既存のクラスの機能を再利用し、新しいクラスを効率的に作成できることが理解できました。また、メソッドのオーバーライドやsuperキーワードの使い方を通して、親クラスと子クラスの関係を柔軟に扱う方法を習得しました。

さらに、抽象クラスとインターフェースの違いを理解し、ポリモーフィズムを利用して、異なるクラスのオブジェクトを同じように扱う仕組みも学びました。これにより、Javaのオブジェクト指向の真髄に触れることができ、より柔軟で拡張性の高いプログラムを設計できるようになります。

次章では、Javaにおける入出力処理を学び、ファイル操作やユーザー入力の処理方法を探っていきます。

Javaでは、ファイル操作やユーザー入力の処理が重要な役割を果たします。これらの処理は、プログラムが外部データを読み込んだり、データを保存するために不可欠です。Javaは、標準的な入出力（I/O）操作を行うために豊富なAPIを提供しており、これを利用してファイルの読み書きやコンソールからの入力を簡単に実装することができます。

この章では、Javaの入出力処理の基本から、ファイルの読み書き、ユーザー入力、バッファリングなど、さまざまなI/O操作について学びます。主に以下の内容をカバーします：

• ファイルの入出力の基本
• Fileクラスを使ったファイル操作
• Scannerクラスを使ったユーザー入力の処理
• FileReaderとBufferedReaderによるファイルの読み込み
• FileWriterとBufferedWriterによるファイルへの書き込み
• 例外処理を含むファイル操作

11.1 入出力の基本概念

入出力（I/O: Input/Output）は、プログラムが外部データとやり取りを行うための仕組みです。入力は、ユーザーや外部ファイルからデータを受け取ることを指し、出力は、ファイルにデータを書き込む、もしくは画面にデータを表示する操作を指します。

Javaでは、入出力処理を行うためにjava.ioやjava.nio.fileパッケージが提供されており、これらを使うことで簡単にI/O処理が実現できます。

11.1.1 入出力のストリーム

Javaの入出力処理は、ストリーム（Stream）という概念に基づいています。ストリームは、データの流れを表すものであり、入力ストリーム（データをプログラムに取り込む）と出力ストリーム（データをプログラムから外部に書き出す）の2種類があります。

• 入力ストリーム: データを外部からプログラムに読み込むためのもの（例：ファイルやユーザー入力）。
• 出力ストリーム: データをプログラムから外部に出力するためのもの（例：ファイルへの書き込みやコンソール出力）。

Javaでは、バイトストリーム（InputStreamやOutputStream）と文字ストリーム（ReaderやWriter）の2種類のストリームが提供されており、用途に応じて使い分けます。

11.2 Fileクラスを使ったファイル操作

Javaでファイルを扱うためには、java.io.Fileクラスを使用します。このクラスを使うことで、ファイルやディレクトリの存在確認、作成、削除、パスの取得など、基本的なファイル操作が行えます。

11.2.1 ファイルの存在確認

まず、特定のファイルが存在するかどうかを確認する方法です。Fileクラスのexists()メソッドを使って、ファイルが存在するか確認できます。

import java.io.File;

public class Main {
    public static void main(String[] args) {
        File file = new File("sample.txt");

        if (file.exists()) {
            System.out.println("ファイルは存在します。");
        } else {
            System.out.println("ファイルは存在しません。");
        }
    }
}

11.2.2 ファイルの作成

ファイルを作成するには、FileクラスのcreateNewFile()メソッドを使用します。

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        File file = new File("newfile.txt");

        try {
            if (file.createNewFile()) {
                System.out.println("ファイルが作成されました。");
            } else {
                System.out.println("ファイルはすでに存在しています。");
            }
        } catch (IOException e) {
            System.out.println("ファイル作成中にエラーが発生しました。");
        }
    }
}

11.2.3 ファイルの削除

ファイルを削除するには、delete()メソッドを使用します。

File file = new File("newfile.txt");
if (file.delete()) {
    System.out.println("ファイルが削除されました。");
} else {
    System.out.println("ファイルの削除に失敗しました。");
}

11.3 ユーザー入力の処理

Javaでは、ユーザーからの入力を受け取るために、java.util.Scannerクラスを使用します。このクラスは、標準入力（キーボード入力）やファイルからの入力を簡単に扱うことができ、文字列や数値の入力を効率的に処理します。

11.3.1 Scannerクラスを使った入力

以下は、Scannerクラスを使って、ユーザーから名前を入力して表示する例です。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);  // 標準入力を読み取るScannerオブジェクトを作成

        System.out.print("名前を入力してください: ");
        String name = scanner.nextLine();  // ユーザーからの入力を取得

        System.out.println("こんにちは、" + name + "さん！");
    }
}

11.3.2 数値入力の処理

Scannerクラスは、数値や他のデータ型も扱うことができます。nextInt()やnextDouble()などのメソッドを使って、数値を入力することが可能です。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("年齢を入力してください: ");
        int age = scanner.nextInt();  // 整数の入力を受け取る

        System.out.println("あなたは " + age + " 歳です。");
    }
}

11.4 ファイルからの読み込み

Javaでファイルからデータを読み込むには、**FileReaderとBufferedReader**を使う方法が一般的です。BufferedReaderを使うことで、ファイルからの読み込みを効率化し、ファイルの内容を一行ずつ処理することができます。

11.4.1 FileReaderとBufferedReaderによる読み込み

以下は、BufferedReaderを使ってテキストファイルを一行ずつ読み込む例です。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("sample.txt"));
            String line;
            while ((line = reader.readLine()) != null) {  // 1行ずつ読み込む
                System.out.println(line);
            }
            reader.close();  // リソースを解放
        } catch (IOException e) {
            System.out.println("ファイルの読み込み中にエラーが発生しました。");
        }
    }
}

11.4.2 ファイルの存在チェックと例外処理

ファイルが存在しない場合に、FileNotFoundExceptionやIOExceptionが発生するため、例外処理を組み込むことが重要です。上記の例では、catchブロックで例外をキャッチし、エラーが発生した場合にメッセージを表示しています。

11.5 ファイルへの書き込み

ファイルへのデータの書き込みには、**FileWriterとBufferedWriter**を使用します。BufferedWriterを使うことで、大量のデータを効率的にファイルに書き込むことが可能です。

11.5.1 FileWriterとBufferedWriterによる書き込み

以下は、BufferedWriterを使ってファイルに文字列を書き込む例です。

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
            writer.write("こんにちは、Java！");  // 文字列を書き込む
            writer.newLine();  // 改行を追加
            writer.write("ファイル操作を学びましょう。");
            writer.close();  // リソースを解放
            System.out.println("ファイルに書き込みが完了しました。");
        } catch (IOException e) {
            System.out.println("ファイルの書き込み中にエラーが発生しました。");
        }
    }
}

11.5.2 追記モードでの書き込み

FileWriterのコンストラクタにtrueを渡すことで、追記モードでファイルにデータを書き込むことができます。

BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt", true));  // 追記モード
writer.write("新しいデータを追加します。");
writer.newLine();
writer.close();

11.6 例外処理を含むファイル操作

ファイル操作では、ファイルが存在しない、読み取り権限がない、ディスクスペースが不足しているなどの問題が発生する可能性があります。これらの問題を正しく処理するために、適切な例外処理を行うことが重要です。

11.6.1 try-with-resources構文

Java 7以降では、**try-with-resources**構文を使用することで、ファイル操作時のリソース（ファイルやストリーム）の自動解放が可能です。try-with-resourcesは、AutoCloseableインターフェースを実装しているオブジェクトを自動的にクローズします。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("sample.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("ファイルの読み込み中にエラーが発生しました。");
        }
    }
}

try-with-resources構文では、tryブロックが終了すると、リソースが自動的に閉じられるため、close()メソッドを明示的に呼び出す必要がありません。

11.7 Javaの入出力処理まとめ

この章では、Javaの入出力処理について学びました。ファイルの操作やユーザー入力の処理は、多くのプログラムで必要となる基本的な機能です。Fileクラスを使ったファイルの存在確認や作成、Scannerクラスを使ったユーザー入力、FileReaderやBufferedReaderを使ったファイルの読み込み、FileWriterやBufferedWriterを使ったファイルへの書き込み、そして、例外処理を通じてエラーハンドリングを行う方法を紹介しました。

これらの基本操作を理解することで、Javaの入出力処理を効率よく実装し、ファイル操作やユーザーインタラクションを含む堅牢なプログラムを作成できるようになります。