Javaのインスタンスメソッドとstaticメソッドの違いとは?具体例で解説【Bronze対策】

こんにちは。
 
先日、Java Bronzeの試験勉強を行っていた内定者から「staticっていつ付けるんですか?」「インスタンスメソッドと何が違うんですか?」と質問がありました。インスタンスメソッドとstaticメソッドの違いは、Javaのクラスとオブジェクトの考え方を理解するうえで重要なポイントです。
 
この記事では、具体的なコード例を使って、インスタンスメソッドとstaticメソッドの違いを分かりやすく解説します。

インスタンスメソッドとは?

インスタンスメソッドとは、new演算子で生成したインスタンス(オブジェクト)に対して呼び出すメソッドです。具体的には、以下の特徴があります。

  • newで生成したインスタンスに対して呼び出す
  • インスタンス変数(フィールド)を参照・変更できる
  • オブジェクトごとに異なる状態を持つ処理に向いている

 
簡単な例:

class Person {
    String name;  // インスタンス変数

    // インスタンスメソッド
    void greet() {
        System.out.println("こんにちは、" + name + "です");
    }
}

public class Main {
    public static void main(String[] args) {
        Person taro = new Person();
        taro.name = "太郎";
        taro.greet();  // インスタンスメソッドを呼び出し
        
        Person hanako = new Person();
        hanako.name = "花子";
        hanako.greet();  // 別のインスタンスで呼び出し
    }
}

出力結果:
こんにちは、太郎です
こんにちは、花子です

この例では、greet()はPersonクラスから生成されたインスタンスに紐づいた振る舞いです。太郎さんと花子さんはそれぞれ独立したインスタンスで、それぞれ異なる名前を持っています。

staticメソッドとは?

staticメソッドとは、クラスそのものに紐づいたメソッドです。具体的には、以下の特徴があります。

  • インスタンスを生成しなくても呼び出せる
  • インスタンス変数を直接扱えない
  • 特定のインスタンスの状態に依存しない共通処理に向いている

 
簡単な例:

class MathUtil {
    // staticメソッド
    static int add(int a, int b) {
        return a + b;
    }
    
    static int multiply(int a, int b) {
        return a * b;
    }
}

public class Main {
    public static void main(String[] args) {
        // インスタンスを作らずに呼び出せる
        int result1 = MathUtil.add(3, 5);
        System.out.println("3 + 5 = " + result1);
        
        int result2 = MathUtil.multiply(4, 6);
        System.out.println("4 × 6 = " + result2);
    }
}

出力結果:
3 + 5 = 8
4 × 6 = 24

add()やmultiply()は、どのインスタンスにも依存しない計算処理なので、staticが適しています。わざわざ`new MathUtil()`としてインスタンスを作る必要はありません。

具体例で理解を深める

カウンターを例に、2つのメソッドの違いをより深く理解しましょう。

class Counter {
    int count = 0;  // インスタンス変数:それぞれのカウンターが持つ
    static int totalCount = 0;  // static変数:すべてのカウンターで共有
    
    // インスタンスメソッド:このカウンターを1増やす
    void increment() {
        count++;
        totalCount++;
    }
    
    // インスタンスメソッド:このカウンターの値を表示
    void showCount() {
        System.out.println("このカウンター: " + count);
    }
    
    // staticメソッド:全体のカウント数を表示
    static void showTotalCount() {
        System.out.println("全体の合計: " + totalCount);
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        
        // それぞれのカウンターを操作
        c1.increment();
        c1.increment();
        c1.showCount();  // このカウンター: 2
        
        c2.increment();
        c2.showCount();  // このカウンター: 1
        
        // 全体の合計を確認(staticメソッド)
        Counter.showTotalCount();  // 全体の合計: 3
    }
}

出力結果:
このカウンター: 2
このカウンター: 1
全体の合計: 3

この例から分かるように、

  • インスタンスメソッド(increment、showCount)は、「そのカウンター」だけを操作します
  • staticメソッド(showTotalCount)は、すべてのカウンターに共通する情報を扱います

なぜstaticメソッドからインスタンス変数を使えないのか?

初心者がつまずきやすい重要なポイントです。

class Sample {
    int value = 10;  // インスタンス変数

    static void foo() {
        // System.out.println(value); // ❌ コンパイルエラー!
    }
}

なぜエラーになるのでしょうか? 理由は2つあります。

理由1:どのインスタンスのvalueか分からない

public class Main {
    public static void main(String[] args) {
        Sample s1 = new Sample();
        s1.value = 10;
        
        Sample s2 = new Sample();
        s2.value = 20;
        
        // Sample.foo()を呼んだとき、valueは10か、20か。どっち?
        Sample.foo();
    }
}

staticメソッドは特定のインスタンスに紐づいていないため、「どのインスタンスのvalueを使えばいいのか」が決まりません。

理由2:インスタンスが存在しない状態でも呼び出せる

public class Main {
    public static void main(String[] args) {
        // インスタンスを1つも作っていない状態で呼び出せる
        Sample.foo();
        
        // この時点では、valueを保持するインスタンスが存在しない!
    }
}

staticメソッドは特定のインスタンスに紐づいていないため、インスタンスが生成されているかどうかに関係なく、インスタンス変数を直接参照することはできません。
 
解決方法:インスタンスを渡す
 
もしstaticメソッドからインスタンス変数を使いたい場合は、インスタンスを引数として渡します。
class Sample {
    int value = 10;

    static void foo(Sample s) {
        System.out.println(s.value);  // ✅ OK! どのインスタンスか明確
    }
}

public class Main {
    public static void main(String[] args) {
        Sample s = new Sample();
        Sample.foo(s);  // インスタンスを渡す
    }
}

逆は可能:インスタンスメソッドからstaticメソッドは呼べる

class Sample {
    int value = 10;  // インスタンス変数
    static int count = 0;  // static変数
    
    void instanceMethod() {
        // ✅ インスタンス変数を使える
        System.out.println(value);
        
        // ✅ static変数も使える
        System.out.println(count);
        
        // ✅ staticメソッドも呼べる
        staticMethod();
    }
    
    static void staticMethod() {
        System.out.println("staticメソッド");
        // System.out.println(value); // ❌ インスタンス変数は使えない
    }
}

インスタンスメソッドは「特定のインスタンスから」呼ばれるため、インスタンス変数もstatic変数も両方使えます。

Java Bronze試験対策のポイント

試験でよく問われるポイントをまとめます。

ポイント1:呼び出し方の違い

class Example {
    void instanceMethod() {
        System.out.println("インスタンスメソッド");
    }
    
    static void staticMethod() {
        System.out.println("staticメソッド");
    }
}

public class Main {
    public static void main(String[] args) {
        // staticメソッドはクラス名で呼び出す
        Example.staticMethod();  // ✅ OK
        
        // インスタンスメソッドはインスタンスが必要
        // Example.instanceMethod();  // ❌ エラー!
        
        Example obj = new Example();
        obj.instanceMethod();  // ✅ OK
        obj.staticMethod();  // ✅ OK(推奨されないが可能)
    }
}

ポイント2:staticから非staticは直接呼べない

class Test {
    void instanceMethod() {
        System.out.println("インスタンスメソッド");
    }

    static void staticMethod() {
        // instanceMethod();  // ❌ コンパイルエラー!
        
        // ✅ インスタンスを作れば呼べる
        Test t = new Test();
        t.instanceMethod();
    }
}

ポイント3:mainメソッドはstatic

public class Main {
    public static void main(String[] args) {
        // なぜmainはstaticなのか?
    }
}

従来のJavaの標準的なプログラム起動方法では、JVMがインスタンスを生成せずにmainメソッドを呼び出します。そのため、mainメソッドはstaticで宣言します。

ポイント4:static変数は共有される

class Counter {
    static int count = 0;  // static変数
    
    void increment() {
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        
        c1.increment();
        c2.increment();
        c1.increment();
        
        // countはすべてのインスタンスで共有される
        System.out.println(Counter.count);  // 3
    }
}

ポイント5:staticメソッドはオーバーライドできない(同名のstaticメソッドを定義した場合は隠蔽となる)

親クラスと子クラスで同じシグネチャのstaticメソッドを定義した場合、オーバーライドではなく隠蔽となります。

class Parent {
    static void show() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    static void show() {
        System.out.println("Child");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent.show();  // Parent
        Child.show();   // Child
    }
}

staticメソッドはオーバーライドではなく隠蔽となるため、インスタンスメソッドのような実行時のポリモーフィズムは適用されません。

まとめ

インスタンスメソッドとstaticメソッドの違いは、次の一点に集約できます。
 
インスタンスメソッド
→ オブジェクトに紐づいた振る舞い(そのオブジェクト固有の処理)
 
staticメソッド
→ クラス全体に共通の処理(どのインスタンスにも依存しない処理)
 
Javaでは、以下の2つの質問を自分に問いかけることで、自然に使い分けられるようになります。
 
1. 「このメソッドは、オブジェクトの状態を使うか?」
2. 「この処理は、クラス全体で1つあれば十分か?」
 
最初は「なぜstaticを使うのか?」と疑問に思うかもしれません。しかし、実際のプロジェクトでは、状態を持たない共通処理をまとめたユーティリティクラスや、クラス全体で共有する情報を管理する場面が頻繁にあります。
 
インスタンスメソッドとstaticメソッドの使い分けは、「個別のモノ」として扱うか、「共通の道具」として扱うかという設計の選択です。この違いを理解することで、より良いJavaプログラムを書けるようになります。
 
 
 
 
《関連記事》

StringとStringBuilderの違い
技術
2026.7.15(Wed)

【初心者向け】JavaのStringとStringBuilderの違いとは? 図で理解する参照の仕組み

#プログラム#Java

extendsの使い方をわかりやすく解説
技術
2026.8.14(Fri)

Javaの継承とは? 初心者向けにextendsの使い方をわかりやすく解説

#プログラム#Java

クラスとオブジェクトの違いを例えで解説
技術
2026.11.10(Tue)

Javaのオブジェクト指向とは? クラスとオブジェクトの違いを例えで解説

#プログラム#Java

記事をシェア
MOST VIEWED ARTICLES