Javaのメソッドとは？基本から応用まで初心者向けに徹底解説！

Javaのメソッドについて、その意味や書き方が分からず悩んでいませんか。プログラミング学習で最初にぶつかる壁の一つが、メソッドの概念かもしれません。

当記事では、Javaのメソッドの基本的な書き方から、現場で役立つ応用テクニックまで、初心者にも分かりやすく解説を進めます。コードの書き方が変われば、プログラミングはもっと楽しくなります。

この記事で学べること

• Javaにおけるメソッドの基本的な役割とメリット
• メソッドの正しい書き方と呼び出し方
• 現場で通用する質の高いメソッドを作成するコツ
• 初心者が遭遇しやすいエラーとその解決策

Javaのメソッドとは？

ここでは、Javaプログラミングの核となる「メソッド」の基本的な役割と、それを利用するメリットについて見ていきましょう。メソッドを理解すれば、プログラムの構造がずっと見やすくなります。

• メソッドはプログラムの「部品」
• なぜメソッドを使うの？3つのメリット

メソッドはプログラムの「部品」

Javaにおけるメソッドとは、特定の処理や操作を一つにまとめた「部品」のようなものです。

例えば、自動販売機でジュースを買うとき、「お金を入れる」「ボタンを押す」「商品が出てくる」「おつりを返す」といった一連の動作があります。この一連の動作を「ジュースを買う」という名前の部品にしたものがメソッドのイメージです。

プログラムの中で同じような処理が何度も出てくる場合、その都度コードを書くのは非効率ですし、間違いの原因にもなります。そこで、一連の処理をメソッドとして部品化しておくことで、必要な時にその部品を呼び出すだけで済むようになります。

なぜメソッドを使うの？3つのメリット

メソッドを活用すると、主に3つの大きなメリットが得られます。どれも質の高いプログラムを作る上で欠かせない要素です。

1. コードの再利用性が高まる
   一度作成したメソッドは、プログラム内の様々な場所から何度でも呼び出せます。同じ処理を何度も書く必要がなくなり、開発効率が向上します。


2. コードが読みやすくなる
   処理のかたまりに「calculateTotalPrice」（合計金額を計算する）のような具体的な名前を付けることで、コードの目的が明確になります。長いプログラムも、意味のあるメソッドの集まりとして構成されるため、全体像を把握しやすくなるでしょう。


3. 修正が楽になる
   仕様変更で計算方法を変える必要が出た場合、メソッド化していれば修正箇所はそのメソッド内部だけで済みます。もしメソッドを使わずに同じコードをあちこちに書いていたら、全ての箇所を漏れなく修正しなければならず、大変な作業になってしまいます。

Javaメソッドの基本的な書き方とルール

メソッドの重要性を理解したところで、次は具体的な書き方のルールを学びます。構文の各要素がどのような意味を持つのかを一つずつ分解して見ていくため、初心者の方もご安心ください。

• メソッド定義の基本構造
• メソッド名の付け方にはルールがある？

メソッド定義の基本構造

Javaのメソッドは、決まった構造に沿って記述します。この基本構造を覚えることが、メソッドを使いこなす第一歩です。

修飾子 戻り値の型 メソッド名(引数リスト) {
    // ここに実行したい処理を記述する
    return 戻り値; // 戻り値がある場合
}

それぞれの要素が何を表しているのか、図解で確認してみましょう。

[ public ]  [  String  ]  [ getMessage ]  [ (String name) ]
    |             |               |                 |
    |             |               |                 +---- (4) 引数リスト
    |             |               +----------------------- (3) メソッド名
    |             +--------------------------------------- (2) 戻り値の型
    +----------------------------------------------------- (1) 修飾子

• 修飾子
• メソッドの公開範囲などを指定します。（例: `public`, `static`）
• 戻り値の型
• メソッドが処理を終えた後に返すデータの型を指定します。（例: `int`, `String`）値を返さない場合は`void`と記述します。
• メソッド名
• どんな処理をするのか分かるような名前を付けます。
• 引数リスト
• メソッドが処理で使う情報を受け取るための変数を定義します。不要な場合は空欄にします。

メソッド名の付け方にはルールがある？

Javaのメソッド名には、慣習として「キャメルケース」という命名規則が用いられます。

キャメルケースとは、複数の単語をつなげる際に、先頭の単語は小文字で始め、それ以降の単語の先頭文字を大文字にする書き方です。らくだのこぶのように見えることから、そう呼ばれています。

• 例: `calculateSum`
• 例: `getUserName`
• 例: `printMessage`

このルールは強制ではありませんが、世界中のJava開発者が従っている共通のルールです。コードの可読性を高めるためにも、必ず守るようにしましょう。

Javaメソッドを構成する4つの重要要素を深掘り

メソッドの基本構造を形作る「戻り値」「引数」「アクセス修飾子」「static修飾子」について、それぞれの役割と使い方を詳しく解説します。これらの要素を理解することで、より柔軟なメソッド設計が可能になります。

• ① 戻り値｜処理の結果を返す
• ② 引数｜メソッドに情報を渡す
• ③ アクセス修飾子｜メソッドの公開範囲を決める
• ④ static修飾子｜インスタンス化は必要？

① 戻り値｜処理の結果を返す

戻り値とは、メソッドが処理を実行した結果として、呼び出し元に返す値のことです。`return`というキーワードを使って値を返します。

例えば、2つの数値を足し算した結果を返すメソッドは、次のように書けます。

// int型の戻り値を返すaddメソッド
public int add(int a, int b) {
    int result = a + b;
    return result; // 計算結果を返す
}

一方、処理をするだけで結果を返す必要がないメソッドもあります。画面に文字を表示するだけの処理などが該当します。その場合は、戻り値の型に`void`（何もない、という意味）を指定します。`void`型のメソッドでは`return`文は不要です。

// 戻り値がない(void)のsayHelloメソッド
public void sayHello() {
    System.out.println("こんにちは！");
}

② 引数｜メソッドに情報を渡す

引数（ひきすう）とは、メソッドを呼び出す際に、メソッド内部の処理で使ってもらうために渡す値のことです。メソッド定義の`()`の中に「型 変数名」の形式で記述します。

引数を使うことで、メソッドは外部からデータを受け取り、それを元に処理を行えるようになります。これにより、より汎用性の高い「部品」を作成できます。

public class Main {
    public static void main(String[] args) {
        // "田中" という情報を引数として渡してメソッドを呼び出す
        printProfile("田中", 25);
    }

    // 2つの引数(String型のnameとint型のage)を受け取るメソッド
    public static void printProfile(String name, int age) {
        System.out.println("名前は" + name + "です。");
        System.out.println("年齢は" + age + "歳です。");
    }
}

【実行結果】

名前は田中です。
年齢は25歳です。

③ アクセス修飾子｜メソッドの公開範囲を決める

アクセス修飾子とは、メソッドをどこから呼び出すことを許可するか、その公開範囲を制御するためのキーワードです。主に3つの種類があり、適切に設定することで、意図しない場所からメソッドが使われるのを防ぎ、プログラムの安全性を高められます。

この考え方はオブジェクト指向における「カプセル化」という重要な概念に繋がっています。

④ static修飾子｜インスタンス化は必要？

`static`修飾子は、メソッドをクラスに直接関連付けるか、それともインスタンス（オブジェクト）に関連付けるかを決定します。この違いは、メソッドの呼び出し方に大きく影響します。

• staticメソッド（クラスメソッド）
  インスタンスを生成しなくても、「クラス名.メソッド名()」の形式で直接呼び出せます。プログラム全体で共通して使う機能を実装する場合によく利用されます。`main`メソッドも`static`メソッドの一つです。


• インスタンスメソッド
  `static`が付いていない、通常のメソッドです。呼び出すには、まず`new`キーワードを使ってクラスからインスタンスを生成し、「インスタンス名.メソッド名()」の形式で呼び出す必要があります。

public class Calculator {
    // staticメソッド
    public static int add(int a, int b) {
        return a + b;
    }

    // インスタンスメソッド
    public int subtract(int a, int b) {
        return a - b;
    }

    public static void main(String[] args) {
        // staticメソッドは直接呼び出せる
        int sum = Calculator.add(10, 5);
        System.out.println("和: " + sum);

        // インスタンスメソッドはインスタンス化が必要
        Calculator calc = new Calculator();
        int difference = calc.subtract(10, 5);
        System.out.println("差: " + difference);
    }
}

【実行結果】

和: 15
差: 5

作ったJavaメソッドを呼び出して使ってみよう

メソッドは定義するだけでは意味がなく、プログラムの中から「呼び出す」ことで初めて処理が実行されます。ここでは、メソッドを呼び出すための具体的な方法を3つのパターンに分けて紹介します。

• 同じクラス内からメソッドを呼び出す
• 別のクラスからメソッドを呼び出す
• mainメソッドから呼び出す方法

同じクラス内からメソッドを呼び出す

最もシンプルなのが、同じクラス内に定義された別のメソッドから呼び出すパターンです。この場合、メソッド名を記述するだけで簡単に呼び出せます。

public class MyClass {
    public void methodA() {
        System.out.println("methodAが呼び出されました。");
        // 同じクラス内のmethodBを呼び出す
        methodB();
    }

    public void methodB() {
        System.out.println("methodBが呼び出されました。");
    }
}

別のクラスからメソッドを呼び出す

プログラムの規模が大きくなると、機能ごとにクラスを分割することが一般的です。別のクラスに定義されたメソッドを呼び出すには、まずそのクラスのインスタンス（実体）を`new`キーワードを使って生成します。

そして、「`インスタンス名.メソッド名()`」という形式で呼び出します。

// Helper.java
public class Helper {
    public void sayHello() {
        System.out.println("こんにちは、Helperクラスです。");
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        // Helperクラスのインスタンスを生成
        Helper helper = new Helper();
        // インスタンスを使ってsayHelloメソッドを呼び出す
        helper.sayHello();
    }
}

【実行結果】

こんにちは、Helperクラスです。

mainメソッドから呼び出す方法

Javaプログラムの実行は、必ず`public static void main(String[] args)`という`main`メソッドから始まります。この`main`メソッドから自作のメソッドを呼び出すことが、プログラムを動作させる基本となります。

ここで注意が必要なのは、`main`メソッドは`static`メソッドであるという点です。`static`なメソッドの中から`static`でないメソッド（インスタンスメソッド）を直接呼び出すことはできません。そのため、呼び出したいメソッドがインスタンスメソッドの場合は、必ずクラスのインスタンスを生成してから呼び出す必要があります。

public class MyApp {
    public static void main(String[] args) {
        // インスタンスを生成
        MyApp app = new MyApp();
        // インスタンス経由でメソッドを呼び出す
        app.start();
    }
    
    // インスタンスメソッド
    public void start() {
        System.out.println("アプリケーションを開始します。");
    }
}

Javaメソッドを上手に書くための7つのコツ

メソッドをただ書けるだけでなく、より品質の高い、プロフェッショナルなコードを書くための実践的なコツを7つ紹介します。これらの点を意識することで、コードの保守性や可読性が格段に向上するでしょう。

• コツ1：メソッドの役割は1つに絞る（単一責任の原則）
• コツ2：処理内容がわかる名前を付ける
• コツ3：引数はシンプルに保つ
• コツ4：コメントで処理の意図を伝える
• コツ5：「早期リターン」でネストを浅くする
• コツ6：エラーが起きる可能性を考える
• コツ7：常にリファクタリングを意識する

コツ1：メソッドの役割は1つに絞る（単一責任の原則）

1つのメソッドが担う役割は、1つだけに限定するべきです。これは「単一責任の原則」と呼ばれ、ソフトウェア設計における非常に重要な考え方の一つとなります。

例えば、「ユーザー情報をデータベースから取得して、内容を加工し、画面に表示する」という複数の処理を1つのメソッドに詰め込むと、後から修正やテストがしにくくなります。

【悪い例】

public void processUserData(int userId) {
    // 1. DBからユーザー情報を取得する処理
    // 2. 取得した情報から表示用の文字列を整形する処理
    // 3. 整形した文字列をコンソールに出力する処理
}

上記のようなメソッドは、機能ごとに適切に分割するのが理想です。

【良い例】

// DBからユーザー情報を取得するメソッド
public User findUserById(int userId) { ... }

// ユーザー情報を表示用の文字列に整形するメソッド
public String formatUserInfo(User user) { ... }

// 文字列をコンソールに出力するメソッド
public void printMessage(String message) { ... }

このように分割しておけば、各メソッドの再利用が容易になり、テストも個別に実施できるため、品質が向上します。

コツ2：処理内容がわかる名前を付ける

メソッドの名前は、その処理内容を正確に、そして簡潔に表すものでなければなりません。メソッド名を見ただけで、そのメソッドが何をするのかを推測できるのが理想です。

一般的に、メソッド名は動詞から始めることが推奨されます。

• 値を取得する: `getUserName`, `getTotalPrice`
• 値を設定する: `setUserName`, `setAddress`
• 状態を確認する(booleanを返す): `isActive`, `hasStock`
• 計算する: `calculateTax`, `sumValues`

`process`や`handle`のような曖昧な動詞は、具体的な処理が分かりにくいため、できるだけ避けたほうが良いでしょう。

コツ3：引数はシンプルに保つ

メソッドの引数は、少ないほどそのメソッドは理解しやすく、使いやすくなります。引数の数は、できれば3つ以内が望ましいです。引数が多くなると、呼び出す際に順番を間違えたり、それぞれの引数の意味が分かりにくくなったりします。

【悪い例】

// 引数が多すぎて分かりにくい
public void createUser(String name, int age, String address, String phoneNumber, String email) { ... }

引数が4つ以上になる場合は、それらのデータが関連性の高いかたまりである可能性が高いです。その場合は、関連するデータをまとめた専用のクラス（オブジェクト）を作り、それを引数として渡すことを検討しましょう。

【良い例】

// UserDataクラスで情報をまとめて渡す
public void createUser(UserData userData) { ... }

コツ4：コメントで処理の意図を伝える

コードを読めば分かるような自明なコメントは、コードのノイズになるため不要です。例えば、`i++` というコードに対して `// iを1増やす` といったコメントは意味がありません。

コメントで記述すべきなのは、コードの表面的な動作(What)ではなく、なぜそのような処理が必要なのかという背景や意図(Why)です。

// 消費税率8%で計算していた旧システムとの互換性を保つため、
// 特価商品(special item)の場合は税率を固定で8%に設定する。
if (item.isSpecial()) {
    taxRate = 0.08;
}

上記のように、ビジネスルールや技術的な制約など、コードだけでは読み取れない設計意図をコメントとして残すことで、将来の保守性が大きく向上します。

コツ5：「早期リターン」でネストを浅くする

条件分岐の`if`文が何重にも入れ子（ネスト）になっているコードは、処理の流れが追いづらく、バグの温床になりがちです。

【悪い例：ネストが深い】

public void processItem(Item item) {
    if (item != null) {
        if (item.hasStock()) {
            if (item.getPrice() > 0) {
                // ここで本来の処理を行う
                System.out.println("処理を実行します。");
            }
        }
    }
}

このような場合は、メソッドの冒頭でエラー条件や事前条件をチェックし、条件を満たさなければすぐに処理を終了させる「早期リターン（ガード節）」という手法が有効です。ネストを浅く保ち、コードをすっきりとさせられます。

【良い例：早期リターン】

public void processItem(Item item) {
    if (item == null) {
        return; // 条件を満たさないので即終了
    }
    if (!item.hasStock()) {
        return; // 条件を満たさないので即終了
    }
    if (item.getPrice() <= 0) {
        return; // 条件を満たさないので即終了
    }

    // すべてのチェックを通過した後に本来の処理を行う
    System.out.println("処理を実行します。");
}

コツ6：エラーが起きる可能性を考える

作成したメソッドが、常に正常に動作するとは限りません。例えば、ファイルを開くメソッドであればファイルが存在しないかもしれませんし、ネットワーク通信を行うメソッドであれば通信が失敗する可能性もあります。

Javaには、そうした予期せぬ事態に対処するための「例外処理」という仕組みがあります。`try-catch`構文を使って、エラーが発生する可能性のある処理を囲み、エラー発生時の代替処理を記述しておくことが重要です。

import java.io.FileReader;
import java.io.FileNotFoundException;

public void readFile(String fileName) {
    try {
        // ファイルが見つからない可能性がある処理
        FileReader reader = new FileReader(fileName);
        // ... ファイルを読み込む処理 ...
    } catch (FileNotFoundException e) {
        // エラーが発生した場合の処理
        System.err.println("エラー: " + fileName + " が見つかりません。");
        // e.printStackTrace(); // エラーの詳細を出力
    }
}

例外を無視する（`catch`ブロックを空にする）のは、問題の隠蔽につながるため、絶対に行わないようにしましょう。

コツ7：常にリファクタリングを意識する

リファクタリングとは、プログラムの外部的な振る舞いを変えずに、内部のコード構造を改善していく作業のことです。一度完成したと思ったコードでも、後から見直すと改善できる点はたくさん見つかります。

例えば、以下のような点を常に意識すると良いでしょう。

• 長すぎるメソッドを、より小さなメソッドに分割できないか？（メソッドの抽出）
• 分かりにくい変数名やメソッド名を、もっと適切な名前に変更できないか？
• 重複しているコードを、一つのメソッドにまとめられないか？

リファクタリングは、機能を追加する作業ではありません。しかし、日頃からコードを綺麗に保つ習慣を付けることで、将来の機能追加や仕様変更が容易になり、バグの少ない堅牢なシステムを構築することに繋がります。

Javaメソッドの応用テクニック3選

基本をマスターしたら、次は一歩進んだ応用テクニックに挑戦してみましょう。ここでは、より柔軟で効率的なプログラミングを可能にする3つの便利な機能を紹介します。

• ① メソッドのオーバーロード
• ② 可変長引数
• ③ 再帰メソッド

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

オーバーロードとは、同じクラス内で、メソッド名は同じでも引数の型・数・並び順が異なるメソッドを複数定義できる仕組みのことです。これにより、似たような機能を持つメソッドに別々の名前を付ける必要がなくなり、呼び出し側が引数の違いを意識するだけで使えるようになります。

public class Printer {
    // String型の引数を1つ受け取るprintメソッド
    public void print(String text) {
        System.out.println("テキスト: " + text);
    }
    
    // int型の引数を1つ受け取るprintメソッド
    public void print(int number) {
        System.out.println("数値: " + number);
    }
    
    public static void main(String[] args) {
        Printer p = new Printer();
        p.print("Java"); // 1つ目のメソッドが呼ばれる
        p.print(123);    // 2つ目のメソッドが呼ばれる
    }
}

② 可変長引数

可変長引数を使うと、メソッドに渡す引数の個数を固定せず、0個以上の任意の数の引数を受け取れるようになります。引数の型の後に「`...`」（ドット3つ）を付けて定義します。

メソッドの内部では、渡された引数は配列として扱われます。これにより、同じ型の引数をいくつも受け取るような場合に、柔軟に対応できます。

public class Calculator {
    // int型の可変長引数を受け取るsumメソッド
    public int sum(int... numbers) {
        int total = 0;
        // numbersは配列として扱える
        for (int num : numbers) {
            total += num;
        }
        return total;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.sum(1, 2));       // 引数2個
        System.out.println(calc.sum(10, 20, 30)); // 引数3個
        System.out.println(calc.sum());           // 引数0個
    }
}

③ 再帰メソッド

再帰メソッドとは、メソッドの処理内容の中で、自分自身のメソッドを呼び出す処理を含むメソッドのことです。特定の条件を満たすまで自分自身を呼び出し続けることで、反復処理を実現します。

階乗の計算や、ディレクトリ構造の探索など、特定のアルゴリズムをシンプルに記述できる場合があります。ただし、必ず処理を終了させるための条件（終了条件）を記述しないと、無限ループに陥ってしまうため注意が必要です。

public class Factorial {
    // nの階乗を計算する再帰メソッド
    public int calculate(int n) {
        // 終了条件: nが1以下になったら1を返す
        if (n <= 1) {
            return 1;
        }
        // 再帰呼び出し: n * (n-1)の階乗
        return n * calculate(n - 1);
    }
}

初心者がつまずきやすいJavaメソッドのエラーと解決策

プログラミング学習中にエラーはつきものです。ここでは、Javaのメソッドを扱う上で初心者が特に遭遇しやすい代表的なコンパイルエラーと、その原因および解決策について解説します。

• `cannot find symbol`：メソッドが見つからない
• `non-static method ...`：staticメソッドからの呼び出しエラー
• 引数の型や数が合わないエラー

`cannot find symbol`：メソッドが見つからない

このエラーは、コンパイラが指定された名前のメソッドを見つけられない時に発生します。原因は非常にシンプルで、多くはタイプミスです。

• 原因: メソッド名のスペルミス。大文字と小文字の間違い。
• 解決策: 呼び出しているメソッド名と、定義しているメソッド名が完全に一致しているかを、一文字ずつ丁寧に見直しましょう。

`non-static method ...`：staticメソッドからの呼び出しエラー

正式なエラーメッセージは `non-static method [メソッド名] cannot be referenced from a static context` です。これは、`static`な`main`メソッドなどから、`static`でないインスタンスメソッドを直接呼び出そうとした場合に発生します。

• 原因: インスタンスを生成せずに、インスタンスメソッドを呼び出そうとしている。
• 解決策: `new`キーワードを使ってクラスのインスタンスを生成し、そのインスタンスを通じてメソッドを呼び出しましょう。

引数の型や数が合わないエラー

メソッドを呼び出す際に、メソッド定義で指定された引数の「データ型」や「個数」が異なっていると、コンパイルエラーになります。

• 原因: `int`型を期待している引数に`String`型の値を渡している、引数が2つ必要なのに1つしか渡していない、など。
• 解決策: メソッドの定義部分（シグネチャ）をもう一度確認し、呼び出し時に渡している値が、型・数ともに正しいかを確認します。

Javaメソッドの学習を加速させるおすすめ情報源

メソッドの概念をより深く理解し、Javaのスキルをさらに向上させるために役立つ学習リソースを紹介します。書籍や公式サイトをうまく活用して、効率的に学習を進めましょう。

独学でJavaを学ぶなら、定評のある入門書を手元に置いておくのがおすすめです。中でも、中山清喬さんの著書『スッキリわかるJava入門』は、初心者がつまずきやすいポイントを丁寧に解説しており、多くのプログラミングスクールでも教科書として採用されている一冊です。

また、最も正確で信頼できる情報は、Javaの開発元であるOracleが提供する公式ドキュメントです。英語ですが、Javaチュートリアルは情報が豊富で、リファレンスとして非常に役立ちます。

より実践的なスキルを身に付けたい中級者以上の方には、Javaの生みの親の一人であるジョシュア・ブロック氏による名著『Effective Java 第3版』がおすすめです。より良いコードを書くためのプラクティスが詰まっています。

まとめ

Javaのメソッドについて、その基本的な概念から実用的な書き方のコツ、応用テクニックまで幅広く解説しました。

押さえておきたい要点は以下の通りです。

• メソッドは処理をまとめた「部品」であり、コードの再利用性や可読性を高める
• 「修飾子 戻り値の型 メソッド名(引数)」という基本構造を覚えることが重要
• 質の高いメソッドを書くには、命名規則や単一責任の原則などを意識する

メソッドを自在に使いこなせるようになると、プログラムの見通しが良くなり、より複雑な機能も実装できるようになります。メソッドはオブジェクト指向プログラミングを理解する上での基礎となりますので、ぜひ何度もコードを書いて練習してみてください。