決め台詞で覚えるJAVA：Silver・サーティファイ2級に向けて

はじめに：

この記事では、Java Silver & サーティファイ2級レベルの試験に出てくる
修飾子たちを「決め台詞」で覚えちゃおう！というコンセプトでまとめています。

対象の修飾子はこの4つ：

• protected
• static
• final
• abstract

ただの用語暗記に疲れたあなたへ。
ちょっとキャラっぽく、ちょっとドラマチックに。
「あのセリフ＝この修飾子！」って思い出せるように、息抜きしながらの勉強にどうぞ

🎓Javaの修飾子には大きく分けて２種類ある！

カテゴリ	説明
アクセス修飾子	誰から見えるか（公開/非公開）
非アクセス修飾子	その他の性質（継承・静的・抽象…）

🧾全修飾子リスト（Java言語仕様ベース）

✅ アクセス修飾子（4つ）

修飾子	意味
public	どこからでも見える🌍
protected	同じパッケージ＋サブクラスから見える🛡️
private	自クラス内だけ🔒
（デフォルト）	同じパッケージ内だけ（≒package-private）🏠

※この「デフォルト」は修飾子そのものではないけど、
よく「4種類目」として扱われるよ！

✅ 非アクセス修飾子（8つ）

修飾子	対象	意味
static	フィールド/メソッド/内部クラス	クラス単位。インスタンス不要🌀
final	変数/メソッド/クラス	一度だけの代入・継承禁止⛔
abstract	クラス/メソッド	未完成。子に任せる📜
synchronized	メソッド/ブロック	同時実行させない🔒
volatile	フィールド	メモリの一貫性を保証する💾📂（主にスレッド）
transient	フィールド	シリアライズ対象外にする📦🚫
native	メソッド	JavaじゃなくてCとかで書かれてる📛
strictfp	クラス/メソッド	浮動小数点の計算精度を厳密にする📐

修飾子×対象 ざっくり早見表！

対象	使える修飾子の例
クラス	public, abstract, final, strictfp
メソッド	public, private, final, static, abstract, synchronized, native, strictfp
変数	private, final, static, volatile, transient

✅ まず覚えておくべき修飾子

アクセス修飾子（4つ）

→ 絶対出る。完璧に理解しておくと安心！

修飾子	ポイント補足	どこから見えるか
public	クラス・メソッド・フィールドで使う	どこからでも 🌍
private	「カプセル化」ってワードとも関係あり	自クラス内だけ 🔒
protected	クラス継承のときに出てくる	同一パッケージ＋サブクラス 🛡️
デフォルト	これが落とし穴。「何もつけない」とどうなるか？	同一パッケージ内のみ 🏠

✅ 非アクセス修飾子で、優先して覚えるべきもの

修飾子	主に使う場所	意味・理由
static	メソッド、変数、内部クラス	クラス単位で使える。mainがstaticなのが典型例
final	クラス、メソッド、変数	一度だけの代入、継承やオーバーライド禁止
abstract	クラス、メソッド	中身なし＝子クラスで作るルール
synchronized	メソッド、ブロック	同時実行を止める（マルチスレッド制御）

ここで登場した修飾子と一緒にいることの多い「void」
Javaの文法的には void は

💡 「戻り値の型」として使われる予約語（keyword）

つまり、修飾子（modifier）ではない
でも「修飾子たちと仲良く前に並んでるから誤解されやすい」ただの見た目上の罠😵‍💫！
修飾子は「性質を変える」もの、voidは「型」
→ int や String と同じポジション！

💡abstract と同じタイミングで見かけるようになった interface も、クラスや列挙型と同じ「参照型」の仲間！

→ つまり interface も new では作れないけど、
それを実装（implements）したクラスのインスタンスを通して使える「型」としての性質があるよ。

決め台詞で覚える！

プロテクトさんの決め台詞

「外部のクラスには見せたくないんだけど、君には教えちゃう！」

// chapter_1/のAクラス
package chapter_1;

public class A {
    protected int protectedField;
    
    public A() {
        protectedField = 10;
    }
}

// chapter_2/のBクラス
package chapter_2;

import chapter_1.A;  // 別パッケージのサブクラスにはインポートが必要

public class B extends A {
    public B() {
        // protected なフィールドにアクセスできる
        System.out.println(protectedField);  // 10
    }
}

スタティックさんの決め台詞

「私はクラスの意思」

「int count = 0;」：変数→ 「static int count = 0;」： クラス全体で 使える変数

public class Sample {
    static int count = 0; // クラス全体で使えるstatic変数
    
    public static void main(String[] args) {
        System.out.println(count); // ← 使える！
        count++;
        showCount();
    }
    
    static void showCount() {
        System.out.println("カウント: " + count); // ← ここでも使える！
    }
}

staticなものはクラスに直接あるから使える

public class Hello {
    static String greeting = "こんにちは";
    
    static void sayHello() {
        System.out.println(greeting);
    }
}
-------------------------------------------
Hello.sayHello(); // ← newしてない！でもOK！

• インスタンスごとに変化する（動的な）要素ではない
• クラスレベルで一定（静的な）要素
• 「クラスという固定された場所にいる」というイメージ
• クラス名.メソッド名() や クラス名.変数名 で呼べる

状態を持たない機能だけでいい設計（実体が要らない）

public class MathUtil {
    static int square(int x) {
        return x * x;
    }
}

何回呼んでも「x を2乗するだけ」
毎回 new する意味ない！
毎回違う情報を持たなくても、処理だけできればいい。

定数だけのクラス

public class Config {
    static final String VERSION = "1.0.0";
    static final int TIMEOUT = 3000;
}

定数クラスは“アプリ全体に伝えるルール表”みたいなもの。
そこにstatic final(変更不可)な値を並べておけば、誰でもどこでもルールを守れる。

逆に、実体が必要なとき

public class Hero {
    String name;
    int hp;

    void attack() {
        System.out.println(name + "の攻撃！");
    }
}

インスタンス変数

「name」や「hp」などの状態（フィールド）を持つ
インスタンスごとに違う動きをする
✅ だから「newして作る実体（オブジェクト）」が必要！
※ new は自我の確立 ：インスタンスごとに違う状態を持てる。

スタティック変数

アプリ全体で使う値。インスタンスいらない！
※ static に「個」はない。 全体の意志。クラス変数。

ファイナルさんの決め台詞

「私は一度きりの真実。運命を変えることは許さない」

public class FinalDemo {
    public static void main(String[] args) {
        final int destiny = 777;
        System.out.println("運命の数は " + destiny);

        // destiny = 888; // ← これ書いたらエラー！「運命を変えることは許さない」
    }
}

変えようとすると、エラーが出る！！ 🔥

cannot assign a value to final variable 'destiny'

こいつローカル変数なのに上書き禁止だと？！
それが final の本気！
「お前が誰だろうが関係ない。一度決めた値を変えることは許さない。」
final は「アクセス修飾子」ではない「性質を変える修飾子」

オーバーライド禁止

public class Rule {
    public final void declare() {
        System.out.println("この規則は変えてはならない。");
    }
}

class SubRule extends Rule {
    // public void declare() {} ← declare() は上書きできない！
}
----------------------------------------------------------------
📝「オーバーライドしないで使う」ってことは、
全く同じメソッドをもう一度書く必要はないし、
もし書いたら、逆にオーバーライド扱いになってエラーになる！

※全く同じシグネチャで書いたら → ❌ コンパイルエラー！！
※コンピュータは上書き？って反応しちゃう

class SubRule extends Rule {
    // ここには declare() について何も書かなくても親のメソッドを呼び出せる
    // mainメソッドに SubRule obj = new SubRule(); でインスタンス化したら obj.declare() は普通に使えるよ！
}

オーバーロードはできる！

public class FinalOverloadExample {
    
    public final void sayHello() {
        System.out.println("こんにちは！");
    }

    // オーバーロード（引数があるバージョン）
    public void sayHello(String name) {
        System.out.println("こんにちは、" + name + "さん！");
    }
    
    public static void main(String[] args) {
        FinalOverloadExample ex = new FinalOverloadExample();
        ex.sayHello(); // ← finalなやつ
        ex.sayHello("ねこ"); // ← オーバーロードされた別のやつ
    }
}

引数が違う → 別のメソッドとしてコンパイルされる
オーバーロード先で final を付けることもできる

public class Greet {
    public final void sayHello() {
        System.out.println("こんにちは！");
    }

    public final void sayHello(String name) {
        System.out.println("こんにちは、" + name + "さん！");
    }
}

「私の言葉を上書きすることは許さん。
だが……新たな言い方で語るなら、聞こう。」

💡 基本データ型（int, double, booleanなど）は、一度代入したらその値は絶対に変えられない。
💡 でも 参照型（List, TreeSet, などのオブジェクト）は 「どのオブジェクトを参照するか」は変えられない が、そのオブジェクトの中身は自由に操作できる！

アブストラクトさんの決め台詞

abstract：「お前のやり方で、これを完成させるんだ」
subclass：「ええ…先代のやり方は？」
abstract：「 自分のやり方をつかみ取るんだ 」

abstract class Blueprint {
    abstract void build(); // ← 親方の残した“形なき設計”
}

class Temple extends Blueprint {
    @Override
    void build() {
        // ここで魂の受け継ぎ
        System.out.println("…俺のやり方で、親方の志を形にします！");
    }
}

abstract は「未完成の設計書」
サブクラスは「志を受け継ぐ弟子」

📜 セリフ × 修飾子対応表（詠唱モード）

セリフ	解釈	Javaでの意味
「お前のやり方で、これを完成させるんだ」	弟子へのバトン	サブクラスで @Override
「ええ…先代のやり方は？」	弟子の迷い	抽象メソッドは中身が無い！
「自分のやり方をつかみ取るんだ」	自立と創造の始まり	実装を書くのは弟子次第！

abstractで理解しておきたいこと

• アブストラクト修飾子はクラスとメソッドにつく。
• アブストラクト修飾子は未完成の印、new できない。
• アブストラクトクラスには、抽象メソッドと具象メソッドどちらも書くことができる。
  • 抽象メソッドだけでもOK
  • 抽象メソッド・具象メソッド、両方でもOK
  • 具象メソッドだけでもOK（インスタンス化させない意図：継承専用にしたいときに使われる）
• アブストラクトクラスはコンストラクタやフィールドも持てる。
• アブストラクトクラスを継承したサブクラスは抽象メソッドを実装するルール。

アブストラクトクラス

abstract class Wizard {
    void chant() {
        System.out.println("ファイアボール！");
    }

    abstract void castSpell(); // ← これは未実装！
}

サブクラス

class LazyWizard extends Wizard {
    @Override
    void castSpell() {
        // とりあえず空実装、chantはそのまま使いたいだけ
    }
}

使わない抽象メソッドを空実装でもOK！空実装でも「実装」はしなきゃいけない。
具象メソッドを変更なしで使うだけなら何も書かなくていい。

mainメソッドなどから呼び出す

LazyWizard wiz = new LazyWizard();
wiz.chant(); // ← OK！具象メソッドはそのまま使える✨

サブクラスの名前でインスタンス化しても親クラスのメソッドを呼び出せる。
継承していれば、親のメソッドもサブクラスに“ついてくる”ため、書き直さなくてもOK。

最後に：ここまで読んでいただき、ありがとうございます。

synchronizedは構造（マルチスレッド）や概念が絡むので、別枠でまとめる予定です。