• Xでシェア
  • LINEでシェア
  • このエントリーをはてなブックマークに追加

これで迷わない！Java論理演算子-使い方と条件分岐の実践パターン総まとめ

  • Java
最終更新日:

この記事のポイント

Java論理演算子は、プログラミングの基本的な制御構造を作る上で欠かせない要素です。

この記事を読むと、次のようなことが身に付きます。

  • 条件分岐やループを制御する論理演算子（&&、||、!）の使い方がわかる
  • 短絡評価（ショートサーキット）の仕組みと機能とメリットがわかる
  • 複数の条件を組み合わせた、複雑な判断ロジックを簡潔に表現するイメージが湧く
  • 三項演算子と組み合わせて、シンプルな条件分岐をたった1行で書く方法を知る
  • 実際のアプリケーション開発で使える、論理演算子の実践パターンを知る

この記事を通して、論理演算子の使い方をマスターすれば、より洗練されたJavaコードを書けるようになるはずです。

日常的に遭遇する条件判断を、効率的かつ読みやすいコードで表現できるスキルを身に付けましょう。

目次

Javaの論理演算子とは？

論理演算子は、「はい（真）」か「いいえ（偽）」（プログラムでは「true」か「false」）を判断するための道具です。

日常生活でも私たちは「AかつB」「AまたはB」「Aではない」といった考え方をしていますよね。これをプログラムの中で表現するのが論理演算子です。例えば、「雨が降っていて、寒い日」を考えてみましょう。この条件は「雨が降っている」と「寒い」の両方が「はい」の場合に成り立ちます。

Javaでは、これを次のように書きます。

「isRaining && isCold」

具体的な論理演算子を見てみましょう。Javaで使う主な論理演算子は3つです。

  1. AND演算子（&&）：両方の条件が真の場合にのみ、全体が真になります
  2. OR演算子（||）：少なくともどちらか一方の条件が真なら、全体が真になります
  3. NOT演算子（!）：条件の真偽を反転させます（真なら偽に、偽なら真になります）

上記3つの演算子は、「もし〜なら、〜する」（if文）や「〜の間、繰り返す」（while文やfor文）など、プログラムの流れを決める部分でよく使います。一般的には条件分岐（if文）やループ（while文やfor文）と言われます。

また、Javaの賢いところは、無駄な判断をしないことです。例えば、「雨が降っていなくて、かつ寒い」という条件で、既に「雨が降っていない」ことがわかったら、「寒い」かどうかを確認する必要はないですよね。Javaもそのように動作します。このような動作を「短絡評価」と呼びます。こうすることで、プログラムの動作が速くなるというメリットがあります。

【関連】
Javaをもっと詳しく学ぶならpaizaラーニング

基本構文

Javaの論理演算子の使い方は、とてもシンプルです。
実際の構文を見てみましょう。

// AND演算子の例 boolean result = true && false; // false（両方trueの場合のみtrueになる） // OR演算子の例 result = true || false; // true（どちらか一方がtrueならtrueになる） // NOT演算子の例 result = !true; // false（真偽を反転させる）

出力結果を画面に表示してみましょう。

public class Main { public static void main(String[] args) { // AND演算子の例 boolean result = true && false; // false（両方trueの場合のみtrueになる） // OR演算子の例 result = true || false; // true（どちらか一方がtrueならtrueになる） // NOT演算子の例 result = !true; // false（真偽を反転させる） System.out.println("AND演算結果: " + (true && false)); System.out.println("OR演算結果: " + (true || false)); System.out.println("NOT演算結果: " + (!true)); } }







実行すると、次のように表示されます。
AND演算結果: false
OR演算結果: true
NOT演算結果: false
実用例
Java論理演算子の働きを実際のコード例で見てみましょう。日常生活の身近な事象に置き換えると、とても分かりやすくなります。動物たちの例を使って各演算子の働きを確認してみます。
このコード例を通して、論理演算子がどのようにプログラムの流れを制御するかを学びましょう。
AND演算子（&&）の使用例
AND演算子は、両方の条件が「はい」（true）の場合にのみ全体が「はい」になります。例えば、動物園の入場条件にしたコード例が以下となります。

  
public class Main {
    public static void main(String[] args) {
        boolean isWeekend = true; // 週末である
        boolean isOpen = true; // 動物園は開園している

        if (isWeekend && isOpen) {
            System.out.println("キリンを見に行けます！");
        } else {
            System.out.println("キリンは見られません...");
        }

        // 条件を変えてみる
        isOpen = false; // 動物園は閉園している
        if (isWeekend && isOpen) {
            System.out.println("キリンを見に行けます！");
        } else {
            System.out.println("キリンは見られません...");
        }
    }
}        

  


  







実行結果：
キリンを見に行けます！
キリンは見られません...
この例では、最初は週末（isWeekend = true）で動物園も開いている（isOpen = true）ので、両方の条件が「はい」となり、キリンを見に行けます。しかし、動物園が閉まっていると（isOpen = false）、片方の条件が「いいえ」になるため、結果も「いいえ」になります。
AND演算子は「両方とも満たす必要がある」場合に使います。例えば、「ログインするにはユーザー名とパスワードの両方が正しい必要がある」といった場面です。
OR演算子（||）の使用例
OR演算子は、どちらか一方の条件でも「はい」（true）であれば、全体が「はい」になります。ペットショップの例で考えてみましょう。

  
public class Main {
    public static void main(String[] args) {
        boolean hasDog = false; // 犬は飼っていない
        boolean hasCat = true; // 猫は飼っている

        if (hasDog || hasCat) {
            System.out.println("ペンギンを買いに行きましょう！");
        } else {
            System.out.println("動物はいりません。");
        }

        // 両方falseの場合
        hasCat = false; // 猫も飼っていない
        if (hasDog || hasCat) {
            System.out.println("ペンギンを買いに行きましょう！");
        } else {
            System.out.println("動物はいりません。");
        }
    }
}

  


  







実行結果：
ペンギンを買いに行きましょう！
動物はいりません。
この例では、最初は犬は飼っていないが、猫は飼っている状態です。OR演算子は「どちらか一方でもtrue」なら全体がtrueになるので、「ペンギンを買いに行きましょう！」が表示されます。次に、犬も猫も飼っていない（両方false）状態にすると、条件全体がfalseになるため「動物はいりません。」が表示されます。
OR演算子は「少なくともどちらか一つの条件を満たす」場合に使います。例えば、「学生証または社員証を持っていれば入場できる」といった場合に便利です。
NOT演算子（!）の使用例
NOT演算子は、条件の結果を逆にします。「はい」を「いいえ」に、「いいえ」を「はい」に変えます。
動物の睡眠状態を例に、コード例を見てみましょう。

  
public class Main {
    public static void main(String[] args) {
        boolean isAwake = true; // ライオンは起きている

        if (!isAwake) { // ライオンが起きていない（寝ている）場合
            System.out.println("ライオンは寝ています。静かに！");
        } else {
            System.out.println("ライオンは起きています。注意して！");
        }

        // 値を変更
        isAwake = false; // ライオンは寝ている
        if (!isAwake) {
            System.out.println("ライオンは寝ています。静かに！");
        } else {
            System.out.println("ライオンは起きています。注意して！");
        }
    }
}

  


  







実行結果：
ライオンは起きています。注意して！
ライオンは寝ています。静かに！
最初のケースでは、ライオンは起きています（isAwake = true）。NOT演算子（!）はこれを逆にして「いいえ」（false）にするので、条件（!isAwake）は false となり、else節の「ライオンは起きています」が表示されます。
次に、ライオンが寝ている状態（isAwake = false）に変えると、NOT演算子によって「はい」（true）になるので、「ライオンは寝ています」が表示されます。
NOT演算子は、条件を簡単に逆転させたいときに便利です。例えば、「ログインしていない場合はログイン画面を表示する」といった場合に使います。
短絡評価の実例
Javaの論理演算子には「短絡評価」という便利な特徴があります。これは、最初の条件だけで結果が決まる場合、2つ目の条件はチェックせずにスキップする機能です。
実際に、コード例で見ていきましょう。パンダのエサやりプログラムを考えてみます。

  
public class Main {
    public static void main(String[] args) {
        boolean isHungry = false; // パンダはお腹が空いていない

        if (isHungry && checkFoodAvailability()) {
            System.out.println("パンダにエサをあげます");
        } else {
            System.out.println("パンダはお腹がすいていないか、エサがありません");
        }

        // パンダが空腹の場合
        isHungry = true; // パンダはお腹が空いている
        if (isHungry && checkFoodAvailability()) {
            System.out.println("パンダにエサをあげます");
        }

    }

    // 別のメソッド
    private static boolean checkFoodAvailability() {
        System.out.println("エサの在庫をチェックしています...");
        return true; // エサはある
    }
}

  


  







実行結果：
パンダはお腹がすいていないか、エサがありません
エサの在庫をチェックしています...
パンダにエサをあげます
最初のケースでは、isHungryがfalseなので、AND演算子（&&）の左側がすでにfalseです。AND演算子は両方がtrueでないと結果がtrueにならないため、右側のcheckFoodAvailability()メソッドは実行されません。そのため、「エサの在庫をチェックしています...」というメッセージは表示されません。
2つ目のケースでは、isHungryがtrueになったので、AND演算子の右側もチェックする必要があります。そのため、checkFoodAvailability()メソッドが実行され、「エサの在庫をチェックしています...」というメッセージが表示されます。
この短絡評価には、次のようなメリットがあります。
    

  1. 無駄な処理を省くことができる（処理速度が向上する）
    2. 

  2. エラーを防ぐことができる（例：nullチェックなど）
    3. 

複合条件の実用例
実際のプログラミングでは、複数の論理演算子を組み合わせて複雑な条件を表現することがあります。動物を分類する例で見てみましょう。

  
public class Main {
    public static void main(String[] args) {
        boolean isMammal = true; // 哺乳類である
        boolean canSwim = true; // 泳げる
        boolean hasWings = false; // 翼はない

        // 「哺乳類で、泳げて、翼がない」動物を判定
        if (isMammal && canSwim && !hasWings) {
            System.out.println("これはイルカかもしれません！");
        } else {
            System.out.println("イルカではないようです。");
        }

        // 条件を変更 - 翼がある場合
        hasWings = true;
        if (isMammal && canSwim && !hasWings) {
            System.out.println("これはイルカかもしれません！");
        } else {
            System.out.println("イルカではないようです。");
        }
    }
}

  


  







実行結果：
これはイルカかもしれません！
イルカではないようです。
この例では、3つの条件を組み合わせています。
    

  1. 哺乳類である (isMammal)
    2. 

  2. 泳げる (canSwim)
    3. 

  3. 翼がない (!hasWings)
    4. 

最初のケースでは、すべての条件が満たされているので「これはイルカかもしれません！」と表示されます。
2つ目のケースでは、翼がある (hasWings = true) ので !hasWings は false となり、条件全体が false になるため「イルカではないようです。」と表示されるのです。
複合条件を使いこなせるようになると、複雑なロジックも簡潔に表現できるようになります。
三項演算子との組み合わせ
論理演算子と三項演算子を組み合わせると、シンプルな条件分岐を一行で書けるので、コードがすっきりします。三項演算子は「条件 ? 真の場合の値 : 偽の場合の値」という形で使います。シンプルな条件分岐を実行したい場合に便利です。

  
public class Main {
    public static void main(String[] args) {
        int temperature = 30; // 気温は30度
        boolean isSunny = true; // 晴れている

        // 気温が25度を超えていて、晴れている場合の動物の行動
        String animalActivity = (temperature > 25 && isSunny)
                ? "カメレオンは日光浴をしています"
                : "カメレオンは木陰で休んでいます";

        System.out.println(animalActivity);

        // 天気を変更してみる
        isSunny = false; // 曇りになった
        animalActivity = (temperature > 25 && isSunny)
                ? "カメレオンは日光浴をしています"
                : "カメレオンは木陰で休んでいます";

        System.out.println(animalActivity);
    }
}

  


  







実行結果：
カメレオンは日光浴をしています
カメレオンは木陰で休んでいます
この例では、「気温が25度を超えていて（temperature > 25）、かつ（&&）晴れている（isSunny）」という条件を三項演算子と組み合わせています。条件がtrueの場合は「カメレオンは日光浴をしています」、falseの場合は「カメレオンは木陰で休んでいます」という文字列がanimalActivityに代入されます。
三項演算子はif-else文の簡略形です。単純な条件分岐であれば、三項演算子を使うとコードが簡潔になり、可読性が向上します。ただし、複雑な条件や処理の場合は、通常のif-else文を使った方が分かりやすいこともあるので、その点は認識しておきましょう。
ビット論理演算子の基本
Javaには通常の論理演算子（&&, ||, !）とは別に、「ビット論理演算子」（&, |）というものもあります。この違いを理解しておくと、いざという場面で役立ちます。ビット論理演算子の最大の特徴は、「短絡評価を行わない」という点です。つまり、条件の左側だけで結果が決まる場合でも、必ず右側の条件も評価します。

  
public class Main {
    public static void main(String[] args) {
        boolean isHerbivore = true;
        boolean isLarge = checkSize(); // このメソッドは必ず実行される

        // ビット論理演算子(&)を使用
        if (isHerbivore & isLarge) {
            System.out.println("この動物はゾウかもしれません");
        } else {
            System.out.println("ゾウではないようです");
        }

        checkSize(); // サイズチェックを実行
        // 草食動物ではない場合
        isHerbivore = false;
        if (isHerbivore & isLarge) {
            System.out.println("この動物はゾウかもしれません");
        } else {
            System.out.println("ゾウではないようです");
        }

    }

    // サイズをチェックするメソッド
    private static boolean checkSize() {
        System.out.println("サイズをチェックしています...");
        return true; // 大きい
    }
}

  


  







実行結果：
サイズをチェックしています...
この動物はゾウかもしれません
サイズをチェックしています...
ゾウではないようです
この例では、isHerbivoreがfalseになっても、checkSize()メソッドが実行されて「サイズをチェックしています...」というメッセージが表示されます。これが通常の論理演算子（&&）だった場合、isHerbivoreがfalseだとcheckSize()は実行されません。
ビット論理演算子は、右側の条件にログ出力やカウンター増加などが含まれており、条件にかかわらずその処理を実行したいような場合に使います。
リアルワールドの条件判定
実際のアプリケーションでは、複数の条件を組み合わせて複雑な判断をすることがよくあります。例えば、動物園のチケット料金の判定について考えてみましょう。

  
public class Main {
    public static void main(String[] args) {
        int age = 10; // 10歳の子ども
        String day = "土"; // 土曜日

        // 条件の定義
        boolean isChild = age < 12; // 12歳未満は子ども
        boolean isSenior = age >= 65; // 65歳以上はシニア
        boolean isWeekend = day.equals("土") || day.equals("日"); // 土日は週末

        // 平日の子どもまたはシニアは半額
        if ((isChild || isSenior) && !isWeekend) {
            System.out.println("うさぎ展示は半額です！");
        } else {
            System.out.println("うさぎ展示は通常料金です。");
        }

        // 平日に変更
        day = "月";
        isWeekend = day.equals("土") || day.equals("日");
        if ((isChild || isSenior) && !isWeekend) {
            System.out.println("うさぎ展示は半額です！");
        } else {
            System.out.println("うさぎ展示は通常料金です。");
        }
    }
}

  


  







実行結果：
うさぎ展示は通常料金です。
うさぎ展示は半額です！
１つ目のケースでは、子ども（isChild = true）だが週末（isWeekend = true）なので、!isWeekendはfalseとなり、全体の条件もfalseになります。そのため、通常料金になります。
2つ目のケースでは、子どもかつ平日（isWeekend = falseのため!isWeekend = true）なので、条件全体がtrueとなり、半額になります。
ちなみに、条件の括弧（）は数学の計算と同じように「括弧の中から先に計算される」というルールです。このように、論理演算子を使うと、複雑なルールも簡潔に表現できます。
よくある質問（Q&A）
Q1. & と &&、| と || の違いは？
A：&& や || は「短絡評価」と呼ばれる方式で、左側の条件だけで結果が決まる場合、右側の式は評価されません。一方で & や | は必ず両方の式を評価します。副作用を伴う処理がある場合は、どちらを使うか注意が必要です。
Q2. 三項演算子と論理演算子を組み合わせるメリットは？
A：三項演算子と論理演算子を組み合わせると、条件分岐を1行でシンプルに書けます。コード量を減らせるので、簡単な条件なら読みやすさも向上します。ただし、複雑な条件を無理に1行で書こうとすると逆に読みにくくなるので、使うのはシンプルなケースに限るのがベストです。
Q3. 複雑な条件で !（NOT） を使うときの注意点は？
A：! を多用すると、条件式の意味が直感的に理解しにくくなることがあります。こうした場合は、括弧で優先順位を明確にしたり、条件を意味のある変数に分けて整理することで、コード全体の読みやすさを保つことが大切です。
Q4. if 文に直接 true / false を返す式を書いてもいい？
A：単純な式であれば、if に直接書くことは問題ありません。一般的な書き方としても許容されています。ただし、式が複雑になると可読性が下がるので、必要に応じてブール変数に分けて整理するとより理解しやすく、安全です。
Q5. String の比較に == を使ってはいけない理由は？
A：== は参照（アドレス）の比較を行うため、文字列の内容が同じでも false になることがあります。文字列の内容を比較したい場合は、必ず equals() を使いましょう。例えば次のように書きます：

  
String a = "hello";
String b = "hello";

if(a.equals(b)) {
    System.out.println("内容は同じです");
}

  



まとめ
Javaの論理演算子は、プログラムの流れを制御する重要な要素です。一般的には、条件分岐やループ制御と言われる役割を果たします。
論理演算子は3種類あります。
    

  • 
AND演算子（&&）：両方の条件が真のときだけ真になる
    • 

  • 
OR演算子（||）：どちらか一方が真なら真になる
    • 

  • 
NOT演算子（!）：真偽を反転させる
    • 

また、Javaにはコードの効率性を向上させる短絡評価という機能があることも学びました。論理演算子は、いわば「プログラムの分かれ道」を作る道具です。
初心者のうちはシンプルな条件から始めて、複合条件や三項演算子など、徐々に複雑な条件判断にも挑戦してみましょう。練習を重ねるうちに、スマートで効率的なコードが書けるようになります。何より、実際にコードを書いて動かしてみることが一番の学びです。
日常のプログラミングで論理演算子を積極的に活用して、Javaプログラミングスキルを磨いていきましょう。
レベルを更に上げたい方はpaizaプログラミングスキルチェックへ





























  1. paizaラーニングトップ
  2. ナレッジ
  3. Javaのナレッジ記事一覧
  4. これで迷わない！Java論理演算子-使い方と条件分岐の実践パターン総まとめ