【2026年7月最新】Javaメソッド完全ガイド｜定義・呼び出し・引数・戻り値・staticまで徹底解説

この記事の内容

1. 01Javaのメソッドとは何か（関数との違い・オブジェクト指向での役割）
2. 02メソッドの定義方法（戻り値の型・メソッド名・引数の書き方）
3. 03メソッドの呼び出し方（同クラス内・別クラスから）
4. 04引数の使い方（単一・複数・可変長引数）
5. 05戻り値とreturn文の使い方
6. 06voidメソッド（戻り値なし）の使い方
7. 07オーバーロード（同名メソッドを複数定義）
8. 08staticメソッドの使い方
9. 09メソッドチェーンの活用
10. 10業務システムでのメソッド活用事例
11. 11Claude CodeでJavaメソッド設計を自動化する
12. FAQよくある質問

📚 用語解説

クラス：Javaプログラムの基本単位。データ（フィールド）と処理（メソッド）をひとまとめにした設計図のようなもの。例えば「Employee（社員）クラス」なら、名前・給与というデータと、給与計算・勤怠管理というメソッドを持つ。

📚 用語解説

インスタンス：クラス（設計図）から作られた実体のこと。例えばEmployeeクラスから「田中さん」「山田さん」という具体的な社員オブジェクトを作ることができる。この「田中さん」「山田さん」がインスタンス。

[アクセス修飾子] [static] 戻り値の型 メソッド名(引数の型 引数名, ...) {
    // 処理内容
    return 戻り値; // void の場合は不要
}

// 消費税込み価格を計算するメソッド
public static int calculateTaxIncludedPrice(int price, double taxRate) {
    int taxAmount = (int)(price * taxRate);
    return price + taxAmount;
}

📚 用語解説

アクセス修飾子：メソッドやクラスへのアクセス範囲を制限するキーワード。public（全クラスからアクセス可）、private（同クラス内のみ）、protected（同クラス+サブクラス+同パッケージ）、指定なし（同パッケージ内のみ）の4種類がある。

外部に公開するメソッドはpublic、内部でしか使わないメソッドはprivateにするのが基本原則です。「とりあえず全部public」にすると、後から変更できないメソッドが増えて設計が硬直化します。まずprivateで作り、必要に応じてpublicに変えるという発想が良い設計につながります。

// 良いメソッド名の例
public double calculateMonthlyPayroll(int employeeId) { ... }
public boolean isValidEmail(String email) { ... }
public List getOrdersByCustomerId(int customerId) { ... }
public void sendNotificationEmail(String toAddress, String subject) { ... }

// 悪いメソッド名の例（何をするか分からない）
public void process() { ... }       // 何を処理？
public int calc(int x) { ... }       // 何を計算？
public boolean check(String s) { ... } // 何をチェック？

public class TaxCalculator {
    // メソッドを定義
    public int calculateTax(int price, double taxRate) {
        return (int)(price * taxRate);
    }

    // 同じクラス内から呼び出す
    public int calculateTotalPrice(int price) {
        double taxRate = 0.1; // 消費税10%
        int tax = calculateTax(price, taxRate); // 同クラスのメソッドを呼び出し
        return price + tax;
    }
}

// 別のクラスからTaxCalculatorのメソッドを使う
public class OrderProcessor {
    public void processOrder(int itemPrice) {
        // TaxCalculatorのインスタンスを作成
        TaxCalculator calculator = new TaxCalculator();

        // インスタンス経由でメソッドを呼び出す
        int totalPrice = calculator.calculateTotalPrice(itemPrice);

        System.out.println("合計金額（税込）: " + totalPrice + "円");
    }
}

public class Main {
    public static void main(String[] args) {
        // 注文処理を開始
        OrderProcessor processor = new OrderProcessor();
        processor.processOrder(10000); // 10,000円の商品を処理

        // 出力: 合計金額（税込）: 11000円
    }
}

mainメソッドは「public static void main(String[] args)」という形式が必須です。staticがついているのは、Javaプログラムの起動時にはまだどのインスタンスも存在していないため、インスタンスなしで実行できるstaticにする必要があるからです。

📚 用語解説

引数（パラメータ）：メソッドに渡すデータのこと。メソッド定義の括弧内に「型 変数名」の形式で書く。呼び出し時に渡す値を「実引数」、定義時の変数名を「仮引数（パラメータ）」と呼び分けることもある。

// 社員IDを受け取って社員名を返すメソッド
public String getEmployeeName(int employeeId) {
    // employeeIdを使ってデータベース（を想定した処理）から名前を取得
    if (employeeId == 1001) return "田中 花子";
    if (employeeId == 1002) return "山田 次郎";
    return "不明";
}

// 呼び出し
String name = getEmployeeName(1001); // → 田中 花子

// 基本給・残業時間・単価から残業代込み給与を計算するメソッド
public int calculateSalary(int baseSalary, double overtimeHours, int overtimeRate) {
    int overtimePay = (int)(overtimeHours * overtimeRate);
    return baseSalary + overtimePay;
}

// 呼び出し（引数の順序を間違えないこと！）
int salary = calculateSalary(300000, 10.5, 2500);
// 基本給300,000円 + 残業10.5時間 × 単価2,500円 = 326,250円

Javaは型チェックが厳格です。定義で「int baseSalary, double overtimeHours」という順番なら、呼び出し時も同じ順番・同じ型で渡す必要があります。型が合わない場合はコンパイルエラーになります。引数が多い場合は、専用のクラス（DTOやValue Object）を作る設計を検討しましょう。

// 任意の数の売上金額を受け取って合計を計算するメソッド
public int calculateTotalSales(int... salesAmounts) {
    int total = 0;
    for (int amount : salesAmounts) {
        total += amount;
    }
    return total;
}

// 呼び出し（引数の数が変わっても同じメソッドで対応）
int total1 = calculateTotalSales(10000, 20000, 30000);       // 3件
int total2 = calculateTotalSales(5000, 8000, 12000, 15000);  // 4件
int total3 = calculateTotalSales(50000);                      // 1件

可変長引数は必ず引数リストの最後に1つだけ書けます。「int... amounts, String label」のように可変長引数の後に別の引数を書くことはできません。また、通常の配列（int[]）も渡せます。

// 割引後の価格を計算して返すメソッド
public double applyDiscount(int originalPrice, double discountRate) {
    if (discountRate < 0 || discountRate > 1) {
        // 不正な割引率の場合は元の価格を返す（早期return）
        return originalPrice;
    }
    double discountedPrice = originalPrice * (1 - discountRate);
    return discountedPrice; // 割引後の価格を返す
}

// 呼び出し
double price = applyDiscount(10000, 0.2); // → 8000.0（20%引き）

// 受注処理のバリデーションメソッド（早期リターンの例）
public String validateOrder(int quantity, int stock, double unitPrice) {
    // 数量チェック
    if (quantity <= 0) {
        return "エラー: 注文数量は1以上を指定してください";
    }

    // 在庫チェック
    if (quantity > stock) {
        return "エラー: 在庫不足です（在庫数: " + stock + "）";
    }

    // 単価チェック
    if (unitPrice <= 0) {
        return "エラー: 単価が不正です";
    }

    // 全チェックを通過
    return "OK";
}

「if(条件A){ if(条件B){ if(条件C){ ... }}}」のようなネストが深いコードは読みにくくなります。早期リターンを使うと条件を満たさない場合に先に返すことができ、ネストが浅くなって読みやすいコードになります。現代のJava開発では早期リターンが強く推奨されています。

📚 用語解説

void：「空・何もない」という意味のキーワード。メソッドの戻り値の型にvoidを指定すると、そのメソッドは値を返さない（return文を書かなくてよい）。ログ出力、画面表示、データ保存など「副作用」を目的とした処理に使う。

public class OrderLogger {
    // ログを記録するだけで値は返さない
    public void logOrder(int orderId, String customerName, int amount) {
        String log = "[" + java.time.LocalDateTime.now() + "] " +
                     "注文ID: " + orderId +
                     " 顧客: " + customerName +
                     " 金額: " + amount + "円";
        System.out.println(log);
        // return文は不要（書いても良いが値は書けない）
    }
}

// 呼び出し（戻り値を受け取る変数は不要）
OrderLogger logger = new OrderLogger();
logger.logOrder(1001, "田中花子", 55000);

// 受注データをデータベースに保存するメソッド（voidの例）
public void saveOrder(Order order) {
    // DBへの保存処理（失敗するとExceptionがスローされる）
    orderRepository.save(order);

    // 保存成功ならログ出力
    logOrder(order.getId(), order.getCustomerName(), order.getTotalAmount());
}

voidメソッドは値を返さないため、「処理が成功したか失敗したか」をboolean戻り値で返すことができません。代わりに、失敗時にはException（例外）をスローして呼び出し元に通知します。これがJavaの標準的なエラーハンドリングです。

📚 用語解説

オーバーロード：同じクラス内に同名のメソッドを複数定義すること。「引数の型・個数・順序」の少なくとも1つが違えばオーバーロードとして認識される。戻り値の型だけが違う場合はオーバーロードにならない（コンパイルエラー）。

public class TaxCalculator {
    // パターン1: 金額のみ（デフォルト税率10%を適用）
    public int calculateTax(int price) {
        return (int)(price * 0.1);
    }

    // パターン2: 金額と税率を指定
    public int calculateTax(int price, double taxRate) {
        return (int)(price * taxRate);
    }

    // パターン3: 金額と税種別（文字列で指定）
    public int calculateTax(int price, String taxType) {
        double rate = "reduced".equals(taxType) ? 0.08 : 0.1; // 軽減税率対応
        return (int)(price * rate);
    }
}

// 呼び出し（同じメソッド名で異なる使い方ができる）
TaxCalculator calc = new TaxCalculator();
int tax1 = calc.calculateTax(10000);           // → 1000
int tax2 = calc.calculateTax(10000, 0.08);    // → 800
int tax3 = calc.calculateTax(10000, "reduced"); // → 800

public class MathUtils {
    // staticメソッド（インスタンス不要で呼べる）
    public static int square(int n) {
        return n * n;
    }

    public static double roundToDecimalPlace(double value, int places) {
        double factor = Math.pow(10, places);
        return Math.round(value * factor) / factor;
    }
}

// 呼び出し（インスタンスを作らずクラス名で直接呼ぶ）
int sq = MathUtils.square(5);           // → 25
double rounded = MathUtils.roundToDecimalPlace(3.14159, 2); // → 3.14

// staticメソッドが向く例：汎用的なユーティリティ
public class StringUtils {
    // どのオブジェクトとも関係ない、汎用的な文字列処理
    public static String toFullWidth(String text) {
        // 半角→全角変換処理
        return text; // （実装省略）
    }

    public static boolean isNumeric(String str) {
        if (str == null || str.isEmpty()) return false;
        for (char c : str.toCharArray()) {
            if (!Character.isDigit(c)) return false;
        }
        return true;
    }
}

// インスタンスなしで使える
boolean result = StringUtils.isNumeric("12345"); // → true

「インスタンスを作らなくていいなら全部staticにしよう」と思うかもしれませんが、それは誤りです。staticにするとインスタンス変数を使えず、テストでモック（代替）に差し替えられなくなります。ユーティリティクラスの汎用的な処理にはstatic、オブジェクトの状態に依存する処理にはインスタンスメソッドを使うのが正しい設計です。

// メソッドチェーンなし（冗長な書き方）
StringBuilder sb = new StringBuilder();
sb.append("こんにちは");
sb.append("、");
sb.append("田中さん");
sb.append("！");
String message = sb.toString();

// メソッドチェーンあり（すっきりした書き方）
String message = new StringBuilder()
    .append("こんにちは")
    .append("、")
    .append("田中さん")
    .append("！")
    .toString();

// メソッドチェーンに対応した注文ビルダークラス
public class OrderBuilder {
    private int customerId;
    private String productName;
    private int quantity;
    private double discountRate;

    // 各setterが自分自身（this）を返す → チェーンができる
    public OrderBuilder setCustomerId(int id) {
        this.customerId = id;
        return this; // ポイント：自分自身を返す
    }

    public OrderBuilder setProduct(String name, int qty) {
        this.productName = name;
        this.quantity = qty;
        return this;
    }

    public OrderBuilder applyDiscount(double rate) {
        this.discountRate = rate;
        return this;
    }

    public Order build() {
        return new Order(customerId, productName, quantity, discountRate);
    }
}

// メソッドチェーンで注文を作成
Order order = new OrderBuilder()
    .setCustomerId(1001)
    .setProduct("ノートPC", 2)
    .applyDiscount(0.1)
    .build();

import java.util.List;
import java.util.stream.Collectors;

// 受注リストから特定条件の合計金額を計算する（実務でよく使うパターン）
public int calculateHighValueOrderTotal(List orders) {
    return orders.stream()
        .filter(order -> order.getStatus().equals("承認済み")) // 承認済みのみ
        .filter(order -> order.getAmount() >= 100000)          // 10万円以上
        .mapToInt(Order::getAmount)                            // 金額のみ取り出す
        .sum();                                                // 合計
}

public class PayrollCalculator {
    private static final double OVERTIME_RATE_MULTIPLIER = 1.25; // 残業割増率

    // 基本給計算
    public static int calculateBaseSalary(int monthlySalary, int workDays, int totalWorkDays) {
        return (int)((double)monthlySalary / totalWorkDays * workDays);
    }

    // 残業代計算
    public static int calculateOvertimePay(int monthlySalary, double overtimeHours) {
        int hourlyRate = monthlySalary / 160; // 月160時間基準
        return (int)(hourlyRate * OVERTIME_RATE_MULTIPLIER * overtimeHours);
    }

    // 社会保険料計算（概算）
    public static int calculateSocialInsurance(int salary) {
        return (int)(salary * 0.1495); // 健康保険 + 厚生年金の会社・個人合計の概算
    }

    // 手取り額計算（これが最終的に呼ばれるメソッド）
    public int calculateNetSalary(int monthlySalary, int workDays, double overtimeHours) {
        int totalWorkDays = 20; // 対象月の所定労働日数（仮）
        int baseSalary = calculateBaseSalary(monthlySalary, workDays, totalWorkDays);
        int overtimePay = calculateOvertimePay(monthlySalary, overtimeHours);
        int grossSalary = baseSalary + overtimePay;
        int socialInsurance = calculateSocialInsurance(grossSalary);
        return grossSalary - socialInsurance;
    }
}

// 使い方
PayrollCalculator calc = new PayrollCalculator();
int netSalary = calc.calculateNetSalary(300000, 18, 12.5);
System.out.println("手取り額: " + netSalary + "円");

public class OrderValidator {
    // 注文全体のバリデーション（複数のチェックメソッドを組み合わせる）
    public ValidationResult validateOrder(Order order) {
        if (!isValidCustomerId(order.getCustomerId())) {
            return ValidationResult.error("顧客IDが不正です");
        }
        if (!isValidQuantity(order.getQuantity())) {
            return ValidationResult.error("数量は1〜999の範囲で入力してください");
        }
        if (!hasEnoughStock(order.getProductId(), order.getQuantity())) {
            return ValidationResult.error("在庫が不足しています");
        }
        return ValidationResult.success();
    }

    private boolean isValidCustomerId(int customerId) {
        return customerId > 0 && customerId <= 999999;
    }

    private boolean isValidQuantity(int quantity) {
        return quantity >= 1 && quantity <= 999;
    }

    private boolean hasEnoughStock(int productId, int quantity) {
        int stock = getStockCount(productId); // DB照会を想定
        return stock >= quantity;
    }

    private int getStockCount(int productId) {
        // データベースから在庫数を取得（実装省略）
        return 100; // ダミーデータ
    }
}

public class SalesReportGenerator {
    // 月次売上レポートを生成するメソッド
    public String generateMonthlySalesReport(List orders, int year, int month) {
        // Stream APIのメソッドチェーンで集計
        double totalSales = orders.stream()
            .filter(o -> o.getYear() == year && o.getMonth() == month)
            .filter(o -> o.getStatus().equals("完了"))
            .mapToDouble(Order::getAmount)
            .sum();

        long orderCount = orders.stream()
            .filter(o -> o.getYear() == year && o.getMonth() == month)
            .filter(o -> o.getStatus().equals("完了"))
            .count();

        double averageOrderValue = orderCount > 0 ? totalSales / orderCount : 0;

        return formatReport(year, month, totalSales, orderCount, averageOrderValue);
    }

    // 整形処理を別メソッドに分離
    private String formatReport(int year, int month, double total, long count, double avg) {
        return String.format(
            "%d年%d月 月次売上レポート\n" +
            "========================\n" +
            "総売上: %,.0f円\n" +
            "注文件数: %d件\n" +
            "平均受注額: %,.0f円\n",
            year, month, total, count, avg
        );
    }
}

「1メソッド1責任（単一責任の原則）」というルールが実務では重要です。上記のformatReportメソッドをgenerateMonthlySalesReportから分離したように、「計算する処理」と「整形する処理」は別メソッドにする方が、後から変更しやすくなります。

# 例1: 既存メソッドのリファクタリング依頼
「以下のJavaメソッドを、単一責任の原則に従ってリファクタリングしてください。
メソッドが複数の責務を持っているため、適切に分割してください。
[既存コードを貼り付け]」

# 例2: メソッド設計の相談
「給与計算システムを設計中です。
以下の業務ルールをJavaメソッドとして実装してください。
- 基本給は月給制で日割り計算あり
- 残業代は基本時給の1.25倍
- 深夜残業（22時以降）は1.5倍
- 社会保険料は健康保険料と厚生年金を合算して計算
最適なメソッド分割と引数設計を提案してください。」

# 例3: テストコード生成
「以下のJavaメソッドに対するJUnit 5のテストコードを生成してください。
正常系・異常系・境界値のテストケースを網羅してください。
[メソッドのコードを貼り付け]」

// Before: 1つのメソッドが多すぎる責務を持っている（よくない例）
public void processMonthlyPayroll(List employees) {
    for (Employee e : employees) {
        // 給与計算
        int base = e.getMonthlySalary() * e.getWorkDays() / 20;
        int overtime = (int)(e.getOvertimeHours() * (e.getMonthlySalary() / 160) * 1.25);
        int gross = base + overtime;
        // 控除計算
        int insurance = (int)(gross * 0.1495);
        int incomeTax = (int)(gross * 0.05);
        int net = gross - insurance - incomeTax;
        // データ保存
        e.setNetSalary(net);
        payrollRepository.save(e.getId(), net, java.time.LocalDate.now());
        // メール送信
        String body = "今月の給与明細をお知らせします。手取り額: " + net + "円";
        mailService.send(e.getEmail(), "給与明細", body);
        System.out.println("処理完了: " + e.getName());
    }
}

// After: Claude Codeが提案した分割後のコード
public class PayrollService {
    private final PayrollRepository payrollRepository;
    private final MailService mailService;

    // メインフロー（協調のみ）
    public void processMonthlyPayroll(List employees) {
        for (Employee employee : employees) {
            int netSalary = calculateNetSalary(employee);
            savePayroll(employee.getId(), netSalary);
            notifyEmployee(employee, netSalary);
            logPayrollCompletion(employee.getName());
        }
    }

    // 給与計算（純粋な計算）
    private int calculateNetSalary(Employee employee) {
        int grossSalary = calculateGrossSalary(employee);
        int totalDeductions = calculateTotalDeductions(grossSalary);
        return grossSalary - totalDeductions;
    }

    private int calculateGrossSalary(Employee employee) {
        int base = calculateBaseSalary(employee.getMonthlySalary(), employee.getWorkDays());
        int overtime = calculateOvertimePay(employee.getMonthlySalary(), employee.getOvertimeHours());
        return base + overtime;
    }

    private int calculateBaseSalary(int monthlySalary, int workDays) {
        return monthlySalary * workDays / 20;
    }

    private int calculateOvertimePay(int monthlySalary, double overtimeHours) {
        int hourlyRate = monthlySalary / 160;
        return (int)(hourlyRate * 1.25 * overtimeHours);
    }

    private int calculateTotalDeductions(int grossSalary) {
        int insurance = (int)(grossSalary * 0.1495);
        int incomeTax = (int)(grossSalary * 0.05);
        return insurance + incomeTax;
    }

    // 保存（副作用のみ）
    private void savePayroll(int employeeId, int netSalary) {
        payrollRepository.save(employeeId, netSalary, java.time.LocalDate.now());
    }

    // 通知（副作用のみ）
    private void notifyEmployee(Employee employee, int netSalary) {
        String body = "今月の給与明細をお知らせします。手取り額: " + netSalary + "円";
        mailService.send(employee.getEmail(), "給与明細", body);
    }

    // ログ（副作用のみ）
    private void logPayrollCompletion(String employeeName) {
        System.out.println("給与処理完了: " + employeeName);
    }
}

NEXT STEP

この記事の内容を、あなたのビジネスで
実践してみませんか？