カテゴリー: システム開発

「ログイン機能ってどこから作ればいい？」「セッション管理って具体的に何をするの？」「パスワードはそのままDBに保存したらダメなの？」

Java の Servlet/JSP を一通り学んだあと、多くの人がぶつかる壁がこの「認証・セッション管理」です。概念はなんとなくわかっても、実際にコードに落とし込もうとすると途端に手が止まる…そんな経験、ありませんか？

この記事では、Java研修のプロジェクト型演習で実際に使用しているログイン・ユーザー管理システムのソースコードを全公開します。前回紹介した汎用DAO（BaseDAO / UserDAO）をベースに、セットアップ手順・セキュリティ設計・よくあるエラーの対処法まで、実践的な内容を丸ごとまとめました。

読み終える頃には「ログイン機能の全体像」と「現場で使えるセキュリティの基本」が身についているはずです！

目次

1. このシステムでできること
2. ファイル構成と各ファイルの役割
3. セットアップ手順（4ステップ）
4. URL設計：どのURLが何をするか
5. セキュリティ設計の5つのポイント
6. 実践コードサンプル集
7. よくあるエラーと対処法
8. まとめ

このシステムでできること

今回作成したシステムは、Webアプリ開発で必ずといっていいほど必要になる「認証付きユーザー管理」の基本形です。

このシステムには管理者（admin）と一般ユーザー（user）の2種類のロールがあり、loginUser.isAdmin() で権限チェックができます。演習のテーマに合わせてロール別の表示切り替えや機能制限に応用できます。

ファイル構成と各ファイルの役割

全19ファイルで構成されています。レイヤー別に整理すると、役割がひと目でわかります。

プロジェクト/
├── sql/
│   └── users_with_auth.sql      ← テーブル作成＋サンプルデータ
│
├── src/
│   ├── dao/
│   │   ├── BaseDAO.java         ← 汎用DB処理（変更不要）
│   │   └── UserDAO.java         ← 認証メソッド追加版
│   ├── dto/
│   │   └── UserDTO.java         ← password・role フィールド追加版
│   ├── filter/
│   │   └── AuthFilter.java      ← /user/* を一括でセッションチェック
│   ├── servlet/
│   │   ├── LoginServlet.java    ← GET:画面表示 / POST:認証処理
│   │   ├── LogoutServlet.java   ← セッション破棄→リダイレクト
│   │   ├── UserListServlet.java ← 一覧取得・名前検索
│   │   ├── UserCreateServlet.java  ← バリデーション付き登録
│   │   ├── UserEditServlet.java    ← パスワード有無で更新を切り替え
│   │   └── UserDeleteServlet.java  ← 自分自身の削除防止付き
│   └── util/
│       └── PasswordUtil.java    ← SHA-256ハッシュ化・照合
│
└── WebContent/
    ├── index.jsp                ← ルート(/)→ログイン画面へ転送
    ├── WEB-INF/web.xml          ← セッションタイムアウト設定
    └── jsp/
        ├── login.jsp            ← ログイン画面（CSS込み）
        ├── common/header.jsp    ← ナビバー・フラッシュメッセージ共通
        └── user/
            ├── list.jsp         ← 一覧＋検索・操作ボタン
            ├── form.jsp         ← 登録・編集の共通フォーム
            └── delete_confirm.jsp ← 削除確認画面

構造のポイントは「レイヤーを分けている」こと。Servlet は処理の司令塔として動き、DB操作は DAO に、データ保持は DTO に、セキュリティチェックは Filter に委ねる設計です。役割が明確なので、チーム開発でも担当を分担しやすくなります。

セットアップ手順（4ステップ）

ファイルを配置したあと、以下の4ステップで動かせます。

Step 1｜DBのセットアップ

提供している SQL ファイルをそのまま実行するだけです。テーブル作成とサンプルデータの投入が一括で完了します。

mysql -u root -p < sql/users_with_auth.sql

実行後、以下の5件のサンプルユーザーが作成されます（パスワードはすべて password123）。

Step 2｜BaseDAO.java の接続情報を変更

以下の3か所を自分の環境に合わせて変更します。

private static final String URL =
    "jdbc:mysql://localhost:3306/your_database" // ← DB名
    + "?useSSL=false&characterEncoding=UTF-8&serverTimezone=Asia/Tokyo";

private static final String USER     = "your_user";     // ← ユーザー名
private static final String PASSWORD = "your_password"; // ← パスワード

Step 3｜JDBCドライバを配置

WEB-INF/lib/mysql-connector-j-8.x.x.jar

Step 4｜Tomcat にデプロイして起動

ブラウザで http://localhost:8080/アプリ名/ を開くと、自動的にログイン画面へ転送されます。

URL設計：どのURLが何をするか

URL の設計はシステム全体の「地図」です。誰がどのURLにアクセスしたときに何が起きるかを把握しておくことが、開発・デバッグ両方で重要になります。

黄色の行（/user/*）は AuthFilter が自動でセッションチェックします。未ログインでアクセスしようとすると、自動的にログイン画面へリダイレクトされます。

セキュリティ設計の5つのポイント

「動けばいい」から卒業して「現場で使えるコード」にするために、今回は5つのセキュリティ対策を実装しています。

① パスワードは必ずハッシュ化してDBに保存する

パスワードを平文（そのままの文字列）でDBに保存するのは絶対にNGです。DBが万一流出した場合にパスワードが丸見えになってしまいます。今回は SHA-256 でハッシュ化してから保存しています。

// 登録時：平文をハッシュ化してDBに保存
String hashed = PasswordUtil.hash("password123");
// → "ef92b778bafe771e89245b89ecbc08..."（64文字の不可逆な文字列）

// ログイン時：入力値を同じようにハッシュ化して比較
UserDTO user = dao.authenticate(email, plainPassword);
// authenticate() の内部で PasswordUtil.matches() が照合を行う

ハッシュ化は一方向の変換なので、ハッシュ値から元のパスワードを復元することはできません。これがパスワード保護の基本です。

② セッション固定化攻撃への対策

ログイン前から存在するセッションIDをそのまま使い続けると「セッション固定化攻撃」という脆弱性につながります。ログイン成功時に旧セッションを破棄してから新しいセッションを発行することで防ぎます。

// ✅ 正しい実装：旧セッションを無効化してから新規生成
HttpSession oldSession = request.getSession(false);
if (oldSession != null) oldSession.invalidate(); // ← ここが重要！

HttpSession newSession = request.getSession(true);
newSession.setAttribute(AuthFilter.SESSION_KEY, user);
newSession.setMaxInactiveInterval(30 * 60); // 30分でタイムアウト

③ AuthFilter で /user/* を一括保護する

Servlet ごとに「ログインしているか？」をチェックするのは面倒なうえにチェック漏れが起きやすいです。Filter を使えばアノテーション1行で /user/ 以下の全 URL を一括保護できます。

@WebFilter("/user/*")    // ← この1行だけで /user/ 以下すべてに適用
public class AuthFilter implements Filter {

    @Override
    public void doFilter(...) {
        HttpSession session   = req.getSession(false);
        boolean    isLoggedIn = (session != null)
                             && (session.getAttribute(SESSION_KEY) != null);

        if (isLoggedIn) {
            chain.doFilter(request, response); // 通過
        } else {
            res.sendRedirect(contextPath + "/login"); // ログイン画面へ
        }
    }
}

④ エラーメッセージはあえて曖昧にする

「パスワードが違います」という親切なメッセージは、攻撃者にとって「このメールアドレスは登録済みだ」という情報を与えてしまいます。

// ❌ NG：どちらが間違いかを伝えてしまう
request.setAttribute("errorMsg", "パスワードが違います");

// ✅ OK：どちらが間違いか教えない
request.setAttribute("errorMsg",
    "メールアドレスまたはパスワードが正しくありません");

⑤ 自分自身の削除を防止する

管理者が誤って自分自身のアカウントを削除すると、管理者がいなくなるという致命的な問題が起きます。削除処理の GET・POST 両方で二重チェックしています。

// ログインユーザーと削除対象が同じIDなら処理しない
if (loginUser != null && loginUser.getId() == id) {
    session.setAttribute("flashMsg", "自分自身は削除できません");
    response.sendRedirect(contextPath + "/user/list");
    return; // ← 処理を中断
}

実践コードサンプル集

Servlet や他のクラスから使うときの典型的なパターンをまとめます。

ユーザーをプログラムから登録する

UserDAO dao = UserDAO.getInstance();

UserDTO newUser = new UserDTO(
    "山田 花子",
    "yamada.hanako@example.com",
    PasswordUtil.hash("securePass!"),  // ← 必ずハッシュ化してから渡す
    28,
    "user"
);

boolean success = dao.insert(newUser);
if (success) {
    System.out.println("登録完了！");
}

ログイン認証を手動で行う

UserDAO dao  = UserDAO.getInstance();
UserDTO user = dao.authenticate("admin@example.com", "password123");

if (user != null) {
    System.out.println("認証成功: " + user.getName()); // → 管理者
    System.out.println("管理者？: " + user.isAdmin()); // → true
} else {
    System.out.println("認証失敗（メールまたはパスワードが違う）");
}

セッションからログインユーザーを取得する

// Servlet や JSP 内で使う基本パターン
HttpSession session   = request.getSession(false);
UserDTO     loginUser = (UserDTO) session.getAttribute(AuthFilter.SESSION_KEY);

if (loginUser != null) {
    System.out.println(loginUser.getName()); // ログイン中のユーザー名

    if (loginUser.isAdmin()) {
        // 管理者にだけ見せる処理・ボタンなどをここに書く
    }
}

パスワードなしで更新する（名前・年齢だけ変える場合）

UserDAO dao  = UserDAO.getInstance();
UserDTO user = dao.findById(2);

user.setName("田中 次郎");
user.setAge(26);

dao.update(user); // パスワードはDBの現在値をそのまま維持

パスワードも含めて更新する

UserDAO dao  = UserDAO.getInstance();
UserDTO user = dao.findById(2);

user.setName("田中 次郎");
user.setPassword(PasswordUtil.hash("newPassword!")); // ← ハッシュ化を忘れずに

dao.updateWithPassword(user); // パスワードも一緒に更新

よくあるエラーと対処法

演習中にハマりやすいエラーを5つ厳選しました。

まとめ

今回は、Java Servlet/JSP で作るログイン・ユーザー管理システムの使い方を全公開しました。

• セットアップは SQL実行 → 接続情報変更 → JARファイル配置 → 起動の4ステップ
• URL設計は /user/* を AuthFilter が一括保護。未ログインはすべてログイン画面へ
• セキュリティ対策として①パスワードのSHA-256ハッシュ化 ②セッション固定化攻撃対策 ③Filter による一括アクセス制御 ④エラーメッセージの曖昧化 ⑤自分自身の削除防止 を実装
• コードサンプルでDAO・PasswordUtil・セッションの実践的な使い方を確認

このシステムは「そのまま演習で使える」レベルの実装ですが、さらに発展させるなら管理者専用画面の追加・ロール別の機能制限・ログイン履歴の記録などに挑戦してみてください。

セキュリティは「動くから大丈夫」ではなく、「なぜこの実装が必要か」を理解して書くことが大切です。今回紹介した5つの対策は、現場でも求められる基本中の基本。ぜひ自分の言葉で説明できるようになるまで、コードを読み込んでみてください！

次のステップも一緒に頑張りましょう！💪

「チームで開発ってどこから始めればいいの？」「役割分担が曖昧でいつも後半バタバタする…」

そんな悩み、すごくよくわかります。プログラミングを一通り学んだあと、いざチーム開発となると「個人学習との違い」に戸惑う人が続出するんです。実はこれ、現場の新人エンジニアにも共通する”あるある”な壁。

今回は、1チーム5名・10日間・テーマ「みんなの役に立つWebシステム」というプロジェクト型演習を例に、ステップバイステップの進め方とつまずきやすいポイント＆対策をまるっとまとめました。

この記事を読めば、演習をスムーズに進めるための全体像と実践的なコツが身につきます。チームリーダーになる人も、メンバーとして参加する人も、ぜひ最後まで読んでみてください！

目次

1. 前提知識：演習に入る前に確認しておこう
2. 10日間の全体スケジュール概要
3. STEP 1｜Day1〜2：チーム結成 & 要件定義
4. STEP 2｜Day3〜4：設計フェーズ（UML・DB・画面設計）
5. STEP 3｜Day5〜7：実装フェーズ（Java Servlet × DB連携）
6. STEP 4｜Day8〜9：テスト & デバッグ
7. STEP 5｜Day10：最終発表 & 振り返り
8. よくあるつまずきポイントと対策
9. まとめ

前提知識：演習に入る前に確認しておこう

この演習は「プログラミング学習の集大成」として位置づけられています。スムーズに進めるには、以下の知識が身についていることが前提です。

• Java言語の基礎（クラス・継承・例外処理など）
• Webの仕組み（HTTP、リクエスト／レスポンス、HTML/CSS）
• Java Servlet / JSP（MVCの概念、フォーム送受信）
• データベース基礎（MySQL、基本的なSQL：SELECT・INSERT・UPDATE・DELETE）
• JDBCによるDB接続（Javaからのデータベース操作）
• UMLの基礎（ユースケース図・クラス図・シーケンス図の読み書き）

「全部完璧！」でなくてもOK。ただ、「全然わからない」状態だと演習中に手が止まりやすいので、不安な分野は事前に復習しておくと安心です。

10日間の全体スケジュール概要

STEP 1｜Day1〜2：チーム結成 & 要件定義

🎯 このフェーズのゴール

「何を作るか」と「誰がどの役割を担うか」をチーム全員で合意すること。

具体的な手順

1. 役割分担を決める：プロジェクトリーダー（PM）、DB担当、フロントエンド担当、バックエンド担当、テスト担当などを決める。5名なら1人が複数役割を兼務することも自然。
2. テーマをブレインストーミング：「みんなの役に立つWebシステム」というテーマで、アイデアを出し合う。例：図書管理システム、タスク管理ツール、食堂メニュー掲示システムなど。
3. ターゲットユーザーを決める：「誰のために」を明確にすることで、機能の優先度が決めやすくなる。
4. ユーザストーリーを書く：「○○として、△△したい、なぜなら□□だから」という形式でユーザの要求を洗い出す。
5. 要件定義書にまとめる：機能一覧、画面一覧、制約条件（使用技術、対応ブラウザなど）を文書化する。

⚠️ ここでよくあるつまずき

「機能が多すぎて10日間では終わらない」問題が頻発します。機能を考えるのは楽しいですが、「MVP（Minimum Viable Product）思考」で”最小限でも動くもの”を優先しましょう。最初から盛り込みすぎると後半で必ず詰まります。

STEP 2｜Day3〜4：設計フェーズ（UML・DB・画面設計）

🎯 このフェーズのゴール

実装前に「設計図」を描き、チーム全員が同じイメージを持った状態にすること。

具体的な手順

1. ユースケース図を作成：アクター（ユーザ）がシステムに対して何をするかを図示。全員で確認することで「認識のズレ」をこの段階で解消できる。
2. クラス図を作成：データの構造と関係性を定義。JavaのクラスやDBテーブルの設計につながる。
3. ER図（テーブル設計）を作成：エンティティ（テーブル）と関連（リレーション）を設計。主キー・外部キー・データ型も明記する。
4. 画面遷移図を作成：どの画面からどの画面に遷移するかを図で示す。URLも一緒に設計しておくとServletのマッピングがスムーズ。
5. シーケンス図を作成（できれば）：ブラウザ→Servlet→DB→Servletという一連の処理フローを可視化する。実装時の道標になる。

⚠️ ここでよくあるつまずき

「設計が雑なまま実装に進んでしまう」パターンが一番多いです。「早く作りたい！」という気持ちはわかりますが、後から設計変更をすると手戻りが膨大になります。設計に時間をかけるのは”遠回り”ではなく”近道”です。

STEP 3｜Day5〜7：実装フェーズ（Java Servlet × DB連携）

🎯 このフェーズのゴール

設計書に基づいて動くシステムを構築すること。

具体的な手順

1. 開発環境を統一する：Eclipse（またはIntelliJ IDEA）、Tomcat、MySQLのバージョンを全員で揃える。「自分のPCでは動く」問題を防ぐために最初が肝心。
2. DBを先に作る：ER図をもとにMySQLでテーブルを作成。CREATE TABLE文はチームで共有・管理する。
3. 共通部品から実装する：DB接続クラス（DBUtil）、セッション管理など、全員が使う共通クラスを先に作ると後の作業が楽になる。
4. Servletを機能単位で実装：1Servlet = 1機能を基本に、doGet / doPost を使い分ける。設計のシーケンス図が道標になる。
5. JSPで画面を作成：EL式・JSTLを活用してServletから受け取ったデータを表示する。デザインはシンプルでOK。まず動かすことを優先。
6. Gitなどでバージョン管理（推奨）：最低限でもファイルのバックアップを取る習慣をつける。上書き事故がチームの士気を大きく下げる。

⚠️ ここでよくあるつまずき

• DB接続エラー：JDBCドライバの設定ミス、ポート番号・パスワードの打ち間違いが多い。接続テスト用のシンプルなクラスを最初に作って確認しよう。
• 文字コードの問題：フォームで日本語を送信すると文字化けすることがある。request.setCharacterEncoding("UTF-8")をdoPostの先頭に忘れずに。
• 作業の重複・衝突：誰が何をやっているか不明になりがち。毎朝10分の「朝会（スタンドアップ）」で今日やることを共有するだけで大幅に改善できる。

STEP 4｜Day8〜9：テスト & デバッグ

🎯 このフェーズのゴール

作ったシステムにバグがないか確認し、品質を担保すること。

具体的な手順

1. テスト仕様書を作成する：テスト項目、入力値、期待する結果、実際の結果、OK/NGを記録する表を用意する。「なんとなくテストした」では抜け漏れが生じる。
2. 単体テスト（コンポーネントテスト）：各Servletや処理ロジックを個別に動作確認する。特に境界値（入力の最大・最小、空文字など）を意識してテストする。
3. 結合テスト：複数の機能をまたいだ操作フロー（例：ログイン→データ登録→一覧表示→ログアウト）を実際に試す。
4. バグ管理と修正：発見したバグはリストに記録し、担当者を割り振って修正する。修正後は必ず再テストを実施。

⚠️ ここでよくあるつまずき

「テスト仕様書を書かずに感覚でテストしてしまう」のが最大の落とし穴。テスト担当者とバグ修正者が別になると「どんな操作で起きたバグか」の情報共有が曖昧になり、修正に時間がかかります。記録することがチームテストの基本中の基本です。

STEP 5｜Day10：最終発表 & 振り返り

🎯 このフェーズのゴール

成果を他者に伝え、学びを言語化すること。

具体的な手順

1. デモ発表の準備：実際にシステムを動かしながら発表する。「何の課題を解決するか」「どんな機能があるか」「工夫した点」を簡潔に伝えられるように準備する。
2. スライドまたはREADMEを用意：口頭だけでなく、画面を見せることで伝わり方が格段にアップする。
3. KPT振り返りを実施：Keep（よかったこと）、Problem（困ったこと）、Try（次に試すこと）の3つで演習全体を振り返る。個人だけでなくチームとして振り返ることが大切。

⚠️ ここでよくあるつまずき

「完成度が低いから発表できない…」と感じる人もいますが、完成していなくても発表に価値はあります。どこまで進んだか、何が難しかったかを伝えること自体が学習の証。発表を恐れずに挑みましょう！

よくあるつまずきポイントと対策【総まとめ】

まとめ

今回は「1チーム5名・10日間のプロジェクト型演習」の進め方を、全5ステップでお届けしました。

• Day1〜2：チーム結成・役割分担・要件定義でチームの方向を揃える
• Day3〜4：UML・DB・画面設計で実装の「地図」を作る
• Day5〜7：Java Servlet × DBで機能を実装する
• Day8〜9：テスト仕様書を使って品質を担保する
• Day10：発表とKPTで学びを言語化する

プロジェクト型演習の最大の価値は、「技術を使って問題を解く体験」と「チームで動く経験」の2つを同時に積めることです。うまくいかない日もあると思いますが、それも含めて現場で活きる”生きた学び”になります。

「みんなの役に立つWebシステム」というテーマに、ぜひ本気で向き合ってみてください。きっとその10日間が、あなたのエンジニアとしての大きな一歩になるはずです！

応援しています！💪

「Javaって学ぶことが多すぎて、どこから手をつければいいかわからない」——そう感じている方は多いはずです。でも実は、Java Web開発に必要な技術には決まった順番と繋がりがあります。

今日1日で学んだのは、その繋がりの核心部分——「HTMLでページを作り・SQLでデータを取り・サーブレットで処理して・DAOで綺麗に設計する」という一連の流れです。この記事では、今日カバーした4つのテーマを「全体像が見える総まとめ」として整理します。各テーマの詳細記事へのリンクも用意しているので、復習に活用してください！

目次

• 今日の学習マップ：4テーマの繋がりを理解しよう
• テーマ①　HTMLの基本構造とCSSの役割分担
• テーマ②　現場で使うSELECT文：データ調査編＆プログラミング編
• テーマ③　サーブレット＆JSPの本質と注意点
• テーマ④　DAOクラス＆Modelクラスの設計パターン
• 4テーマを繋げると見えてくる「Webアプリの全体像」
• まとめ：今日の学びを3行で整理

今日の学習マップ：4テーマの繋がりを理解しよう

今日学んだ4テーマは、バラバラに存在しているわけではありません。Webアプリケーションの「リクエスト〜レスポンス」という1本の流れの中で、それぞれが明確な役割を担っています。

【今日の学習マップ：Webアプリ リクエスト〜レスポンスの流れ】

① ブラウザ（クライアント）
   └─ テーマ① HTMLで作られた入力フォームからリクエストを送信
            └─ DOCTYPE・head/body構造・ブロック/インライン要素
            └─ CSSで「構造（HTML）」と「見た目」を分離する

                        ↓ HTTPリクエスト

② サーブレット（Controller）
   └─ テーマ③ サーブレットがリクエストを受け取り処理を振り分ける
            └─ HttpServlet継承・doGet()/doPost()・ライフサイクル
            └─ フォワードでJSPへ、リダイレクトで別URLへ
            └─ セッション管理でログイン状態を保持する

                        ↓ DAOを呼ぶ

③ DAO / Model層
   └─ テーマ④ DAOがDBアクセスを一手に引き受ける
            └─ JDBC：接続→PreparedStatement→ResultSet→クローズ
            └─ ResultSet → DTOに変換 → List<DTO>でサーブレットへ返す
            └─ JavaBeansでビジネスロジックをModelにまとめる

                        ↓ SQL発行

④ データベース（MySQL）
   └─ テーマ② SELECT文でデータを取得・集計・結合する
            └─ WHERE・ORDER BY・GROUP BY＋集約関数
            └─ INNER JOIN / LEFT OUTER JOIN
            └─ PreparedStatementでプレースホルダ実行

                        ↓ DTOリストで返却

⑤ JSP（View）
   └─ テーマ③ JSPがデータを受け取りHTMLとして表示する
            └─ EL式 ${ } でスクリプトレスに表示
            └─ ビジネスロジックはJSPに書かない

                        ↓ HTMLレスポンス

⑥ ブラウザ（クライアント）
   └─ テーマ① CSS（外部ファイル）でデザインされた画面が表示される

この流れが「頭の地図」として入ると、今後どんな機能を作るときも「どのクラスに何を書けばいいか」が迷わなくなります。では各テーマを順に振り返りましょう。

テーマ①　HTMLの基本構造とCSSの役割分担

Web開発の出発点は「ブラウザに表示される画面を作ること」です。HTMLとCSSはその2大技術ですが、それぞれの役割を混同しないことが最初の重要ポイントです。

🔑 今日のキーポイント

<!-- ✅ 今日の最重要コード：HTML構造とCSSの役割分担 -->

<!-- HTML（構造・意味だけを書く） -->
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>ページタイトル</title>
    <link rel="stylesheet" href="style.css">  <!-- CSSは外部ファイルで -->
  </head>
  <body>
    <div id="header">ヘッダー</div>
    <p class="important">重要なお知らせ</p>
  </body>
</html>

/* CSS（見た目だけを書く） */
#header   { background-color: #333; color: #fff; padding: 20px; }
.important { color: red; font-weight: bold; }

テーマ②　現場で使うSELECT文：データ調査編＆プログラミング編

Webアプリのほぼすべての機能はDBとの連携があります。「どうデータを取るか」を制するのがSELECT文です。今日は「現場でよく使う6パターン」を2軸で整理しました。

🔑 今日のキーポイント

-- ✅ 今日の最重要SQLパターン集

-- ①絞り込み（LIKE・IN・BETWEEN）
SELECT * FROM m_company WHERE company_name LIKE '%株式会社%';
SELECT * FROM m_company WHERE company_id IN (1, 3, 5);
SELECT * FROM m_company WHERE company_id BETWEEN 2 AND 6;

-- ②並べ替え（ORDER BY）
SELECT * FROM m_company ORDER BY area_id ASC, company_id DESC;

-- ③集計（GROUP BY + COUNT）
SELECT area_name, COUNT(*) AS cnt FROM m_company
GROUP BY area_name HAVING COUNT(*) >= 2;

-- ④内部結合（INNER JOIN）
SELECT t1.person_lname, t2.company_name
FROM m_person t1 INNER JOIN m_company t2 ON t1.company_id = t2.company_id;

-- ⑤PreparedStatement（Javaコード）
String sql = "SELECT * FROM m_company WHERE company_name = ?";
PreparedStatement pstmt = con.prepareStatement(sql);
pstmt.setString(1, inputName);
ResultSet rs = pstmt.executeQuery();

特に「WHEREとHAVINGの使い分け」は試験でも実務でも頻出です。「集約関数（COUNT等）の結果を条件にするならHAVING、個別レコードの絞り込みはWHERE」と覚えておきましょう。

テーマ③　サーブレット＆JSPの本質と注意点

JavaでWebアプリを作るときの2大サーバサイド技術です。「サーブレットで処理してJSPで表示する」という役割分担がMVCの基本になります。

🔑 今日のキーポイント

// ✅ 今日の最重要コードパターン：サーブレット→JSPフォワード

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        request.setCharacterEncoding("UTF-8");
        String name     = request.getParameter("NAME");
        String password = request.getParameter("PASSWORD");

        if ("embex".equals(password)) {
            // セッションにログイン情報を保存
            HttpSession session = request.getSession();
            session.setAttribute("loginUser", name);

            // JSPへフォワード（処理結果を表示させる）
            request.setAttribute("userName", name);
            request.getRequestDispatcher("/welcome.jsp").forward(request, response);
        } else {
            request.getRequestDispatcher("/login.html").forward(request, response);
        }
    }
}

<!-- ✅ JSP側：EL式でスクリプトレスに表示（スクリプトレットを書かない！） -->
<%@ page contentType="text/html; charset=UTF-8" %>
<h1>ようこそ、${userName}さん！</h1>
<p>ログインに成功しました。</p>

テーマ④　DAOクラス＆Modelクラスの設計パターン

サーブレット・JSP・SQLと学んできて、最後に「それらをどう綺麗に繋げるか」の設計パターンを学びました。それがDAOパターン + DTO/JavaBeansです。

🔑 今日のキーポイント：3者の違いを整理する

// ✅ 今日の最重要コードパターン：DAO → DTO変換 → Listで返す

public class CompanyDAO {
    public List<CompanyDTO> findAll() {
        List<CompanyDTO> list = new ArrayList<>();
        Connection con = null; PreparedStatement pstmt = null; ResultSet rs = null;
        try {
            con   = DriverManager.getConnection(URL, USER, PASS);
            pstmt = con.prepareStatement("SELECT * FROM m_company ORDER BY company_id");
            rs    = pstmt.executeQuery();
            while (rs.next()) {
                CompanyDTO dto = new CompanyDTO();          // DBの1行 → DTOの1インスタンス
                dto.setCompanyId(rs.getInt("company_id"));
                dto.setCompanyName(rs.getString("company_name"));
                dto.setAreaName(rs.getString("area_name"));
                list.add(dto);                              // ListにDTOを追加
            }
        } catch (SQLException e) { e.printStackTrace();
        } finally {
            // 必ずクローズ（finally で確実に）
            try { if (rs    != null) rs.close();    } catch (SQLException e) {}
            try { if (pstmt != null) pstmt.close(); } catch (SQLException e) {}
            try { if (con   != null) con.close();   } catch (SQLException e) {}
        }
        return list;   // List<CompanyDTO> をサーブレットへ返す
    }
}

4テーマを繋げると見えてくる「Webアプリの全体像」

今日学んだ4テーマを1本のコードフローとして繋げると、以下のようになります。これがMVCモデルに基づいたJava Webアプリの完成形です。

// ===== MVCモデル完成形：会社一覧表示機能の全体フロー =====

// 【テーマ① HTML：ブラウザからリクエスト送信】
// <a href="/companyList">会社一覧を見る</a>
// ↓ GETリクエスト送信

// 【テーマ③ サーブレット（Controller）】
@WebServlet("/companyList")
public class CompanyListServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // 【テーマ④ DAOを呼ぶ（ビジネスロジックはDAOに任せる）】
        CompanyDAO dao = new CompanyDAO();
        List<CompanyDTO> companyList = dao.findAll();   // ← 内部でSQLを発行

        // JSP（View）へ渡すためにrequestにセット
        request.setAttribute("companyList", companyList);

        // JSPへフォワード（URLは変わらない）
        request.getRequestDispatcher("/companyList.jsp").forward(request, response);
    }
}

// 【テーマ② SQL（DAOの内部で発行）】
// SELECT company_id, company_name, area_name
// FROM testdb.m_company
// INNER JOIN testdb.m_area ON m_company.area_id = m_area.area_id
// ORDER BY company_id ASC;

// 【テーマ④ DTO：ResultSet → Javaオブジェクトへ変換】
// DBの1行 = CompanyDTOの1インスタンス → List<CompanyDTO> でサーブレットへ返る

// 【テーマ③ JSP（View）：EL式でスクリプトレスに表示】
// <c:forEach var="company" items="${companyList}">
//   <tr>
//     <td>${company.companyId}</td>
//     <td>${company.companyName}</td>
//     <td>${company.areaName}</td>
//   </tr>
// </c:forEach>

// 【テーマ① CSS：外部ファイルで画面をデザイン】
// table { border-collapse: collapse; width: 100%; }
// td, th { border: 1px solid #ccc; padding: 8px; }

4テーマはそれぞれ独立した技術ですが、Webアプリという1つのシステムの中で「画面 → 処理 → DB → 表示」という役割を担い、密接に連携しています。どのテーマが欠けても、Webアプリは成立しません。

また、各技術の「役割分担の鉄則」も今日のテーマに一貫して流れていました。

まとめ：今日の学びを3行で整理

今日カバーした内容は、Java Web開発のほぼすべての土台になる技術群です。最後に「今日の学びの核心」を3行でまとめます。

今日の4テーマを貫く一番大切な考え方は「役割分担」です。HTMLとCSS、サーブレットとJSP、DAOとDTO——それぞれが「自分の仕事だけをする」ように設計することで、修正が楽になり、チームで分業でき、バグが減ります。

次のステップは、今日の4テーマをすべて使った「会社一覧 → 詳細 → 登録 → 更新 → 削除」のフルCRUDアプリを実際に手を動かして作ることです。設計図（データの流れ）は今日学んだもので完成しています。あとはコードに落とすだけ！

各テーマの詳細については、シリーズ別記事もあわせてご活用ください。手を動かすことが一番の近道——今日学んだことをぜひ実際のコードで試してみてください！

📚 シリーズ記事一覧（今日の補講）

• 【Java基礎①】変数（プリミティブ型・参照型・スコープ）
• 【Java基礎②】メソッド（定義・引数・戻り値・命名規約）
• 【Java基礎③】クラス（設計図・インスタンス・カプセル化・コンストラクタ）
• 【Web基礎①】HTMLの基本構造とCSSの役割分担　← 今日
• 【DB/SQL①】現場で使うSELECT文（データ調査編＆プログラミング編）　← 今日
• 【Java Web①】サーブレット＆JSPの本質と注意点　← 今日
• 【Java Web②】DAOクラス＆Modelクラスの設計パターン　← 今日

「クラスって変数とメソッドをまとめただけ？」「インスタンスとオブジェクトって何が違うの？」——Javaを学び始めると、こういった疑問が次々と湧いてきますよね。

実は、クラスこそがJavaの核心です。クラスを理解できると、「オブジェクト指向」という考え方が一気にクリアになり、より大規模なプログラムが書けるようになります。

この記事では、IT研修の現場で初学者に繰り返し伝えてきた視点をもとに、「なぜクラスが便利なのか」「Javaでの定義・利用方法」「現場で必ず押さえておきたいポイント」まで、ていねいに解説します。具体的なコード例も豊富に用意したので、ぜひ手を動かしながら読んでみてください！

目次

• １．クラスって何が便利なの？
  • ①データとメソッドを「ひとまとめ」にできる
  • ②現実世界の「もの」をプログラムで表現できる
  • ③「設計図」として何度でも使い回せる
• ２．クラスを定義するって？利用するって？
  • ①クラスの定義：フィールドとメソッドをまとめる基本構文
  • ②クラスの利用：newでインスタンス化して「.」でアクセスする
  • ③アクセス修飾子とカプセル化：ゲッター・セッターで安全に守る
• ３．クラスについて整理しておきたいこと
  • ①クラス・オブジェクト・インスタンスの言葉の違い
  • ②コンストラクタとは：newのタイミングで自動実行される初期化処理
  • ③オーバーロードとガーベージコレクションの基礎知識
• まとめ

１．クラスって何が便利なの？

①データとメソッドを「ひとまとめ」にできる

これまでに学んだ「変数」は1種類のデータを入れる箱でした。でも現実のプログラムでは、複数のデータをまとめて管理したい場面がたくさんあります。

たとえば「社員情報」を管理したいとき、変数だけだとこうなります。

// ❌ 変数だけで社員情報を管理しようとすると…
String employeeName1 = "田中";
int employeeAge1 = 28;
String employeeDept1 = "開発部";

String employeeName2 = "鈴木";
int employeeAge2 = 35;
String employeeDept2 = "営業部";
// 社員が増えるたびに変数が爆発的に増える…

クラスを使うと、「社員」というひとまとまりの型を自分で定義できます。これが「ユーザー定義型」の考え方です。

// ✅ クラスを使うと社員情報がひとまとまりに
class Employee {
    String name;   // フィールド（属性）
    int age;
    String dept;

    void work() { // メソッド（操作）
        System.out.println(name + "が仕事をしています");
    }
    double getSalary() {
        return age * 1000.0; // 仮の給与計算
    }
}

クラスには「フィールド（属性）」と「メソッド（操作）」の両方を定義できるのがポイントです。データとそのデータに関する処理がセットになっているので、管理がとても楽になります。

②現実世界の「もの」をプログラムで表現できる

オブジェクト指向の考え方の根っこは、「現実世界に存在するものをそのままプログラムで表現しよう」というアイデアです。

たとえば「銀行口座」を考えてみましょう。現実の銀行口座には「残高（属性）」があり、「入金する・出金する（操作）」という行為ができます。これをそのままクラスで表現できます。

class Account {
    String owner;   // 口座名義（属性）
    int balance;    // 残高（属性）

    void deposit(int amount) {   // 入金する（操作）
        balance += amount;
        System.out.println(amount + "円入金しました。残高：" + balance + "円");
    }

    void withdraw(int amount) {  // 出金する（操作）
        if (balance >= amount) {
            balance -= amount;
            System.out.println(amount + "円出金しました。残高：" + balance + "円");
        } else {
            System.out.println("残高不足です");
        }
    }
}

このように、現実の「もの」の特徴（属性）と「できること」（操作）をそのままクラスに落とし込めます。これが「オブジェクト指向」という設計思想の本質です。

他にも「顧客クラス」「商品クラス」「注文クラス」など、業務システムの主要な概念がそのままクラスとして表現できます。

③「設計図」として何度でも使い回せる

クラスは「設計図（ひな形）」です。設計図そのものはメモリを使いませんが、設計図をもとに「実体（インスタンス）」を何個でも作ることができます。

家の設計図に例えると——同じ設計図から何棟でも家を建てられますよね。それぞれの家には違う人が住んでいて、違う家具が置いてある。クラスとインスタンスの関係もまったく同じです。

// Accountクラス（設計図）から複数のインスタンスを生成
Account account1 = new Account();   // 田中さんの口座
account1.owner = "田中";
account1.balance = 50000;

Account account2 = new Account();   // 鈴木さんの口座
account2.owner = "鈴木";
account2.balance = 120000;

// それぞれ独立したインスタンスとして存在する
account1.deposit(10000);   // 田中さんの残高が変わる
account2.withdraw(5000);   // 鈴木さんの残高が変わる（田中さんには無関係）

1つのクラス定義から、何個でも独立したインスタンスを作れる。これがクラスの最大の「使い回し」のメリットです。

２．クラスを定義するって？利用するって？

①クラスの定義：フィールドとメソッドをまとめる基本構文

Javaでクラスを定義する基本構文はこうです。

class クラス名 {
    // フィールド（属性：データを保持する変数）
    データ型 フィールド名;

    // メソッド（操作：処理を定義する）
    戻り値の型 メソッド名(引数) {
        // 処理内容
    }
}

具体例として「点（Point）クラス」を作ってみましょう。

class Point {
    // フィールド（座標の属性）
    int x;
    int y;

    // メソッド（2点間の距離を返す操作）
    double distanceTo(Point other) {
        int dx = this.x - other.x;
        int dy = this.y - other.y;
        return Math.sqrt(dx * dx + dy * dy);
    }

    // メソッド（座標を表示する操作）
    void display() {
        System.out.println("(" + x + ", " + y + ")");
    }
}

ここで登場した this キーワードは「このインスタンス自身」を指します。this.x は「このインスタンスのフィールド x」という意味です。引数名とフィールド名が同じになるときなどに特に活躍します。

②クラスの利用：newでインスタンス化して「.」でアクセスする

クラス（設計図）を定義しただけでは何も起きません。new 演算子を使ってインスタンスを生成して初めて、メモリ上に実体が作られます。これを「インスタンス化」といいます。

// クラス名 変数名 = new クラス名();
Point p1 = new Point();

// フィールドへのアクセスは「.（ドット）」を使う
p1.x = 3;
p1.y = 4;

// メソッドの呼び出しも「.（ドット）」を使う
p1.display();   // → (3, 4)

// 別のインスタンスも生成してみる
Point p2 = new Point();
p2.x = 0;
p2.y = 0;

// p1からp2への距離を計算
double dist = p1.distanceTo(p2);
System.out.println("距離：" + dist);   // → 距離：5.0

new のあとに呼び出している Point() はコンストラクタです（次のセクションで詳しく解説します）。

また、他のクラスのメソッドを呼び出す場合は、インスタンスを生成した上で インスタンス変数.メソッド名() の形でアクセスします。これが「クラスを利用する」ということです。

③アクセス修飾子とカプセル化：ゲッター・セッターで安全に守る

クラスのフィールドを外部から直接書き換えられると、意図しない値が入り込んでバグの原因になります。これを防ぐのがカプセル化（情報隠蔽）という考え方です。

アクセス修飾子を使って、フィールドの公開範囲をコントロールします。

カプセル化の実装パターンは「フィールドはprivate、アクセスはpublicなゲッター・セッター経由」です。

class Account {
    private String owner;   // ← privateにして外部から直接触れないようにする
    private int balance;

    // ゲッター（値を取得するメソッド）
    public String getOwner() {
        return owner;
    }

    public int getBalance() {
        return balance;
    }

    // セッター（値を設定するメソッド）
    public void setOwner(String owner) {
        this.owner = owner;
    }

    public void setBalance(int balance) {
        if (balance >= 0) {           // ← 不正な値を弾くチェックを入れられる！
            this.balance = balance;
        } else {
            System.out.println("残高に負の値は設定できません");
        }
    }
}

// 利用する側
Account act = new Account();
act.setOwner("田中");
act.setBalance(50000);

// act.balance = -9999;  ← ❌ privateなのでコンパイルエラー！直接触れない
System.out.println(act.getBalance());   // ✅ ゲッター経由でアクセス → 50000

セッターの中に「残高が0以上かどうか」のチェックを入れられているのがポイントです。データの整合性をクラス自身が守る——これがカプセル化の真の価値です。

３．クラスについて整理しておきたいこと

①クラス・オブジェクト・インスタンスの言葉の違い

「クラス」「オブジェクト」「インスタンス」——似たような言葉が並んでいて混乱しやすいので、しっかり整理しておきましょう。

// Employeeクラス（設計図）は値を持たない
// ↓
Employee emp1 = new Employee();   // インスタンス生成
emp1.name = "田中";    // インスタンスが初めて値を持つ
emp1.age = 28;

Employee emp2 = new Employee();   // 別のインスタンスを生成
emp2.name = "鈴木";   // emp1とは独立した値
emp2.age = 35;

// emp1を変えてもemp2は変わらない（別々の実体）
emp1.age = 29;
System.out.println(emp2.age);   // → 35（変わっていない）

class Account {
    private String owner;
    private int balance;

    // コンストラクタ（クラス名と同じ名前、戻り値なし）
    public Account(String owner, int initialBalance) {
        this.owner = owner;
        this.balance = initialBalance;
        System.out.println(owner + "の口座を開設しました（残高：" + initialBalance + "円）");
    }
}

// 利用する側
Account act = new Account("田中", 50000);
// → 田中の口座を開設しました（残高：50000円）
// インスタンス生成と同時に初期値が設定される！

// コンストラクタを定義しなかった場合は、これが自動生成される
// public Account() { }  ← デフォルトコンストラクタ

// ただし、引数ありのコンストラクタを定義すると…
// public Account(String owner, int balance) { ... }
// ↑ これを定義した場合、下の呼び出しはエラーになる
Account act = new Account();   // ❌ 引数なしのコンストラクタがない！

class Calculator {
    // 引数が2つのバージョン
    static int add(int a, int b) {
        return a + b;
    }

    // 引数が3つのバージョン（オーバーロード）
    static int add(int a, int b, int c) {
        return a + b + c;
    }

    // 引数の型がdoubleのバージョン（オーバーロード）
    static double add(double a, double b) {
        return a + b;
    }
}

// 呼び出し側：同じ名前addで、引数によって自動的に適切なメソッドが選ばれる
System.out.println(Calculator.add(1, 2));         // → 3（2引数int版）
System.out.println(Calculator.add(1, 2, 3));      // → 6（3引数int版）
System.out.println(Calculator.add(1.5, 2.5));     // → 4.0（double版）

Account act = new Account("田中", 50000);
act = null;   // 参照を切る → このインスタンスはガーベージコレクションの対象になる

act = new Account("鈴木", 30000);   // 新しいインスタンスに参照を付け替え

「メソッドって、ただの処理のかたまりでしょ？」——そう思っていませんか？

実は、メソッドを使いこなせるかどうかで、コードの読みやすさ・修正のしやすさ・チームでの開発効率が劇的に変わってきます。プロのエンジニアが「メソッド設計が大事」と口をそろえる理由は、まさにここにあります。

この記事では、IT研修の現場で初学者に繰り返し伝えてきた視点をもとに、「なぜメソッドが必要なのか」「Javaでの具体的な書き方」「現場で気をつけたいポイント」まで、ていねいに解説します。コード例もたっぷり用意したので、ぜひ手を動かしながら読み進めてください！

目次

• １．メソッドって何が便利なの？
  • ①処理を「再利用できる部品」としてまとめられる
  • ②「入口と出口」が明確になり、処理の流れが読みやすくなる
  • ③機能を分割することで保守・修正・チーム開発が楽になる
• ２．Java言語でのメソッドの利用方法は？
  • ①メソッドの定義方法：基本構文をマスターしよう
  • ②引数（実引数・仮引数）と戻り値（return文）の役割と書き方
  • ③voidメソッドと値を返すメソッドの使い分け・staticの意味
• ３．メソッドについて整理しておきたいこと
  • ①実引数と仮引数の関係／値渡しと参照渡しの違い
  • ②return文は1つにまとめる（構造化プログラミングの原則）
  • ③メソッド名の命名規約と、読みやすいコード設計のコツ
• まとめ

１．メソッドって何が便利なの？

①処理を「再利用できる部品」としてまとめられる

まず一番シンプルな便利さから。メソッドは「処理をひとまとめにして、何度でも呼び出せる部品」です。

たとえば、割引価格を計算する処理が複数の場所で必要になったとします。メソッドを使わないと、同じ計算式をあちこちにコピーして書くことになります。でもそれだと、税率が変わったときに全部探して直さないといけない…とても大変ですよね。

// ❌ メソッドを使わない場合（同じ計算が散らばる）
double price1 = 24800 * 0.7;
double price2 = 15000 * 0.7;
double price3 = 8000  * 0.7;
// 割引率を変えたいとき、全行を修正しなければならない…

// ✅ メソッドを使う場合（一か所を直すだけでOK）
static double calcDiscountPrice(int originalPrice, double rate) {
    return originalPrice * rate;
}

// 呼び出し
double price1 = calcDiscountPrice(24800, 0.7);
double price2 = calcDiscountPrice(15000, 0.7);
double price3 = calcDiscountPrice(8000,  0.7);

メソッドにまとめることで、修正は1か所だけ。コードの「部品化」ができると、プログラムの品質がぐっと上がります。

②「入口と出口」が明確になり、処理の流れが読みやすくなる

メソッドには「入口（引数）」と「出口（戻り値）」があります。この設計思想がとても大切で、処理の目的と流れを一目でわかるようにしてくれます。

料理に例えると——「材料を渡す（引数）→ シェフが調理する（メソッドの処理）→ 料理が出てくる（戻り値）」というイメージです。シェフの中身（レシピ）を知らなくても、材料を渡せば料理が返ってくる。それがメソッドの本質です。

// 「入力値を2乗する」メソッド
static int pow2(int src) {
    return src * src;
}

// 使う側はシンプル
int result = pow2(3);   // 3を渡す → 9が返ってくる
System.out.println(result);  // → 9

pow2(3) を読むだけで「3を2乗するんだな」とすぐわかりますよね。これがメソッドが「読みやすさ」を生む理由です。

③機能を分割することで保守・修正・チーム開発が楽になる

大きなプログラムを1つのメソッド（mainメソッド）に全部書いてしまうと、どこに何の処理があるかわからなくなります。これは「スパゲッティコード」と呼ばれる悪い状態です。

メソッドで機能を分割すると、次のようなメリットが生まれます。

• ✅ バグの場所を特定しやすい（どのメソッドで問題が起きているかがわかる）
• ✅ チームで担当を分けやすい（Aさんはこのメソッド、Bさんはあのメソッドを担当）
• ✅ テストしやすい（メソッド単位で動作確認できる）

// mainメソッドがすっきり！ 何をしているか一目でわかる
public static void main(String[] args) {
    dispHeader("成績表");          // ①ヘッダー表示
    String msg = judge(75);        // ②点数判定
    dispResult(msg);               // ③結果表示
    dispFooter();                  // ④フッター表示
}

mainメソッドが「目次」のような役割を果たしていますね。処理の流れが上から下へ読めるコード——これがメソッド分割の理想形です。

２．Java言語でのメソッドの利用方法は？

①メソッドの定義方法：基本構文をマスターしよう

Javaでメソッドを定義するときの基本構文はこうです。

static 戻り値の型 メソッド名(引数の型 引数名, ...) {
    // 処理内容
    return 戻り値;
}

各パーツの意味を整理しておきましょう。

具体的なコードを見てみましょう。定価と割引率を受け取って、割引後の価格を返すメソッドです。

class TestShop {
    public static void main(String[] args) {
        int price = 24800;     // 定価
        double rate = 0.7;     // 割引率

        // calc()メソッドの呼び出し
        double ret = calc(price, rate);
        System.out.println("割引後の価格は" + ret + "です。");
    }

    static double calc(int yen, double rate) {
        double result;
        result = yen * rate;
        return result;
    }
}

main メソッドから calc() を呼び出し、戻り値を変数 ret で受け取っています。この「呼び出す→処理→受け取る」の流れを体で覚えましょう！

②引数（実引数・仮引数）と戻り値（return文）の役割と書き方

引数には「実引数」と「仮引数」という2つの言葉があります。混乱しやすいので整理しておきましょう。

// 呼び出し元：num が「実引数」
int num = 4;
pow2(num);   // ← numの値(4)がpow2メソッドへ渡される

// メソッド定義：src が「仮引数」
static int pow2(int src) {   // ← srcに4がコピーされる
    return src * src;
}

大事なポイントは、実引数と仮引数は変数名が違っても問題ないということです（上の例では num と src）。値がコピーされるのであって、変数名が一致している必要はありません。

また、戻り値は return 文で返します。引数は複数渡せますが、戻り値は 0個（void）か1個だけ というルールがあります。

// 引数は複数OK
static double calc(int yen, double rate) {
    return yen * rate;   // 戻り値は1つだけ
}

// 戻り値なし（void）も可
static void showMessage(String msg) {
    System.out.println(msg);
    // returnは不要（または return; だけ書く）
}

③voidメソッドと値を返すメソッドの使い分け・staticの意味

メソッドには大きく2種類あります。「値を返すメソッド」と「値を返さないメソッド（voidメソッド）」です。

// ✅ 値を返すメソッド（戻り値あり）
static String judge(int score) {
    String message;
    if (score >= 90) {
        message = "優秀賞";
    } else if (score >= 60) {
        message = "合格";
    } else {
        message = "再試験";
    }
    return message;   // 文字列を返す
}

// ✅ voidメソッド（戻り値なし）
static void dispResult(String msg) {
    System.out.println("判定結果：" + msg);
    // return は不要
}

また、static 修飾子について。mainメソッドから直接呼び出すメソッドには static が必要です。これはJavaのクラス設計に関わるルールで、最初の段階では「mainから呼ぶなら static をつける」と覚えておけばOKです。

３．メソッドについて整理しておきたいこと

①実引数と仮引数の関係／値渡しと参照渡しの違い

先ほど触れた「実引数・仮引数」に関連して、もう1つ大事な概念が「値渡し」と「参照渡し」です。

Javaでは、引数の型によって渡し方が変わります。

• 基本データ型（int・double など）→ 値渡し：値のコピーが渡される。メソッド内で変更しても、呼び出し元の変数は変わらない。
• 参照型（配列・Stringなど）→ 参照渡し：メモリ上の「場所」が渡される。メソッド内で変更すると、呼び出し元の変数にも影響が出る。

// 値渡し（基本データ型）：呼び出し元は変わらない
static void changeValue(int num) {
    num = 99;   // コピーを変えているだけ
}

int var = 0;
changeValue(var);
System.out.println(var);   // → 0（変わっていない！）

// 参照渡し（配列）：呼び出し元も変わる！
static void changeArray(int[] ary) {
    ary[0] = 99;   // 同じ場所を操作している
}

int[] array = new int[]{0, 1, 2};
changeArray(array);
System.out.println(array[0]);   // → 99（変わってしまった！）

「配列を渡したら中身が変わった！」はよくあるバグの原因です。参照渡しの挙動を理解しておくことが、バグを防ぐ第一歩になります。

②return文は1つにまとめる（構造化プログラミングの原則）

コードを書いていると、条件分岐の中に複数の return 文を書きたくなることがあります。でも、構造化プログラミングの考え方では「メソッドの出口は1つにする」が原則です。

// ❌ return文が複数（出口が複数）
static int getA(int param) {
    if (param > 10) {
        return 1;   // 出口1
    } else {
        return 0;   // 出口2
    }
}

// ✅ return文を1つにまとめる（推奨）
static int getA(int param) {
    int ret;
    if (param > 10) {
        ret = 1;
    } else {
        ret = 0;
    }
    return ret;   // 出口はここだけ！
}

また、コーディング規約として return 文に不要な () はつけません。

// ❌ 不適合例
return (value);
return (1);

// ✅ 適合例
return value;
return 1;

小さなことに見えますが、チームで統一されたルールに従うことが、長期的に読みやすいコードベースを守ることにつながります。

③メソッド名の命名規約と、読みやすいコード設計のコツ

最後に、メソッド名の付け方について。良いメソッド名は、コードを読む人（未来の自分やチームメンバー）への「プレゼント」です。

Javaのコーディング規約では、メソッド名の先頭の単語はなるべく動詞にするとされています。

また、英単語の対称性にも気をつけましょう。たとえば open と close、get と set、start と stop のように、対になる処理には対称的な名前をつけることで、コードの意図が伝わりやすくなります。

// ✅ 対称性を意識した命名
static void openFile(String path) { /* ファイルを開く */ }
static void closeFile(String path) { /* ファイルを閉じる */ }

static String getUserName() { /* 名前を取得 */ return ""; }
static void setUserName(String name) { /* 名前をセット */ }

こういった積み重ねが、誰が読んでも理解できるプロフェッショナルなコードにつながっていきます。

まとめ

今回はJavaの「メソッド」について、基礎の基礎から現場で使える知識まで解説しました。最後にポイントを整理しておきます。

メソッドをうまく使えるようになると、コードの「設計力」が身についてきます。「このメソッドは何をするメソッドか」を一言で説明できるくらいシンプルにまとめること——それが良いメソッド設計の第一歩です。

まずは今日のコード例を実際に打って動かしてみてください。「手を動かすこと」が理解を10倍速くしてくれます！

次回は「クラスとオブジェクト指向の基礎」について解説予定です。お楽しみに！

「変数って聞いたことあるけど、なんのためにあるの？」「Javaって型がたくさんあってよくわからない…」そんなふうに感じたことはありませんか？

プログラミングを始めたばかりのころ、変数の概念でつまずく人はとても多いです。でも安心してください。変数は一度しっかり理解してしまえば、どんなプログラムを書くときにも必ず役に立つ「土台」になります。

この記事では、IT研修の現場で初学者に繰り返し伝えてきた視点をもとに、「なぜ変数が必要なのか」から「Javaでの具体的な使い方」「現場で気をつけたいポイント」まで、ていねいに解説していきます。コードの例もたっぷり入れているので、ぜひ手を動かしながら読み進めてみてください！

目次

• １．なぜ変数は必要なの？
  • ①「データを一時的に覚えておく箱」が必要な理由
  • ②変数は「メモリ上のある領域に名前をつけたもの」
  • ③「値を使い回す・変える・比べる」場面すべてで変数が活躍する
• ２．Java言語で使う変数は？
  • ①基本データ型（プリミティブ型）の種類と特徴
  • ②変数の宣言・代入・初期化の書き方
  • ③参照型変数には「データのある場所（参照）」が入る
• ３．変数について整理しておきたいこと
  • ①変数・定数・リテラルの違い
  • ②型変換（キャスト）のルールと注意点
  • ③変数のスコープ（有効範囲）とコーディング規約
• まとめ

１．なぜ変数は必要なの？

①「データを一時的に覚えておく箱」が必要な理由

プログラムは、何かを「計算」したり「判断」したりするためのものです。その過程で、途中の値を一時的にどこかに保存しておく必要があります。それが「変数」の役割です。

たとえば、消費税を計算するプログラムを考えてみましょう。税率が8%から10%に変わったとき、変数を使っていれば1か所直すだけで済みます。でも変数を使わずに数値を直接書いていたら…すべての箇所を探して修正しなければなりません。

// ❌ 変数を使わない場合（修正が大変）
System.out.println(1000 * 0.10);
System.out.println(2000 * 0.10);
System.out.println(3000 * 0.10);

// ✅ 変数を使う場合（税率を1か所変えるだけでOK）
double taxRate = 0.10;
System.out.println(1000 * taxRate);
System.out.println(2000 * taxRate);
System.out.println(3000 * taxRate);

変数があることで、コードの変更に強くなり、読みやすくなる。これが変数が必要な一番の理由です。

②変数は「メモリ上のある領域に名前をつけたもの」

少しだけコンピュータの仕組みに踏み込んでみましょう。プログラムが動くとき、データはコンピュータのメモリ（RAM）上に乗ります。メモリはものすごく大量の「番地」（アドレス）に区切られた空間です。

でも、番地をそのまま使うのは大変ですよね。「0x00FF12AB番地の値を使え」なんて言われても人間には辛い。そこで登場するのが変数名です。「この番地の領域を score と呼ぼう」と名前をつけることで、人間がわかりやすくデータを扱えるようになります。

イメージとしては、ロッカーに名前シールを貼るようなもの。中身（データ）は変わっても、ロッカーの名前（変数名）は変わらない。だから次に使うときも同じ名前でアクセスできる、という仕組みです。

③「値を使い回す・変える・比べる」場面すべてで変数が活躍する

変数が活躍する場面は大きく3つあります。

• 使い回す：同じ値を複数の計算で使うとき（消費税率、円周率など）
• 変える：ループのカウンタや、ユーザーが入力した値を更新するとき
• 比べる：「点数が60点以上かどうか」「在庫が0かどうか」などの条件判断

int score = 85;         // 使い回す
score = score + 10;     // 変える（ボーナス加点）
if (score >= 90) {      // 比べる（合格判定）
    System.out.println("優秀賞！");
}

プログラムのあらゆる場面で変数は登場します。変数を制する者がプログラミングを制すると言っても過言ではありません！

２．Java言語で使う変数は？

①基本データ型（プリミティブ型）の種類と特徴

Javaでは変数を使うとき、必ず「どんなデータを入れるか」という型（データ型）を指定します。型によって、メモリ上で確保される領域のサイズが決まります。

まず覚えておきたいのが基本データ型（プリミティブ型）です。Javaの基本データ型はサイズが固定で、OSやハードウェアに依存しないのが大きな特徴です。

日常的によく使うのは int・double・boolean・String（後述）あたりです。まずこの4つをしっかり押さえましょう。

②変数の宣言・代入・初期化の書き方

Javaで変数を使うには、まず宣言が必要です。宣言とは「この名前でこの型の変数を使います」とJavaに伝える行為です。

// 宣言だけ
int score;

// 宣言と同時に初期化（推奨！）
int score = 100;

// 後から値を代入
int score;
score = 100;   // ← これでもOK

注意点： Javaでは、初期化せずに変数を使おうとするとコンパイルエラーになります。宣言しただけの変数の値は「不定」とみなされるためです。これは初学者がよくハマるポイントなので要注意！

// ❌ これはコンパイルエラー
int score;
System.out.println(score);  // エラー！初期化されていない変数は使えない

// ✅ 正しい書き方
int score = 0;
System.out.println(score);  // OK

また、long 型は末尾に L、float 型は F をつけるルールがあります。

long population = 1280000000L;   // Lをつけないとint扱いでエラーの可能性
float pi = 3.14F;                // Fをつけないとdouble扱いになる

③参照型変数には「データのある場所（参照）」が入る

基本データ型の変数には「値そのもの」が入ります。一方、Javaには参照型という変数もあります。代表例は String（文字列）や配列、クラスのインスタンスなどです。

参照型の変数には、データそのものではなく「データが存在するメモリ上の場所（参照）」が格納されます。このイメージの違いが、後々の「値渡し・参照渡し」の理解につながります。

// 基本データ型：値そのものをコピー
int a = 10;
int b = a;   // bにaの「値10」がコピーされる
b = 99;      // bを変えてもaは変わらない（aはまだ10）

// 参照型：参照（場所）をコピー
int[] array1 = new int[]{1, 2, 3};
int[] array2 = array1;   // array2にarray1の「参照」がコピーされる
array2[0] = 99;           // array2を通じて変更すると…
System.out.println(array1[0]);  // → 99！ array1も変わってしまう

「え、array1まで変わるの？！」と驚いた方は正常な反応です。これが参照型の大事なポイント。同じ場所を2つの変数で指しているから、片方を変えると両方に影響が出るんです。

３．変数について整理しておきたいこと

①変数・定数・リテラルの違い

似たような言葉が並んで混乱しやすいので、ここでしっかり整理しましょう。

定数は final キーワードをつけて宣言します。税率・円周率など「プログラム中で変わらない値」を定数にしておくと、意図しない書き換えを防げて安全です。

final double TAX_RATE = 0.10;
TAX_RATE = 0.08;   // ❌ コンパイルエラー！定数は変更不可

また「リテラル」は定数ではありません。100 というコードに書かれた数値そのものがリテラルです。この違いは試験でも問われるので押さえておきましょう。

②型変換（キャスト）のルールと注意点

異なる型のデータを組み合わせて計算するとき、Javaは自動的に型を変換してくれる場合があります。これを暗黙的な型変換（自動変換）といいます。

int a = 10;
double b = a;   // int → double は自動変換OK（精度が上がる方向）
System.out.println(b);   // 10.0

逆に精度が下がる方向（double → int など）は、データが失われる可能性があるため明示的なキャストが必要です。

double price = 198.9;
int intPrice = (int) price;   // キャスト：小数点以下が切り捨てられる
System.out.println(intPrice); // → 198

実務でよくある注意点として、実数計算の誤差問題があります。

double result = 0.0;
for (int i = 0; i < 1000; i++) {
    result += 0.1;
}
System.out.println(result);   // 100.0 にならない！ ← 誤差が蓄積される

金額など誤差が許されない計算には BigDecimal クラスを使いましょう。処理は少し遅くなりますが、正確な計算ができます。

③変数のスコープ（有効範囲）とコーディング規約

スコープとは、変数が「どこから使えるか」の範囲のことです。Javaでは、変数は宣言されたブロック（波かっこ {} の中）でのみ有効です。

if (true) {
    int x = 10;   // xはこのブロック内だけで有効
}
System.out.println(x);   // ❌ コンパイルエラー！ブロックの外では使えない

コーディング規約として、現場では以下のルールが一般的です。

• ✅ ローカル変数は宣言時に初期化する（後から初期化するより安全）
• ✅ 変数の「使い回し」はしない（意味が異なるデータに同じ変数名を使わない）
• ✅ 変数名は役割がわかる名前をつける（x より customerAge の方がわかりやすい）
• ✅ スコープはできるだけ狭く保つ（必要な場所で宣言し、無駄に広げない）

// ❌ 変数の使い回し（NG例）
int i;
for (i = 0; i < 5; i++) { /* 処理 */ }
for (i = 0; i < 3; i++) { /* 別の処理でiを再利用 */ }

// ✅ 目的ごとに新しく宣言（推奨）
for (int row = 0; row < 5; row++) { /* 処理 */ }
for (int col = 0; col < 3; col++) { /* 別の処理 */ }

コーディング規約はチームで統一することで、誰が読んでも理解しやすいコードが書けるようになります。最初から良い習慣を身につけましょう！

まとめ

今回はJavaの「変数」について、基礎の基礎からていねいに解説しました。最後にポイントを整理しておきます。

変数はプログラミングの最重要基礎です。「なぜそうなのか」を理解した上で使いこなせるようになると、条件分岐もループも一気に理解しやすくなります。ぜひ今日紹介したコード例を実際に動かして、自分の手で確かめてみてください！

次回は「演算子と条件分岐」について解説予定です。お楽しみに！

「データベースって、なんとなく聞いたことはあるけど、正直よくわからない…」
そんな方、けっこう多いんじゃないでしょうか？

実は、あなたが毎日使っているスマホアプリ・ネットショッピング・SNS、そのすべての裏側でデータベースが動いています。
ITエンジニアを目指すなら、データベースの知識は絶対に避けて通れません。

この記事では、「データベースって何？」というゼロの状態から、RDB・SQL・NoSQLの違い、さらにJavaとの連携の仕組みまでを、身近な例えをつかってやさしく・まるごと解説します！
最後まで読めば、データベースの全体像がスッキリつかめますよ。

📋 目次

• そもそもデータベースって何？ファイル管理との違い
• DBMSの3つの特徴
• RDB（リレーショナルデータベース）の仕組み
• SQLの基本4操作をやさしく解説
• データベースの今昔話｜なぜ今もRDB・SQLが使われるのか？
• RDB vs NoSQL｜何が違うの？どう使い分ける？
• JavaとDBをつなぐ仕組み｜JDBCとDAOって何？
• まとめ

🗂️ そもそもデータベースって何？ファイル管理との違い

データベースとは、データを整理してまとめて管理できる仕組みのことです。

「Excelでも管理できるじゃん」と思いますよね。でも、データが増えてきたり、複数のアプリやユーザーが同じデータを使うようになると、ファイル管理では一気に限界が来ます。

ひと言でまとめると、「データベースは、ファイル管理では対応しきれない大規模・複雑なデータを、安全・効率的に扱うための専用の仕組み」です。

🔑 DBMSの3つの特徴

データベースを管理するソフトウェアをDBMS（データベース管理システム）といいます。DBMSには次の3つの大きな特徴があります。

📊 RDB（リレーショナルデータベース）の仕組み

現在のシステム開発で最も広く使われているのが、RDB（リレーショナルデータベース）です。
データを行（レコード）×列（フィールド）の表（テーブル）形式で管理します。

📌 テーブル・レコード・フィールドのイメージ
テーブル ＝ 名簿リスト全体
レコード ＝ 1人分のデータ（行）
フィールド ＝ 名前・年齢・部署などの項目（列）

さらに主キー（Primary Key）で各レコードを一意に識別し、外部キー（Foreign Key）で別のテーブルと関連付けることで、データの重複をなくしながら複雑な情報を整理できます。
この「テーブルを分けてキーでつなぐ」設計のことを正規化といい、データの整合性を保つ基本的な考え方です。

💬 SQLの基本4操作をやさしく解説

RDBを操作するための言語がSQL（Structured Query Language）です。
国際標準として規格化されているので、MySQLでもOracleでも同じ書き方が通用します。

さらにWHERE句で条件を絞り込み、JOIN句で複数テーブルを結合することで、業務に必要な情報をピンポイントで取り出せます。

📜 データベースの今昔話｜なぜ今もRDB・SQLが使われるのか？

RDBが生まれたのは1970年代。当時はファイルごとにデータが散在して管理しきれない問題が深刻でした。
そこに「表形式でデータを管理する」という革命的な発想のRDBが登場し、標準言語SQLとともに世界中に普及しました。

それから50年以上たった今も使われ続ける理由は3つあります。

• 🏦 整合性・信頼性が圧倒的に高い：銀行・会計・給与計算など「1円もズレてはいけない」業務システムはRDB一択
• 👨‍💻 SQLが国際標準で人材が豊富：世界中にエンジニアがいて学習コストが低い
• 🏢 既存システムへの膨大な投資：企業の基幹システムはRDBで構築済みで、今さら全面移行は現実的でない

⚔️ RDB vs NoSQL｜何が違うの？どう使い分ける？

2000年代後半、SNSやビッグデータの時代になるとRDBだけでは対応しきれないケースが増え、NoSQLが登場しました。

💡 現場の結論：「どちらか」ではなく「使い分け」！
💳 金融・会計 → RDB（整合性最優先）
📱 SNS・ログ管理 → NoSQL（スピード・スケール優先）
🛒 ECサイト → 両方を組み合わせる！

☕ JavaとDBをつなぐ仕組み｜JDBCとDAOって何？

Javaプログラムからデータベースを操作するときに使うのがJDBC（Java Database Connectivity）です。
JDBCはJavaとDBの間に入る「通訳役」のような存在で、どのDBMSでも同じJavaコードで操作できる環境を提供します。

🔗 DB接続の流れ（5ステップ）

1. DBに接続する（電話をかける）
2. SQL文を作る（話す内容を決める）
3. SQLを実行する（話す）
4. 結果を受け取る（答えを聞く）
5. 接続を閉じる（電話を切る）← 必ず閉じること！

さらに現場でよく使われる設計パターンがDAO（Data Access Object）です。
「業務処理（ビジネスロジック）」と「DB操作（データアクセス処理）」を分離することで、将来MySQLからPostgreSQLに切り替えても業務ロジックを一切変えずに済むという大きなメリットがあります。

また、SQLインジェクションなどの攻撃を防ぐためにPreparedStatementを使うことが現場の鉄則です。

📝 まとめ

今回学んだことを一気に振り返りましょう！

データベースは「難しい技術」というより、「データの整理整頓術」です。
まずはSQLで実際にデータを検索・追加してみる体験が理解の近道！
「SELECT * FROM 自分の興味」で、ぜひ次のステップを探してみてください 😄🚀

「オブジェクト指向って、なんとなくわかった気がするけど、実際どう使うの？」——そう感じているエンジニア研修生、あなただけじゃありません。

プログラミングを学び始めると、必ずといっていいほどぶつかるのがオブジェクト指向の壁。教科書を読んでも「クラスってなに？」「継承って何が便利なの？」とモヤモヤしたまま進んでしまう人が後を絶ちません。

この記事では、IT業界の研修現場で積み上げてきた知見をもとに、オブジェクト指向の3大特性（カプセル化・継承・ポリモーフィズム）を日常の例えとコードで解説。さらに各原則のメリット・デメリットと、近年注目される関数型プログラミングとの違いまで踏み込みます。読み終えるころには、設計の選択肢が一段と広がっているはずです！

目次

1. この記事を読む前に知っておきたい前提知識
2. 【大項目①】カプセル化 ── データを守る「黒い箱」の仕組み
3. 【大項目②】継承 ── コードを「親から子へ」引き継ぐ魔法
4. 【大項目③】ポリモーフィズム ── 「同じ呼び方、違う動き」の柔軟設計
5. 【番外編】関数型プログラミングとの違いを理解しよう
6. まとめ ── 3大原則＋αを現場で活かすために

この記事を読む前に知っておきたい前提知識

この記事は、以下の知識を持っている方を対象にしています。

• Javaなど、オブジェクト指向言語を学習中（または学習予定）の方
• 変数・メソッド・クラスという言葉を聞いたことがある方
• プログラミングの基本的な書き方（if文・for文など）を理解している方

「クラスって何？」という段階の方は、まず「クラスとはオブジェクトの設計図」というイメージを持っておいてください。家の設計図（クラス）があれば、同じ構造の家（オブジェクト）をいくつでも建てられる——このイメージが、以下の3大原則を理解する土台になります。

【大項目①】カプセル化 ── データを守る「黒い箱」の仕組み

カプセル化ってそもそも何？

カプセル化（Encapsulation）とは、データ（属性）と処理（メソッド）をひとつのクラスにまとめ、外部から直接触れないように隠蔽する仕組みです。

身近な例で言うと、車のエンジンがまさにカプセル化そのものです。私たちはエンジンの内部構造を知らなくても、アクセルとブレーキというインターフェースだけで運転できますよね。内部の複雑な仕組みは隠されていて、私たちは決まった操作口からしかアクセスできない——それがカプセル化の本質です。

実装の具体的なイメージ（Java例）

public class BankAccount {
    private int balance; // 残高：外部から直接触れない（private）

    // 残高を確認するための窓口（publicメソッド）
    public int getBalance() {
        return balance;
    }

    // 入金するための窓口
    public void deposit(int amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

残高（balance）に private をつけることで、外部から直接 balance = -99999 のような不正な書き換えを防げます。アクセスは必ず決められたメソッド経由——これがカプセル化の安全装置です。

✅ カプセル化のメリット

• 安全性の確保：外部から直接データを変更できないため、意図しない値の書き換えやバグの混入を防げます。銀行口座の残高が「どこからでも書き換え自由」では困りますよね。それを防ぐのがカプセル化です。
• 保守性の向上：内部実装を変更しても、外部のインターフェース（メソッド名）さえ変えなければ、呼び出し元のコードを修正する必要がありません。変更の影響範囲をクラス内に閉じ込められます。
• チーム開発の効率化：「このクラスはこのメソッドを通じて使う」というルールが明確になるため、担当者ごとの実装の分業がしやすくなります。

⚠️ カプセル化のデメリット・注意点

• コード量が増える：すべての属性に対してgetterやsetterを用意すると、シンプルなデータ構造でもコードが膨らみがちです。過剰なカプセル化は逆に可読性を下げることもあります。
• 設計スキルが求められる：「どこまでprivateにするか」「どのメソッドを公開するか」という判断には設計センスが必要です。初学者のうちは、何でもpublicにしてしまいがちな点に注意しましょう。
• 過剰なカプセル化は逆効果：必要以上に隠蔽すると、テストや外部連携が困難になるケースもあります。「適切に隠す」という感覚が大切です。

カプセル化の3つの結論

• ✅ 結論①：データと処理をひとまとめにすることで、クラスの内部構造を外部から隠蔽できる
• ✅ 結論②：private・publicの使い分けにより、意図しないデータ操作を防ぎ、安全性が高まる
• ✅ 結論③：バグの発生源がクラス内に局所化されるため、デバッグと保守のコストが大幅に下がる

【大項目②】継承 ── コードを「親から子へ」引き継ぐ魔法

継承ってそもそも何？

継承（Inheritance）とは、既存のクラス（親クラス＝スーパークラス）の属性やメソッドを、新しいクラス（子クラス＝サブクラス）が引き継いで使える仕組みです。

日常的な例えで言うと、「乗り物」という大きなカテゴリがあったとして、そこから「自動車」「自転車」「バイク」がそれぞれ派生していくイメージです。どれも「移動できる」という共通の特性（メソッド）を持ちながら、それぞれ固有の動きを持っています。

実装の具体的なイメージ（Java例）

// 親クラス：乗り物
public class Vehicle {
    protected String name;

    public void move() {
        System.out.println(name + "が移動します");
    }
}

// 子クラス：自動車（Vehicleを継承）
public class Car extends Vehicle {
    public Car() {
        this.name = "自動車";
    }

    // 自動車固有の動作を追加
    public void honk() {
        System.out.println("クラクションを鳴らします");
    }
}

Car クラスは Vehicle を継承しているので、move() メソッドをそのまま使えます。同時に、honk() という自動車だけの機能も追加できる。共通部分は親にまとめ、固有部分だけ子に書く——これが継承の美しさです。

✅ 継承のメリット

• コードの再利用性：親クラスに共通処理をまとめることで、同じコードを何度も書く必要がなくなります。修正も親クラス1か所で済むため、変更漏れのリスクが激減します。
• 拡張性の高さ：新しい機能を持つクラスを追加するとき、親クラスを継承するだけで既存の処理を引き継げます。「ゼロから書く」必要がなく、開発スピードが上がります。
• 現実世界のモデル化：「自動車は乗り物である（is-a関係）」という現実の階層構造を、そのままコードで表現できます。設計の意図が伝わりやすくなります。

⚠️ 継承のデメリット・注意点

• 親子の強い結合（密結合）：親クラスの変更が、意図せず子クラスの動作に影響を与えることがあります。「親を直したら子が壊れた」という問題は、継承の深みにはまるほど起きやすくなります。
• 継承の多用は設計を複雑にする：継承の階層が深くなると、どのクラスがどのメソッドを持っているかを追うのが困難になります。「3階層以上の継承は要注意」と現場では言われます。
• is-a関係でない使い方はNG：「コードを流用したいだけ」という理由で継承するのは誤りです。その場合はコンポジション（has-a関係）の利用を検討しましょう。

継承の3つの結論

• ✅ 結論①：親クラスのコードを子クラスで再利用でき、同じ処理を何度も書く「コードの重複」を根本から防げる
• ✅ 結論②：親クラスを修正すれば全子クラスに変更が反映されるため、拡張性・保守性が格段に向上する
• ✅ 結論③：クラス階層を使って現実世界の「is-a関係」を自然にモデル化できる（ただし深い階層は逆効果）

【大項目③】ポリモーフィズム ── 「同じ呼び方、違う動き」の柔軟設計

ポリモーフィズムってそもそも何？

ポリモーフィズム（Polymorphism）とは、同じインターフェース（メソッド名）を通じて、異なるクラスが異なる処理を実行できる仕組みです。「多態性」とも呼ばれます。

日常の例えで言うと、テレビのリモコンの電源ボタンがまさにそれ。どのメーカーのテレビでも「電源ボタンを押す」という操作は同じですが、内部的な処理はメーカーによって異なります。操作する側は「電源ボタンを押す」という統一した手順だけ知っていればいい——それがポリモーフィズムの力です。

実装の具体的なイメージ（Java例）

// 共通の抽象クラス
public abstract class Shape {
    public abstract void draw(); // 共通メソッド
}

// 円クラス
public class Circle extends Shape {
    public void draw() {
        System.out.println("○ 円を描きます");
    }
}

// 四角クラス
public class Rectangle extends Shape {
    public void draw() {
        System.out.println("□ 四角を描きます");
    }
}

// 使う側：Shape型でまとめて扱える！
Shape[] shapes = { new Circle(), new Rectangle() };
for (Shape s : shapes) {
    s.draw(); // 同じ呼び方で、各クラスの処理が動く
}

draw() という同じメソッド名で、円は円の描き方、四角は四角の描き方を実行します。新しい図形クラスを追加しても、使う側のコード（forループ部分）は一切変更不要です。

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

• コードの統一性と可読性：処理の種類が増えても、呼び出し側は「同じメソッドを呼ぶだけ」でよくなります。条件分岐（if-else）だらけのコードが激減し、すっきりと読みやすくなります。
• 拡張に強い設計（開放閉鎖の原則）：新しいクラスを追加するとき、既存のコードを変更せずに機能拡張できます。これはソフトウェア設計の原則「OCP（Open/Closed Principle）」そのものです。
• チーム分業の明確化：インターフェースさえ決めれば、各クラスの実装は別々のメンバーが並行して進められます。大規模開発での生産性向上に直結します。

⚠️ ポリモーフィズムのデメリット・注意点

• 動作の追跡が難しくなる：「このメソッドを呼んだとき、実際にどのクラスの処理が動くのか？」がコードを見ただけではわかりにくくなります。デバッグ時に混乱しやすい点には注意が必要です。
• 過剰な抽象化はかえって複雑に：将来の変更を見越して抽象化を進めすぎると、「何のためのクラスか」がわかりにくくなります。「今必要な抽象化だけを行う（YAGNI原則）」が鉄則です。
• インターフェース設計の質が問われる：共通インターフェースの設計が甘いと、後から修正するコストが大きくなります。設計段階での慎重な検討が必要です。

ポリモーフィズムの3つの結論

• ✅ 結論①：同じメソッド名で異なるクラスの処理を統一的に呼び出せるため、コードのシンプルさと一貫性が保たれる
• ✅ 結論②：新しいクラスを追加しても既存コードを変更する必要がなく、「開放閉鎖の原則」に沿った安全な拡張ができる
• ✅ 結論③：インターフェースを共通化することで、チーム開発での分業が明確になり、並行作業がスムーズになる

【番外編】関数型プログラミングとの違いを理解しよう

そもそも「関数型プログラミング」って何？

オブジェクト指向の対比としてよく挙げられるのが関数型プログラミング（Functional Programming）です。近年、JavaやPythonなどの主要言語にも関数型の特徴が取り入れられ、現場エンジニアにとって避けて通れない概念になっています。

関数型プログラミングの核心は、「データを変更せず、関数を組み合わせて処理を表現する」という考え方です。数学の関数のように「同じ入力には必ず同じ出力が返る（副作用のない処理）」を理想とします。

オブジェクト指向 vs 関数型：考え方の根本的な違い

Javaで見る「OOP的な書き方」vs「関数型的な書き方」

同じ「リストから偶数だけを取り出す」処理を比べてみましょう。

OOP的なアプローチ（命令型）：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evens = new ArrayList<>();

for (int n : numbers) {
    if (n % 2 == 0) {
        evens.add(n); // リストの状態を変化させる
    }
}
// evens → [2, 4, 6]

関数型的なアプローチ（Java Stream API）：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evens = numbers.stream()
    .filter(n -> n % 2 == 0) // 条件を「関数」として渡す
    .collect(Collectors.toList());
// evens → [2, 4, 6]

関数型アプローチは「何をしたいか（What）」を宣言的に記述します。OOP的アプローチは「どうやるか（How）」を手順として記述します。どちらが優れているという話ではなく、場面によって使い分けるのが現代の開発スタイルです。

✅ 関数型プログラミングのメリット

• テストのしやすさ：同じ入力には必ず同じ出力が返るため、ユニットテストが非常にシンプルになります。副作用がないので、テスト環境の準備が最小限で済みます。
• 並行処理との親和性：データを変更しない（イミュータブルな）設計は、複数のスレッドが同じデータを扱う並行処理において競合状態（race condition）を防ぎやすくなります。
• コードの簡潔さ：Stream APIやラムダ式を活用することで、ループや条件分岐を短く宣言的に書けます。意図が伝わりやすく、バグも入り込みにくくなります。

⚠️ 関数型プログラミングのデメリット・注意点

• 学習コストが高い：「イミュータブル」「高階関数」「モナド」など、OOPとは異なる概念体系を習得する必要があります。慣れるまでに時間がかかることが多いです。
• 状態管理が複雑になるケースも：状態の変更を完全に排除しようとすると、逆にコードが複雑になることもあります。現実のビジネスシステムでは、状態を持つことが自然なケースも多いです。
• チームのスキルセットが問われる：チーム全員が関数型の考え方を理解していないと、コードレビューや保守が難しくなります。導入には段階的なアプローチが有効です。

結論：OOPと関数型は「対立」ではなく「補完」の関係

重要なのは「どちらが正しいか」ではありません。現代の開発現場では、OOPと関数型の考え方を組み合わせるハイブリッドアプローチが主流です。

• 大枠の設計・役割分担 → オブジェクト指向で整理
• データ変換・集計処理 → 関数型（Stream/ラムダ）で簡潔に記述

「使い分ける視点」を持つことが、一段上のエンジニアへの近道です。

まとめ ── 3大原則＋αを現場で活かすために

オブジェクト指向の3大特性と関数型プログラミングの要点を整理しましょう。

オブジェクト指向の3原則は、バラバラに覚えるのではなく「セットで使ってはじめて力を発揮する」ものです。カプセル化でデータを守り、継承でコードを再利用し、ポリモーフィズムで柔軟に拡張する。そして、データ処理の場面では関数型の視点を取り入れてさらに洗練させる——この流れを意識するだけで、書くコードの品質がワンランク上がります。

研修の場で「なぜこの書き方をするの？」と感じたとき、ぜひこの4つの視点で問い直してみてください。きっと設計の意図が見えてくるはずです。まずは小さなクラスを一つ作ってみること。それが、オブジェクト指向マスターへの第一歩です。一緒に頑張っていきましょう！💪

「アプリケーションが遅い」「データベースの接続エラーが頻発する」――そんな悩みを抱えていませんか？
多くの原因は、データベースとのやり取りを担うConnectionオブジェクトの不適切な運用にあります。特に、マルチスレッド環境でのJavaアプリケーションでは、その重要性は計り知れません。

はじめまして。システムエンジニアとして、日々多くのJavaアプリケーション開発に携わっている筆者です。
この記事では、私が現場で培ってきた経験と知識に基づき、JDBC接続の核心であるConnectionオブジェクトの「正しい」運用方法を解説します。
この記事を最後まで読めば、あなたのアプリケーションが抱えるデータベース接続の問題を根本から解決し、パフォーマンスと安定性を飛躍的に向上させるための実践的なノウハウが手に入ります。

目次

• なぜConnectionオブジェクトの運用が重要なのか？
• Connectionオブジェクトの3つの運用パターン
• 【実践】Connection Poolを利用した実装例
• まとめ：運用の鍵は「Connection Pool」にあり

なぜConnectionオブジェクトの運用が重要なのか？

「Connectionオブジェクトはなぜスレッドセーフではないのか？」
この問いに答えられないうちは、データベース関連のトラブルから逃れることはできません。

Connectionオブジェクトは、Javaアプリケーションとデータベースをつなぐ「物理的なパイプ」のようなものです。このパイプは一度に一つのスレッドしか通ることができません。
複数のスレッドが同時に同じConnectionオブジェクトを使おうとすると、以下のような問題が発生します。

• 競合状態（Race Condition）：複数の処理が同時にデータベースへ書き込みを行い、意図しないデータが書き込まれる可能性があります。
• データ不整合：あるスレッドがトランザクションを開始した直後に、別のスレッドがそのトランザクションを勝手にコミットしてしまう、といった事態が起こり得ます。
• パフォーマンスの低下：スレッド間で接続オブジェクトの奪い合いが発生し、処理がブロックされて全体のパフォーマンスが著しく低下します。

これらの問題を回避し、アプリケーションの安定性とパフォーマンスを確保するためには、Connectionオブジェクトの運用方針を明確にする必要があります。

Connectionオブジェクトの3つの運用パターン

JDBC接続をマルチスレッド環境で安全に扱うための主な運用パターンは以下の3つに大別できます。

1. スレッドごとに接続を確立・切断する

これは最もシンプルで、直感的に理解しやすい方法です。各スレッドがデータベース操作を行うたびに、独自のConnectionオブジェクトを生成し、操作完了後に閉じます。

メリット：

• 実装が簡単で、スレッドセーフ性を確保しやすい。

デメリット：

• パフォーマンスが悪い。データベースへの接続・切断は非常にコストが高い処理です。アクセスが頻繁なシステムでは、このオーバーヘッドが無視できません。
• 接続数が多くなると、データベースサーバーに大きな負荷がかかる。

このパターンが適しているケース：
バッチ処理など、単発的かつ接続頻度が低いアプリケーション。

2. Connection Poolを利用する

現代のWebアプリケーションや大規模システムでは、この方法がデファクトスタンダードです。
事前に複数のConnectionオブジェクトを生成し、プール（貯蔵庫）に保持しておきます。スレッドが必要な時にプールから接続を借りて、使用後にプールへ返却します。

メリット：

• パフォーマンスが非常に高い。接続の確立・切断コストを大幅に削減できるため、レスポンスタイムが向上します。
• 接続数を制御できるため、データベースへの負荷を管理しやすい。

デメリット：

• 初期設定の学習コストがある。

このパターンが適しているケース：
ほとんどすべてのWebアプリケーション、APIサーバー、常時稼働するシステム。

3. 共有のConnectionオブジェクトを同期する

一つのConnectionオブジェクトを複数スレッドで共有し、同期ブロック（synchronizedなど）でアクセスを制御する方法です。

メリット：

• 使用するConnectionオブジェクトが1つで済む。

デメリット：

• 致命的なパフォーマンスボトルネック。一度に1つのスレッドしかデータベース操作ができないため、他のスレッドはロック解除を待つことになり、並行性が失われます。

このパターンが適しているケース：
原則として、この方法は避けるべきです。

【実践】Connection Poolを利用した実装例

Connection Poolは、アプリケーションの安定と高速化に不可欠です。ここでは、最も人気のあるConnection Poolライブラリの一つ、HikariCPを例に、その使い方を解説します。

前提知識：
MavenやGradleなどのビルドツールでHikariCPの依存関係を追加する必要があります。

手順1：HikariCPの設定

アプリケーション起動時に、Connection Poolを初期化します。設定はプロパティファイルやJavaコードで行うことができます。

// Javaコードでの設定例
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import java.sql.Connection;

public class DataSourceManager {
private static HikariDataSource dataSource;

public static void initDataSource() {
    HikariConfig config = new HikariConfig();
    config.setJdbcUrl("jdbc:mysql://localhost:3306/mydatabase");
    config.setUsername("user");
    config.setPassword("password");
    config.addDataSourceProperty("cachePrepStmts", "true");
    config.addDataSourceProperty("prepStmtCacheSize", "250");
    config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
    dataSource = new HikariDataSource(config);
}

public static HikariDataSource getDataSource() {
    return dataSource;
}
}

手順2：接続の取得と返却

データベース操作を行う際は、HikariDataSourceから接続を取得し、使用後は必ずclose()メソッドを呼び出します。

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class DatabaseOperations {
public void saveUser(String username) {
Connection connection = null;
PreparedStatement ps = null;

    try {
        connection = DataSourceManager.getDataSource().getConnection();
        ps = connection.prepareStatement("INSERT INTO users (username) VALUES (?)");
        ps.setString(1, username);
        ps.executeUpdate();
        // コミット、ロールバックなどのトランザクション管理
        connection.commit(); 
    } catch (SQLException e) {
        // エラーハンドリング
        e.printStackTrace();
        if (connection != null) {
            try {
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }
    } finally {
        // 使用後、必ずclose()を呼び出す
        // このclose()は物理的な接続切断ではなく、プールへの返却を意味する
        try {
            if (ps != null) ps.close();
            if (connection != null) connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
}

実践例：
上記DatabaseOperationsクラスのsaveUserメソッドは、複数のスレッドから同時に呼び出されても安全です。各スレッドはDataSourceManager.getDataSource().getConnection()を呼び出すことで、プールから独立したConnectionオブジェクトを取得するため、競合することはありません。

よくある失敗と注意点：

• close()の呼び忘れ：finallyブロックで必ずconnection.close()を呼び出してください。これを怠ると、プールに接続が返却されず、やがて接続が枯渇してシステムが停止します。
• 静的フィールドへのConnectionの保持：Connectionオブジェクトをクラスの静的フィールドに保持すると、スレッドセーフでなくなります。必ずメソッド内で取得・使用・返却のサイクルを完結させてください。

まとめ：運用の鍵は「Connection Pool」にあり

この記事を通じて、Connectionオブジェクトの運用がアプリケーションのパフォーマンスと安定性に直結することをご理解いただけたかと思います。

結論として、ほとんどすべてのシステムにおいて、Connection Poolを利用することが最も賢明な選択です。

• 接続コストの削減によるパフォーマンス向上
• スレッドセーフな運用によるシステム安定性の確保
• 接続数の制御によるデータベース負荷の適正化

これらのメリットを享受するために、ぜひHikariCPのような堅牢なConnection Poolライブラリの導入を検討してください。正しい知識と技術を身につければ、データベース周りのトラブルは劇的に減少し、より高品質なアプリケーション開発に専念できるはずです。

あわせて読みたい

• Javaにおけるスレッドセーフ性の基礎知識と実践方法
• SQLインジェクションを防ぐ！PreparedStatementの徹底解説

この記事があなたの開発の一助となれば幸いです。もしご質問があれば、お気軽にお問い合わせください。