【Java初心者向け】引数と戻り値がスッキリわかる！基本から実践まで徹底解説

Javaの引数と戻り値の仕組み、正しく理解できていますか？
プログラミング学習で多くの人がつまずくポイントですが、実は一度概念を掴んでしまえば難しいものではありません。

この記事では、Javaにおける引数と戻り値の基本から、現場で役立つ実践的なテクニックまでを、豊富なコード例と共に解説していきます。
この記事を読み終える頃には、メソッドの仕組みが面白いほどクリアに見えてくるはずです。

この記事で学べること

• メソッドの基本的な構造
• 引数と戻り値の役割と書き方
• つまずきやすい「値渡し」の本当の意味
• コードの品質を上げる実践的なテクニック
• よくあるエラーの原因と対処法

Javaの引数と戻り値とは？

ここでは、Javaプログラミングの根幹をなす「メソッド」と、その構成要素である「引数」「戻り値」の役割について解説します。
まずは全体のイメージを掴みましょう。

• まずはメソッドの基本構造を理解しよう
• 引数（ひきすう）とは？メソッドに渡す「材料」
• 戻り値（もどりち）とは？メソッドからの「結果」

まずはメソッドの基本構造を理解しよう

メソッドとは、一連の処理をひとまとめにしたものです。

例えば、2つの数値を足し算する処理をメソッドとして定義しておけば、必要な時にいつでもその処理を呼び出せます。

メソッドの構造を、身近な自動販売機でイメージしてみましょう。

【自動販売機（メソッド）のイメージ】

あなた -------- お金（引数）を投入 --------> [ 自動販売機 ]
あなた <------- ジュース（戻り値）を受け取る --- [ (メソッド) ]

この自動販売機のように、何かを受け取って（引数）、処理を行い、何かを返す（戻り値）のがメソッドの基本的な働きです。

引数（ひきすう）とは？メソッドに渡す「材料」

引数とは、メソッドに処理をお願いする際に渡す値のことです。

自動販売機の例で言えば「お金」が引数にあたります。
「150円」という引数を渡せば、150円のジュースを買う処理が実行されます。

プログラムでは、計算させたい数値や、画面に表示させたい文字列などを引数として渡します。

戻り値（もどりち）とは？メソッドからの「結果」

戻り値とは、メソッドが処理を実行した結果として返してくる値です。

自動販売機の例では「ジュース」が戻り値です。
メソッドに処理を依頼した側（呼び出し元）は、この戻り値を受け取って、さらに別の処理に利用できます。

例えば、計算結果を画面に表示したり、別の計算に使ったりします。

Javaの引数（argument）の基本をマスターしよう

ここでは、Javaで引数を使うための具体的なコードの書き方を学びます。

メソッドを定義し、そこに引数を渡す方法をステップバイステップで見ていきましょう。
正しい文法を身に付けることが重要です。

• 引数の基本的な書き方
• 複数の引数を渡す方法
• データ型を意識しよう！引数の型宣言

引数の基本的な書き方

引数を持つメソッドは、メソッド名の後の丸括弧 `()` の中に「データ型 変数名」の形式で記述します。

メソッドを呼び出す側は、定義されたデータ型に合った値を渡す必要があります。

挨拶を表示する簡単なメソッドを例に見てみましょう。

public class Main {
    public static void main(String[] args) {
        // "田中さん" という文字列を引数として渡し、greetメソッドを呼び出す
        greet("田中さん");
    }

    // 文字列型の引数 name を受け取るgreetメソッド
    public static void greet(String name) {
        System.out.println(name + "、こんにちは！");
    }
}

実行結果

田中さん、こんにちは！

複数の引数を渡す方法

メソッドには、カンマ `,` で区切ることで複数の引数を渡せます。
例えば、2つの数値を受け取って、その合計を表示するメソッドを作ってみましょう。

public class Main {
    public static void main(String[] args) {
        // 10 と 20 という2つの数値を引数として渡す
        printSum(10, 20);
    }

    // int型の引数 num1 と num2 を受け取るprintSumメソッド
    public static void printSum(int num1, int num2) {
        int total = num1 + num2;
        System.out.println("合計は" + total + "です");
    }
}

実行結果

合計は30です

データ型を意識しよう！引数の型宣言

Javaは静的型付け言語なので、引数を定義する際には必ずデータ型を指定しなくてはなりません。
メソッドを呼び出すときも、定義された型と同じ型の値を渡す必要があります。

もし違うデータ型を渡そうとすると、コンパイルエラーが発生します。

データ型	説明	例
int	整数を扱う型	`int age = 25;`
double	小数を扱う型	`double height = 175.5;`
String	文字列を扱う型	`String name = "山田";`
boolean	真偽値（trueかfalse）を扱う型	`boolean isStudent = true;`

Javaの戻り値（return value）を使いこなそう

ここでは、メソッドの処理結果を呼び出し元に返す「戻り値」の仕組みと書き方を解説します。

戻り値を活用することで、プログラムをより部品化し、再利用性を高めることができます。

• 戻り値の基本的な書き方と`return`文
• 戻り値がない場合は`void`を使おう
• なぜ戻り値が必要なの？

戻り値の基本的な書き方と`return`文

戻り値があるメソッドを定義する場合、メソッド名の前に戻り値の「データ型」を記述します。
そして、メソッドの処理の最後に `return` 文を使って値を返します。

`return`で返す値の型は、メソッド定義時に宣言した戻り値の型と一致している必要があります。

先ほどの足し算メソッドを、結果を返すように変更してみましょう。

public class Main {
    public static void main(String[] args) {
        // addメソッドを呼び出し、戻り値を変数resultに代入する
        int result = add(100, 50);
        System.out.println("計算結果は: " + result);
    }

    // 2つのint型の引数を受け取り、int型の戻り値を返すaddメソッド
    public static int add(int a, int b) {
        int sum = a + b;
        // 計算結果のsumを呼び出し元に返す
        return sum;
    }
}

実行結果

計算結果は: 150

戻り値がない場合は`void`を使おう

メソッドによっては、特定の処理を実行するだけで、結果を返す必要がない場合があります。
例えば、画面にメッセージを表示するだけのメソッドなどです。

そのように戻り値がない場合は、戻り値の型を `void`（ヴォイド）と記述します。
`void`は「何もない」という意味です。
`void`を指定したメソッドでは、`return`文は省略できます。

public class Main {
    public static void main(String[] args) {
        // 戻り値がないメソッドの呼び出し
        showMessage("処理を開始します");
    }

    // 戻り値がない (void) showMessageメソッド
    public static void showMessage(String message) {
        System.out.println("--- " + message + " ---");
        // 戻り値がないのでreturnは不要
    }
}

なぜ戻り値が必要なの？

戻り値を使う最大のメリットは、処理の部品化です。

ある特定の計算を行うメソッドを作っておけば、その計算結果を様々な場所で使い回すことができます。

例えば、税込み価格を計算するメソッドを作ったとします。

このメソッドが税込み価格を戻り値として返してくれれば、その結果を使って合計金額を計算したり、データベースに保存したりと、柔軟にプログラムを組み立てることが可能になります。

【つまずきポイント】値渡しと参照渡しの違いを理解しよう

Javaの引数の渡し方には「値渡し」という重要なルールがあります。特に、配列やオブジェクトを引数にした際の挙動は、多くの初学者が混乱するポイントです。

ここでは、その仕組みをメモリの動きと共に解説します。

• Javaの基本は「値渡し」
• プリミティブ型の場合：元の値は変わらない
• 参照型（オブジェクト）の場合：元のオブジェクトが変更される？

Javaの基本は「値渡し」

Javaでメソッドに引数を渡すとき、その渡し方は常に値渡し（call by value）です。
これは、メソッドに渡されるのが、変数の中身そのものではなく、その値をコピーしたものである、というルールです。
このルールを理解することが、後の混乱を避けるために非常に重要になります。

プリミティブ型の場合：元の値は変わらない

まず、`int` や `double` などのプリミティブ型を引数に渡す場合を見てみましょう。
これは非常にシンプルで、値のコピーが渡されるため、メソッド内で何をしても元の変数には影響がありません。

public class Main {
    public static void main(String[] args) {
        int originalValue = 10;
        System.out.println("メソッド呼び出し前: " + originalValue); // --> 10

        // メソッドを呼び出す
        tryToChange(originalValue);

        System.out.println("メソッド呼び出し後: " + originalValue); // --> 10 (変わらない！)
    }

    public static void tryToChange(int value) {
        // メソッドの中で値を変更する
        value = 20;
        System.out.println("メソッドの中: " + value); // --> 20
    }
}

実行結果

メソッド呼び出し前: 10
メソッドの中: 20
メソッド呼び出し後: 10

`tryToChange` メソッドの中で `value` を `20` に変更しても、`main` メソッドの `originalValue` は `10` のままです。これは `originalValue` の値 `10` のコピーが渡されたからです。

参照型（オブジェクト）の場合：元のオブジェクトが変更される？

次に、配列やオブジェクトなどの参照型を引数に渡す場合です。

ここが少しややこしく見えるポイントです。

参照型の場合も渡されるのは値のコピーですが、その値とは「オブジェクトの所在地（アドレス値）」なのです。

【参照渡しのイメージ】

変数の箱 [ originalArray | アドレス値: 100番地 ] ---> [ 10 | 20 ] (実際のデータ)
                 |
               コピー
                 |
メソッドの箱 [ array       | アドレス値: 100番地 ] ---> 同じ場所を指す

コピーされたアドレス値も、元の変数と同じ場所を指しているため、メソッド内でその所在地にあるデータを変更すると、結果的に元のデータも変更されることになります。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] originalArray = {10, 20};
        System.out.println("メソッド呼び出し前: " + Arrays.toString(originalArray)); // --> [10, 20]

        // メソッドを呼び出す
        changeArray(originalArray);

        System.out.println("メソッド呼び出し後: " + Arrays.toString(originalArray)); // --> [99, 20] (変わる！)
    }

    public static void changeArray(int[] array) {
        // メソッドの中で配列の要素を変更する
        array[0] = 99;
        System.out.println("メソッドの中: " + Arrays.toString(array)); // --> [99, 20]
    }
}

実行結果

メソッド呼び出し前: [10, 20]
メソッドの中: [99, 20]
メソッド呼び出し後: [99, 20]

値渡し vs 参照渡しのような挙動の比較
プリミティブ型 (int, doubleなど)	参照型 (配列, オブジェクトなど)
値そのもののコピーが渡される	所在地（アドレス値）のコピーが渡される
メソッド内で変更しても呼び出し元に影響なし	メソッド内で要素を変更すると呼び出し元にも影響あり

Javaの引数と戻り値を使いこなすための7つの実践テクニック

基本を理解したら、次はより実践的なテクニックを身に付けていきましょう。

ここで紹介する7つのテクニックを使いこなせれば、コードの可読性や柔軟性が格段に向上し、より高度なプログラミングが可能になります。

1. 複数の値を返したいときは配列やオブジェクトを使おう
2. メソッドのオーバーロードで同じ名前のメソッドを使い分ける
3. 可変長引数（...）で任意の数の引数を受け取る
4. わかりやすい引数名・メソッド名を付ける
5. 引数がnullでないかチェックする
6. コマンドライン引数を受け取る`main`メソッドの引数
7. `final`修飾子で引数の再代入を防ぐ

複数の値を返したいときは配列やオブジェクトを使おう

Javaのメソッドは、直接的には一つの戻り値しか返せません。

しかし、配列やオブジェクトを使えば、実質的に複数の値を返すことが可能です。
例えば、合計と平均を同時に計算して返したい場合、`double`型の配列を使います。

public class Main {
    public static void main(String[] args) {
        int[] data = {10, 20, 30, 40, 50};
        double[] results = calculate(data);
        System.out.println("合計: " + results[0]);
        System.out.println("平均: " + results[1]);
    }

    // 合計と平均を計算してdouble型の配列で返すメソッド
    public static double[] calculate(int[] nums) {
        double sum = 0;
        for (int num : nums) {
            sum += num;
        }
        double avg = sum / nums.length;
        double[] resultArray = {sum, avg};
        return resultArray;
    }
}

メソッドのオーバーロードで同じ名前のメソッドを使い分ける

オーバーロードとは、同じ名前で、引数の型や数が異なるメソッドを複数定義することです。

呼び出し側は渡す引数によって、どのメソッドが実行されるかを自動的に選択させることができます。

public class Main {
    // int型2つの引数を取るaddメソッド
    public static int add(int a, int b) {
        return a + b;
    }
    // double型2つの引数を取るaddメソッド
    public static double add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        System.out.println(add(5, 10));      // int版が呼ばれる
        System.out.println(add(3.5, 2.5));   // double版が呼ばれる
    }
}

可変長引数（...）で任意の数の引数を受け取る

引数の数が決まっていない場合に便利なのが、可変長引数です。

データ型の後に `...` を付けることで、0個以上の引数を配列として受け取れます。
ただし、可変長引数は引数リストの最後に一つだけしか定義できません。

public class Main {
    public static void main(String[] args) {
        printAll("山田", "田中", "鈴木");
        printAll("佐藤");
    }

    // 任意の数のString型引数を受け取る
    public static void printAll(String... names) {
        for (String name : names) {
            System.out.print(name + " ");
        }
        System.out.println();
    }
}

わかりやすい引数名・メソッド名を付ける

技術的な話ではありませんが、これは非常に重要です。

メソッド名はその処理内容を表す動詞で始め（例：`calculateSum`）、引数名は何の値であるかが明確にわかる名詞（例：`userName`, `price`）にすることが推奨されます。
読みやすいコードは、バグの発見を容易にし、メンテナンス性を向上させます。

引数がnullでないかチェックする

特に参照型の引数を受け取る場合、その値が `null` である可能性を常に考慮する必要があります。

もし `null` の変数に対してメソッドを呼び出そうとすると、`NullPointerException` という有名なエラーが発生します。
メソッドの冒頭で `null` チェックを行うのは、堅牢なプログラムを作るための良い習慣です。

public static void printLength(String text) {
    // nullチェック
    if (text == null) {
        System.out.println("文字列がnullです。");
        return; // メソッドの処理を中断
    }
    System.out.println("文字数: " + text.length());
}

コマンドライン引数を受け取る`main`メソッドの引数

Javaプログラムを実行する際のエントリーポイントである `public static void main(String[] args)`。

この引数 `String[] args` は、プログラム実行時に外部から渡されるコマンドライン引数を受け取るためのものです。

これにより、プログラムの挙動を実行時に変更できます。

`final`修飾子で引数の再代入を防ぐ

引数に `final` を付けると、その引数に対する再代入がコンパイルエラーになります。
これにより、メソッド内で誤って引数の値を変更してしまうことを防ぎ、コードの意図を明確にできます。

この機能がどのように機能し、どのようなメリットがあるのかを、もう少し詳しく見ていきましょう。

`final` 引数の主な目的とメリット

引数に`final`を付ける最大の目的は、「この引数はメソッドの中で値を一切変更しません」というプログラマーの意思をコード上で明確に示すことです。
これにより、主に2つのメリットが生まれます。

• 予期せぬバグの防止
  メソッドの処理が長くなると、意図せず引数に別の値を代入してしまうミスが起こり得ます。`final`を付けておけば、もし再代入しようとしてもコンパイルの段階でエラーとして検知されるため、バグの発生を未然に防ぐことが可能です。


• コードの可読性向上
  コードを読む人に対して、「この変数は受け取ったときの初期値のまま使われる」という情報がはっきりと伝わります。変数の値が途中で変わる可能性を考えなくて済むため、メソッドの動作を追いやすくなり、理解の助けとなります。

`final` 引数の挙動：プリミティブ型と参照型

`final`の効果は、引数のデータ型がプリミティブ型（`int`など）か参照型（配列やオブジェクトなど）かによって、少し意味合いが異なります。

1. プリミティブ型の場合

`int`や`double`のようなプリミティブ型の場合、`final`を付けるとその変数に別の値を再代入できなくなります。

【NGコード例】

public class Calculator {
    // 引数taxRateをfinalで宣言
    public void calculatePrice(final double taxRate) {
        // taxRateに別の値を再代入しようとするとコンパイルエラーになる
        taxRate = 0.10; // ←ここでエラー！「finalローカル変数taxRateに値を割り当てることはできません」

        double price = 1000 * (1 + taxRate);
        System.out.println("価格: " + price);
    }
}

この例では、`taxRate`の値をメソッド内で変更しようとしたため、コンパイルエラーが発生します。これにより、計算の前提となる値を誤って上書きしてしまうようなミスを防げます。

2. 参照型の場合

配列やオブジェクトなどの参照型の場合、`final`が禁止するのは、その変数が「別のオブジェクト」を指すように変更することだけです。

つまり、変数が指しているオブジェクト自体の状態（中身のデータ）を変更することは可能なので、注意が必要です。

【コード例】

import java.util.Arrays;

public class ArrayProcessor {
    // 引数numbersをfinalで宣言
    public void modifyFirstElement(final int[] numbers) {
        // OK: numbersが指す配列の「中身」を変更することはできる
        if (numbers != null && numbers.length > 0) {
            numbers[0] = 99;
        }

        // NG: numbersに「別の新しい配列」を再代入することはできない
        // numbers = new int[]{100, 200}; // ←ここでコンパイルエラー！
    }
}

この例では、`final`で宣言された配列`numbers`の0番目の要素を`99`に変更することは許可されています。

しかし、`numbers`に全く別の新しい配列を代入しようとすると、コンパイルエラーになります。

Javaの引数と戻り値のよくあるエラーと解決策を学ぼう

引数や戻り値の扱いを間違えると、コンパイルエラーが発生します。
ここでは、初心者が遭遇しがちな代表的なエラーとその原因、そして具体的な解決策を見ていきましょう。
エラーメッセージを正しく読むことが、問題解決の第一歩です。

• エラー例1：「シンボルを見つけられません」
• エラー例2：「メソッド ... は、指定された型に適用できません」
• エラー例3：「到達できない文です」（return文の後ろに処理を書いた場合）

エラー例1：「シンボルを見つけられません」

これは、存在しない変数やメソッドを呼び出そうとしたときに発生します。
引数関連では、メソッドのスコープ（有効範囲）外で引数変数を使おうとした場合によく見られます。

NGコード

public class Main {
    public static void someMethod(int x) {
        System.out.println(x);
    }
    public static void main(String[] args) {
        someMethod(100);
        System.out.println(x); // エラー！ xはsomeMethodの中だけで有効
    }
}

解決策: 引数として宣言された変数は、そのメソッドの中だけでしか使えません。
メソッドの外でその値を使いたい場合は、戻り値として受け取る必要があります。

エラー例2：「メソッド ... は、指定された型に適用できません」

このエラーは、メソッドを呼び出す際に渡した引数の型や数が、メソッドの定義と一致しない場合に発生します。

NGコード

public class Main {
    public static void printNumber(int number) {
        System.out.println(number);
    }
    public static void main(String[] args) {
        // エラー！ int型を期待しているのに、String型を渡している
        printNumber("123");
    }
}

解決策: メソッド定義で指定された通りのデータ型と数の引数を渡すように修正します。

エラー例3：「到達できない文です」（return文の後ろに処理を書いた場合）

`return`文が実行されると、その時点でメソッドの処理は終了し、呼び出し元に制御が戻ります。
そのため、`return`文の後に処理を記述しても、そのコードが実行されることは絶対にありません。

NGコード

public static int add(int a, int b) {
    return a + b;
    System.out.println("計算完了！"); // エラー！ この行は実行されない
}

解決策: `return`文は、メソッドの処理の最後に記述するようにします。

まとめ：Javaの引数と戻り値を理解してプログラムの幅を広げよう

この記事では、Javaにおける引数と戻り値の基本から応用までを解説してきました。
最後に、重要なポイントを振り返りましょう。

• メソッドは処理をまとめたもので、引数で情報を受け取り、戻り値で結果を返す。
• Javaの引数は常に「値渡し」。プリミティブ型は値のコピー、参照型はアドレス値のコピーが渡される。
• 戻り値がないメソッドは`void`と定義する。
• 配列やオブジェクトを戻り値にすることで、実質的に複数の値を返すことが可能になる。
• エラーメッセージを恐れず、原因を正しく理解することが上達の鍵。

引数と戻り値を自在に使いこなせるようになると、プログラムを機能ごとに部品化できるようになり、コードの再利用性やメンテナンス性が飛躍的に向上します。

これは、オブジェクト指向プログラミングを深く理解するための重要なステップです。

今回学んだ知識を土台にして、次はクラスやオブジェクト、継承といった、より高度な概念の学習に進んでみてください。

プログラミングの世界がさらに広がっていくはずです。