Javaで理解！divideメソッド使い方8選

はじめに
Javaとdivideメソッドの基本
- Javaプログラムの構造
- divideメソッドの基本概念
divideメソッドの詳細な使い方
注意点と対処法
カスタマイズ方法
divideメソッドの応用例
まとめ
関連記事

はじめに

Javaで割り算を扱うときは、演算子/、自作のdivideメソッド、BigInteger.divide、BigDecimal.divideを目的に合わせて選びます。プログラム初心者がつまずきやすいのは、整数除算で小数部が切り捨てられる点、0で割るとArithmeticExceptionが起きる点、金額計算では丸め方を明示する必要がある点です。

そのため、Java基本としては小さなdivideメソッドを作り、入力チェック、例外処理、戻り値の型、精度の扱いを順に確認すると理解しやすくなります。Javaメソッド使い方の学習では、式を直接書くだけで終わらせず、処理名を付けたメソッドに分けるとコーディング入門の段階でも読み返しやすいコードになるのが基本です。

動作確認環境

Java SE 21 / OpenJDK 21
Jakarta Servlet 6.0相当のAPI表記を補足対象として扱います

📖 この記事で学べること

Javaのmainメソッドとdivideメソッドの関係
int、double、BigInteger、BigDecimalの割り算の違い
ArithmeticExceptionやNumberFormatExceptionへの対処
コマンドライン、コンソール入力、配列処理でのdivideメソッドの使い分け
画像処理、データ分析、Web処理へ広げる実装パターン

Javaとdivideメソッドの基本

結論から言えば、Javaのdivideメソッドは「割り算の意図に名前を付けた処理」として設計すると扱いやすくなります。単純な割り算ならa / bで足りますが、分母チェックや戻り値の型をそろえる処理が加わると、public static int divide(int a, int b)のように切り出す意味が出ます。

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

結果: 期待される出力は「Hello, World!」です。これはJavaプログラムの最小構成に近い例で、class、public、static、void、String[]、args、System.out.printlnの役割を確認できるのが目安です。

この形を基準にすると、Java基本の学習で出てくるメソッド呼び出しの流れが整理できます。mainは起点になり、そこから別の処理を呼び出すため、divideメソッドも同じ構造の中に置けます。

Javaプログラムの構造

一般に、Javaのコードはclassの中にfieldやmethodを置いて構成するのがポイントです。プログラム初心者は、割り算の式そのものよりも、どのクラスに処理を書き、どのメソッドから呼び出すかで迷いやすいかもしれません。

その理解を補うには、Javaの言語仕様を一次情報で確認するのが確実です。詳細な構文はJava Language Specificationにまとまっており、標準APIの挙動はJava SE 21 API Documentationで確認できます。

具体的には、コーディング入門の段階ではpublic class Mainを用意し、mainからdivideを呼ぶ形を反復すると構造をつかみやすくなります。Javaプログラミングチュートリアルとして読む場合も、式、メソッド、例外、入出力の順に広げるのが現実的です。

divideメソッドの基本概念

divideメソッドという名前は、Javaの予約語ではありません。自作メソッドとしてdivideを定義する場合もあれば、BigIntegerやBigDecimalが持つdivideを呼ぶ場合もあるのが一般的です。

public class DivideExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 2;
        int result = a / b;
        System.out.println("結果: " + result);
    }
}

結果: 期待される出力は「結果: 5」です。int同士の割り算なので、10 / 2の結果もintとしてresultに入ります。

この例ではメソッド名を付けていませんが、式の中心は割り算です。その処理に名前を付けると、Javaメソッド使い方の観点ではdivide(a, b)という呼び出しに変えられます。

ただし、整数の割り算は小数部を保持しません。たとえば10 / 4は2.5ではなく2になるため、プログラミング学習では型の違いを早い段階で確認しておくと混乱を減らせますし、ここがポイントです。

項目	主なコード	扱う型	注意点	学習上の位置付け
最小構成	`main`	`String[]`	起点の形を固定する	Java基本
整数除算	`a / b`	`int`	小数部が落ちる	コーディング入門
自作メソッド	`divide(a, b)`	`int`	分母チェックを入れる	Javaメソッド使い方
例外処理	`try` / `catch`	`ArithmeticException`	0除算を捕捉する	プログラム初心者向け
文字列変換	`Integer.parseInt`	`String`から`int`	不正入力を想定する	入力処理
コンソール入力	`Scanner`	`System.in`	入力待ちになる	対話型処理
配列処理	`double[]`	`double`	要素数を意識する	反復処理
拡張for	`for (double val : result)`	`double`	添字が不要	配列出力
任意精度整数	`BigInteger.divide`	`BigInteger`	整数として割る	大きい整数
小数精度	`BigDecimal.divide`	`BigDecimal`	丸め指定が必要	金額計算
丸め	`RoundingMode.HALF_UP`	`enum`	方針を明示する	精度管理
戻り値変更	`double`	`int`から`double`	キャストを使う	型変換
オーバーロード	`divide`	複数の引数型	引数で選ばれる	設計練習
ラムダ式	`BiFunction`	`Integer`	`apply`で呼ぶ	関数型表現
画像処理	`BufferedImage`	ピクセル値	範囲外に注意する	応用処理
ファイル読込	`ImageIO.read`	`File`	パスが必要	外部データ
平均色	`getRGB`	`int`	ビット演算を使う	画像分析
配列分割	`Arrays.copyOfRange`	`double[]`	余りに配慮する	データ分析
ストリーム平均	`Arrays.stream`	`OptionalDouble`	`orElse`を添える	集計処理
HTTP入力	`getParameter`	`String`	nullもあり得る	Web処理
Servlet出力	`PrintWriter`	HTML文字列	エスケープを考える	Webアプリ
レスポンス型	`setContentType`	`text/html`	文字コードも検討する	HTTP基礎
例外伝播	`throws`	例外型	呼び出し側で扱う	設計判断
早期終了	`return`	制御構文	後続処理を止める	入力検証
条件分岐	`if`	`boolean`	境界条件を見る	制御基礎
反復	`for`	添字	範囲を間違えない	配列操作
ビット演算	`>>` / `&`	`int`	色成分を抜き出す	応用理解
型推論なし	`BigDecimal result`	明示型	読みやすさを保つ	基本練習
外部リンク確認	`target` / `rel`	HTML属性	別タブの安全性	記事実装
関連学習	`List`や`override`	Java API	周辺知識へ広げる	プログラミング学習

divideメソッドの詳細な使い方

Javaプログラミングチュートリアルとしてdivideメソッドを追うなら、整数、大きな整数、例外処理、外部入力、配列の順で確認すると、同じ割り算でも設計が変わる理由を理解できます。一方、最初からすべての書き方を覚えようとすると、型と例外が混ざって見えやすくなります。

サンプルコード1：基本的なdivideメソッドの使用

具体的には、BigIntegerのdivideは任意精度整数の割り算を扱いるのが現実的です。通常のintで足りない大きな整数を扱う場合、Java基本の範囲を越えて標準ライブラリのクラスを使う発想が必要になります。

import java.math.BigInteger;

public class DivideMethodExample {
    public static void main(String[] args) {
        BigInteger number1 = new BigInteger("50");
        BigInteger number2 = new BigInteger("2");

        BigInteger result = number1.divide(number2);

        System.out.println("割り算の結果は: " + result);
    }
}

結果: 期待される出力は「割り算の結果は: 25」です。new BigInteger("50")とnew BigInteger("2")で値を作り、number1.divide(number2)が割り算の結果を返します。

割り算の結果は: 25

結果: これは上のプログラムで期待される出力例です。出力例を別ブロックに分けると、プログラム本体とコンソール表示の境界が分かりやすくなります。

その使い分けは、Java List型完全ガイド！初心者でもマスターできる7つのステップのようなコレクション学習にもつながりますが、これは押さえたい点です。複数の値を持つ処理では、数値型だけでなくデータの持ち方も読み解く必要があるためです。

サンプルコード2：例外処理を含むdivideメソッドの使用

ただし、割る数が0になる可能性がある場合は、正常系だけで処理を組み立てると途中で止まります。Javaでは整数を0で割るとArithmeticExceptionが発生するため、プログラム初心者の段階でもtryとcatchを一緒に練習したほうが読みやすいコードになります。

public class DivideExample {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 0;

        try {
            int result = divide(num1, num2);
            System.out.println("結果: " + result);
        } catch (ArithmeticException e) {
            System.out.println("エラー: 0で割ることはできません");
        }
    }

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

結果: 期待される出力は「エラー: 0で割ることはできません」です。num2が0なので、return a / bの時点で例外が発生し、catch側の処理に移ります。

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

結果: これは例外発生時に期待される出力例です。throws ArithmeticExceptionを付けると、呼び出し側が例外を意識しやすくなります。

この書き方は、Javaメソッド使い方の練習としても有効です。処理本体をdivideに置き、表示やエラー文言をmain側に置くことで、計算とユーザー向け出力の責務を分けられますし、これが一つの目安です。

サンプルコード3：コマンドラインからの入力を利用したdivideメソッドの使用

コマンドライン引数を使うと、ソースコードを書き換えずに割られる数と割る数を渡せます。プログラミング学習では、argsがString[]で渡される点と、数値へ変換するためにInteger.parseIntが必要になる点を押さえると理解が進みます。

public class DivideMethodExample {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("正しい数の引数を入力してください。");
            return;
        }

        try {
            int num1 = Integer.parseInt(args[0]);
            int num2 = Integer.parseInt(args[1]);

            if (num2 == 0) {
                System.out.println("0で割ることはできません。");
                return;
            }

            int result = divide(num1, num2);
            System.out.println("結果：" + result);

        } catch (NumberFormatException e) {
            System.out.println("数値を入力してください。");
        }
    }

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

結果: たとえば引数に10と2を渡した場合、期待される出力は「結果：5」です。引数が足りなければ「正しい数の引数を入力してください。」、数値へ変換できなければ「数値を入力してください。」が期待されます。

このとき、args.length、args[0]、args[1]、returnの役割を分けて読むと流れが明確になります。コーディング入門では、失敗時に早めに処理を終える書き方を覚えると、後続の条件分岐が深くなりにくいです。

サンプルコード4：コンソールからの入力を利用したdivideメソッドの使用

一方、実行時に画面から値を入力したい場合はScannerを使いると整理できます。標準入力を扱うSystem.inと、整数を読み取るnextIntを組み合わせると、Javaプログラミングチュートリアルらしい対話型の例になります。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("整数を入力してください： ");
        int number = scanner.nextInt();
        System.out.println("入力された整数は " + number + " です。");
    }
}

結果: 入力として7を与えた場合、期待される出力は「入力された整数は 7 です。」です。Scanner scanner = new Scanner(System.in)で標準入力を読み取る準備を行います。

その基本形に割り算を組み込むと、ユーザーが入力した値をdivideメソッドに渡せます。ただし、nextIntは整数以外の入力で例外が起きるため、実用寄りにするなら入力値の検証も検討すると理解できます。

import java.util.Scanner;

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

        System.out.print("割られる数を入力してください： ");
        int dividend = scanner.nextInt();

        System.out.print("割る数を入力してください： ");
        int divisor = scanner.nextInt();

        try {
            int result = divide(dividend, divisor);
            System.out.println("結果は " + result + " です。");
        } catch (ArithmeticException e) {
            System.out.println("エラー： 0で割ることはできません。");
        }
    }

    public static int divide(int dividend, int divisor) throws ArithmeticException {
        return dividend / divisor;
    }
}

結果: 入力として10と2を与えた場合、期待される出力は「結果は 5 です。」です。割る数に0を与えた場合は「エラー： 0で割ることはできません。」が期待されます。

これらの入力処理は、Javaエスケープ処理の10ステップマスターガイドで扱う文字列処理とも関係します。外部から来る値は、数値、文字列、空文字、想定外の記号を含む可能性があるため、入力境界で確認する発想が必要です。

サンプルコード5：複数の値を取り扱うdivideメソッドの使用

複数の値をまとめて割る場合は、配列を受け取るdivideメソッドにできると覚えるとよいでしょう。double[]を使うと小数を含むデータも扱えるため、Java基本から少し進んだ配列処理の練習になります。

public class DivideMultipleValues {

    /**
     * 複数の値を受け取って分割するメソッド
     * @param values 分割する値の配列
     * @param divisor 分割する数
     * @return 分割後の値の配列
     */
    public static double[] divide(double[] values, double divisor) {
        double[] result = new double[values.length];

        for (int i = 0; i < values.length; i++) {
            result[i] = values[i] / divisor;
        }

        return result;
    }
}

結果: このコード単体はメソッド定義なので、直接のコンソール出力はありません。期待される動作は、valuesの各要素をdivisorで割った新しいdouble[]を返すことです。

この実装では、入力配列を直接書き換えず、new double[values.length]で結果用の配列を作ります。そのため、元データを残したまま加工後のデータを得られる設計になります。

public class Main {
    public static void main(String[] args) {
        double[] values = {10.0, 20.0, 30.0, 40.0};

        double[] result = DivideMultipleValues.divide(values, 2.0);

        for (double val : result) {
            System.out.println(val);
        }
    }
}

結果: 期待される出力は、5.0、10.0、15.0、20.0の順です。forの拡張構文を使うことで、各要素を順番に表示できます。

5.0
10.0
15.0
20.0

結果: これは配列{10.0, 20.0, 30.0, 40.0}を2.0で割った場合の期待される出力例です。プログラミング学習では、入力配列、出力配列、表示処理を分けて読むと整理できます。

💡 Tips: divideメソッドを自作する場合、名前だけで処理内容が分かるようにし、divideValuesやdivideSafelyのように目的を加える設計も考えられますが、覚えておくと役立つでしょう。

注意点と対処法

Javaの割り算で特に押さえたいのは、0除算、型、精度の三領域です。これらはdivideメソッドの外側で確認する場合も、メソッド内部で処理する場合もあり、どこに責務を置くかでコードの読みやすさが変わります。

0での割り算と例外処理

基本的に、整数の0除算はArithmeticExceptionで扱います。プログラム初心者は、エラーを隠すのではなく、発生条件を明示してユーザーに伝える形を覚えると、後から修正しやすいコードになると考えられます。

public class DivideByZeroExample {
    public static void main(String[] args) {
        int dividend = 10;
        int divisor = 0;

        try {
            int result = dividend / divisor;
            System.out.println("結果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("エラー：0で割ることはできません。");
        }
    }
}

結果: 期待される出力は「エラー：0で割ることはできません。」です。divisorが0なので、try内の割り算で例外が起き、catchのメッセージが出力されます。

⚠️ 注意: catch (Exception e)で広く捕まえすぎると、想定していない不具合まで同じ扱いになります。割り算の0除算ならArithmeticExceptionを使うと原因が読み取りやすくなると言えるでしょう。

ただし、Web入力やファイル入力のように値の出どころが増える場合は、0除算だけでなく未入力や数値変換失敗も考慮します。Javaメソッド使い方としては、計算前に検証する設計と、例外を受けて処理する設計の両方を知っておくと対応範囲が広がります。

データ型の注意点

整数同士の割り算では、小数部が切り捨てられますし、ここを基本と考えるとよいでしょう。これはバグではなく、intの演算結果がintになるという型の規則に沿った動きです。

public class DataTypeExample {
    public static void main(String[] args) {
        int intDividend = 10;
        int intDivisor = 4;
        double doubleDividend = 10.0;
        double doubleDivisor = 4.0;

        System.out.println("int型の割り算：" + (intDividend / intDivisor));
        System.out.println("double型の割り算：" + (doubleDividend / doubleDivisor));
    }
}

結果: 期待される出力は「int型の割り算：2」と「double型の割り算：2.5」です。intDividend / intDivisorでは小数部が保持されず、doubleDividend / doubleDivisorでは小数を含む結果になります。

この違いは、コーディング入門の段階で早めに確認したい点です。たとえば割合や平均値を扱う処理では、(double) a / bのように片方をdoubleへ変換してから割るほうが意図に合う場合があります。

精度に関する注意点

小数を扱う場合、doubleは2進浮動小数点数として近似値を表するのが基本です。金額や丸めが必要な業務計算では、BigDecimalを使い、スケールと丸め方を明示するのが一般的です。

import java.math.BigDecimal;
import java.math.RoundingMode;

public class PrecisionExample {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("10.0");
        BigDecimal bd2 = new BigDecimal("3.0");

        BigDecimal result = bd1.divide(bd2, 2, RoundingMode.HALF_UP);
        System.out.println("BigDecimalを使用した割り算の結果：" + result);
    }
}

結果: 期待される出力は「BigDecimalを使用した割り算の結果：3.33」です。divide(bd2, 2, RoundingMode.HALF_UP)により、小数第2位までを半分以上切り上げの方針で丸めます。

その注意点は、公式APIのBigDecimalにも記載されています。BigDecimalのAPIドキュメントを確認すると、割り切れない除算では丸め指定が必要になるケースを把握できるのが目安です。

ℹ️ 補足: 古い例ではBigDecimal.ROUND_HALF_UPを見かける場合がありますが、現在のコードではRoundingMode.HALF_UPを使う書き方が適しています。

カスタマイズ方法

divideメソッドは、戻り値、引数、呼び出し方を変えることで用途に合わせられます。Java基本の練習ではintを返す形から始め、必要に応じてdouble、オーバーロード、ラムダ式へ広げると理解しやすくなるのがポイントです。

戻り値の型を変更する

整数の割り算でも小数を残したい場合は、戻り値をdoubleにします。このとき、計算前に片方を(double)で変換しないと、整数除算が先に行われてからdoubleへ変わるため、意図した値になりません。

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

結果: divide(10, 4)を呼び出した場合、期待される戻り値は2.5です。(double) aによって、割り算が小数を扱う演算として評価されます。

これを理解すると、プログラミング学習で出てくる平均値、割合、進捗率の処理が読みやすくなるのが一般的です。Javaでうるう年を判定！初心者でも分かる9ステップ解説のような条件分岐の題材でも、戻り値の型をどう決めるかは同じ考え方です。

関数オーバーロードを利用したカスタマイズ

同じ名前で複数の引数型を扱いたい場合は、メソッドのオーバーロードを使います。Javaではメソッド名が同じでも、引数の型や個数が違えば別のメソッドとして定義できます。

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

public static double divide(double a, double b) {
    return a / b;
}

結果: divide(10, 2)ではint版が選ばれ、期待される戻り値は5です。divide(10.0, 4.0)ではdouble版が選ばれ、期待される戻り値は2.5になるのが現実的です。

この仕組みは、Javaでマスターする！オーバーライドのたった7つのステップで扱うオーバーライドと混同されやすい領域です。オーバーロードは同じクラス内で引数違いの同名メソッドを定義する考え方で、オーバーライドは親子関係のあるクラスで振る舞いを差し替える考え方です。

ラムダ式を利用したカスタマイズ

関数として渡したい場合は、BiFunctionに割り算処理を入れる方法もあります。短い処理を変数として扱えるため、計算処理を別のメソッドに渡す場面で使えます。

BiFunction<Integer, Integer, Double> divide = (a, b) -> (double) a / b;

結果: divide.apply(10, 4)を呼び出した場合、期待される戻り値は2.5です。実際に使うファイルでは、java.util.function.BiFunctionのimportが必要になると整理できます。

ただし、プログラム初心者が最初に学ぶ形としては、通常のpublic staticメソッドのほうが追いやすいです。ラムダ式は、メソッドの分解に慣れてからJavaメソッド使い方の発展として扱うと負担が少なくなります。

💡 Tips: BiFunction<Integer, Integer, Double>では戻り値がDoubleになります。プリミティブ型のdoubleとは箱詰めの有無が違うため、大量処理では型の選択も確認すると理解できます。

divideメソッドの応用例

divideメソッドの考え方は、数値を割る処理だけでなく、画像やデータをいくつかの範囲に分ける処理にも応用できます。厳密には標準APIのdivideだけを使うわけではありませんが、分割数を決め、範囲ごとに処理する発想は同じです。

サンプルコード6：グラフィカルなアプリケーションでの利用例

画像を縦横に分けて平均色を求める処理では、幅と高さを分割数で割ります。この例ではBufferedImage、ImageIO、Fileを使い、区画ごとにgetAverageColorを呼び出すると覚えるとよいでしょう。

import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;

public class ImageDivider {
    public static void main(String[] args) {
        try {
            BufferedImage image = ImageIO.read(new File("path/to/your/image.jpg"));
            int divide = 4;
            int width = image.getWidth() / divide;
            int height = image.getHeight() / divide;

            for (int y = 0; y < divide; y++) {
                for (int x = 0; x < divide; x++) {
                    int avgColor = getAverageColor(image, x * width, y * height, width, height);
                    System.out.println("区画(" + x + ", " + y + ")の平均色: " + Integer.toHexString(avgColor));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static int getAverageColor(BufferedImage image, int x, int y, int width, int height) {
        long sumRed = 0, sumGreen = 0, sumBlue = 0;
        int pixelCount = width * height;

        for (int i = x; i < x + width; i++) {
            for (int j = y; j < y + height; j++) {
                int rgb = image.getRGB(i, j);
                sumRed += (rgb >> 16) & 0xFF;
                sumGreen += (rgb >> 8) & 0xFF;
                sumBlue += rgb & 0xFF;
            }
        }

        int avgRed = (int) (sumRed / pixelCount);
        int avgGreen = (int) (sumGreen / pixelCount);
        int avgBlue = (int) (sumBlue / pixelCount);

        return (avgRed << 16) | (avgGreen << 8) | avgBlue;
    }
}

結果: 画像ファイルが存在し、読み込みに成功した場合、期待される出力は「区画(0, 0)の平均色: …」のような16進数の行です。path/to/your/image.jpgは実際の画像パスに置き換える必要があります。

この例では、image.getWidth() / divideとimage.getHeight() / divideで区画サイズを決めます。ただし、画像サイズが分割数で割り切れない場合、端のピクセルが処理対象から外れる可能性があるため、実用化するなら余りの扱いを追加すると考えられます。

サンプルコード7：データ分析に利用する例

データ分析の入口では、配列をいくつかの範囲に分け、範囲ごとの平均値を求める処理がよく出ます。JavaではArrays.copyOfRangeとArrays.streamを組み合わせると、区間抽出と平均計算を短く書けます。

import java.util.Arrays;

public class DataAnalysis {
    public static void main(String[] args) {
        double[] data = {1.2, 3.4, 5.6, 7.8, 9.0, 2.3, 4.5, 6.7, 8.9, 10.1};
        int divide = 2;
        int segmentSize = data.length / divide;

        for (int i = 0; i < divide; i++) {
            double[] segment = Arrays.copyOfRange(data, i * segmentSize, (i + 1) * segmentSize);
            double average = Arrays.stream(segment).average().orElse(0);
            System.out.println("データセグメント" + (i + 1) + "の平均値: " + average);
        }
    }
}

結果: 期待される出力は、データセグメントごとの平均値を示す2行です。前半5個の平均は5.4、後半5個の平均は6.5になるため、その値を含む表示が期待されます。

この処理では、data.length / divideで1区画あたりの要素数を決めます。一方、データ数が分割数で割り切れない場合は余りが発生するため、プログラミング学習の発展課題として、最終区画に残りを含める処理を考えると理解が深まりますし、ここがポイントです。

関連する配列や注釈の理解を広げたい場合は、Javaアノテーションの12選！初心者から上級者まで徹底ガイドも周辺知識になります。直接の割り算ではありませんが、Javaコードを読解するための語彙を増やす助けになります。

サンプルコード8：ウェブアプリケーションでの利用例

Webアプリケーションでは、フォームから受け取った値を数値に変換し、divideメソッドで計算してレスポンスへ返す流れになると言えるでしょう。古いjavax.servlet系の例を読む機会もありますが、現行のJakarta EE系ではjakarta.servlet名前空間を使う環境が一般的です。

import java.io.IOException;
import java.io.PrintWriter;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

public class DivideServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        response.setContentType("text/html; charset=UTF-8");
        PrintWriter out = response.getWriter();

        try {
            int num1 = Integer.parseInt(request.getParameter("num1"));
            int num2 = Integer.parseInt(request.getParameter("num2"));

            int result = divide(num1, num2);
            out.println("<html><body>");
            out.println("結果: " + result);
            out.println("</body></html>");
        } catch (ArithmeticException e) {
            out.println("<html><body>");
            out.println("エラー: 0で割ることはできません");
            out.println("</body></html>");
        } catch (NumberFormatException e) {
            out.println("<html><body>");
            out.println("エラー: 数値を入力してください");
            out.println("</body></html>");
        } finally {
            out.close();
        }
    }

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

結果: num1=10、num2=2のPOSTを受け取った場合、期待されるHTML内の表示は「結果: 5」です。num2=0なら「エラー: 0で割ることはできません」、数値変換に失敗した場合は「エラー: 数値を入力してください」が期待されます。

この例では、request.getParameterが返す値をInteger.parseIntで変換しています。ただし、HTMLを文字列で直接組み立てる処理は規模が大きくなるほど保守しにくいため、実務寄りのWeb開発ではテンプレートエンジンやフレームワークの利用を検討するのが基本です。

⚠️ 注意: Web入力を扱うコードでは、数値変換だけでなくHTMLエスケープやCSRF対策なども設計対象になります。divideメソッド自体が単純でも、入力元がWebになると周辺の安全対策が増えます。

こうした応用を読むと、divideメソッドは単なる計算式ではなく、入力、検証、計算、出力の間に置かれる部品だと理解できるのが目安です。Javaプログラミングチュートリアルで基礎を固めた後は、周辺処理まで含めてコード全体を見ると、Javaメソッド使い方の理解が実装に結び付きます。

まとめ

Javaでdivideメソッドを扱うときは、どの型の値を割るのか、0除算をどこで防ぐのか、小数や丸めをどう扱うのかを先に決めると設計が安定します。演算子/だけで済む処理もありますが、入力チェックや例外処理が加わるならメソッドとして切り出す価値があるのがポイントです。

その判断は、プログラム初心者にとってJava基本を越える入口にもなります。コーディング入門ではintの割り算から始め、プログラミング学習が進んだらdouble、BigDecimal、配列、Web入力へ広げると、同じdivideメソッドでも使いどころの違いが見えてきます。

最後の確認として、割り算の処理は「入力を受け取る」「値を検証する」「計算する」「結果を返す」という流れで整理できるのが一般的です。Javaプログラミングチュートリアルとして手を動かす際は、各サンプルのmain、divide、try、catchの役割を分けて読み、必要に応じて戻り値や例外処理を調整すると学習の土台になります。