大於、小於的運算會了，但如果想要同時進行兩個以上的條件判斷呢？例如分數大於 80 「且」小於 90 的判斷。在邏輯上有 所謂的「且」（And）、「或」（Or）與「反」（Inverse），在 Java 中也提供這幾個基本邏輯運算所需的「邏輯運算子」（Logical operator），分別為「且」（&&）、「或」（||）及「反相」（!）三個運算子。

來看看範例 3.17 會輸出什麼？

public class LogicalOperator {

public static void main(String[] args) {

int number = 75;

System.out.println((number > 70 && number < 80));

System.out.println((number > 80 || number < 75));

System.out.println(!(number > 80 || number < 75));

}

}

三段陳述句分別會輸出 true、false 與 true 三種結果，分別表示 number 大於 70「且」小於 80 為真、number 大於 80「或」小於 75 為假、number 大於 80「或」小於 75 的「相反」為真。

接下來看看「位元運算子」（Bitwise operator），在數位設計上有 AND、OR、NOT、XOR 與補數等運算，在 Java 中提供這些運算的就是位元運算子，它們的對應分別是&（AND）、|（OR）、^（XOR）與~（補數）。

如果您不會基本的位元運算，可以從範例3.18中瞭解各個位元運算的結果。

public class BitwiseOperator {

public static void main(String[] args) {

System.out.println("AND運算：");

System.out.println("0 AND 0\t\t" + (0 & 0));

System.out.println("0 AND 1\t\t" + (0 & 1));

System.out.println("1 AND 0\t\t" + (1 & 0));

System.out.println("1 AND 1\t\t" + (1 & 1));

System.out.println("\nOR運算：");

System.out.println("0 OR 0\t\t" + (0 | 0));

System.out.println("0 OR 1\t\t" + (0 | 1));

System.out.println("1 OR 0\t\t" + (1 | 0));

System.out.println("1 OR 1\t\t" + (1 | 1));

System.out.println("\nXOR運算：");

System.out.println("0 XOR 0\t\t" + (0 ^ 0));

System.out.println("0 XOR 1\t\t" + (0 ^ 1));

System.out.println("1 XOR 0\t\t" + (1 ^ 0));

System.out.println("1 XOR 1\t\t" + (1 ^ 1));

}

}

執行結果就是各個位元運算的結果：

AND運算：

0 AND 0 0

0 AND 1 0

1 AND 0 0

1 AND 1 1

OR運算：

0 OR 0 0

0 OR 1 1

1 OR 0 1

1 OR 1 1

XOR運算：

0 XOR 0 0

0 XOR 1 1

1 XOR 0 1

1 XOR 1 0

Java 中的位元運算是逐位元運算的，例如 10010001 與 01000001 作 AND 運算，是一個一個位元對應運算，答案就是 00000001；而補數運算是將所有的位元 0 變 1，1 變 0，例如 00000001 經補數運算就會變為 11111110，例如下面這個程式所示：

byte number = 0;

System.out.println((int)(~number));

這個程式會在主控台顯示 -1，因為 byte 佔記憶體一個位元組，它儲存的 0 在記憶體中是 00000000，經補數運算就變成 11111111，這個數在電腦中用整數表示則是 -1。

要注意的是，邏輯運算子與位元運算子也是很常被混淆的，像是'&&'與'&'，'||'與 '|'，初學時可得多注意。

位元運算對初學者來說的確較不常用，但如果用的恰當的話，可以增進不少程式效率，例如範例 3.19 可以判斷使用者的輸入是否為奇數：

import java.util.Scanner;

public class OddDecider2 {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.print("請輸入數字: ");

int number = scanner.nextInt();

System.out.println("是否為奇數? " +

((number&1) != 0 ? '是' : '否'));

}

}

執行結果：

請輸入數字: 66

是否為奇數? 否

範例 3.19 得以運作的原理是，奇數的數值若以二進位來表示，其最右邊的位元必為 1，而偶數最右邊的位元必為 0，所以您使用1來與輸入的值作 AND 運算，由於 1 除了最右邊的位元為 1 之外，其它位元都會是 0，與輸入數值 AND 運算的結果，只會留下最右邊位元為 0 或為 1 的結果，其它部份都被 0 AND 運算遮掉了，這就是所謂「位元遮罩」，例如 4 與 1 作 AND 運算的結果會是 0，所以判斷為偶數：

整數4：00000100

整數1：00000001

AND 運算後：00000000

而 3 與 1 作 AND 運算的結果是 1，所以判斷為奇數：

整數3：00000011

整數1：00000001

AND運算後：00000001

XOR 的運算較不常見，範例 3.20 舉個簡單的 XOR 字元加密例子。

public class XorCode {

public static void main(String[] args) {

char ch = 'A';

System.out.println("編碼前：" + ch);

ch = (char)(ch^7);

System.out.println("編碼後：" + ch);

ch = (char)(ch^7);

System.out.println("解碼：" + ch);

}

}

0x7 是 Java 中整數的 16 進位寫法，其實就是 10 進位的 7，將位元與 1 作 XOR 的作用其實就是位元反轉，0x7 的最右邊三個位元為 1，所以其實就是反轉 ch 變數的最後兩個位元，如下所示：

ASCII 中的 'A' 字元編碼為 65：01000001

整數 7：00000111

XOR 運算後：01000110

01000110 就是整數 70，對應 ASCII 中的字元 'F' 之編碼，所以用字元方式顯示時會顯示 'F' 字元，同樣的，這個簡單的 XOR 字元加密，要解密也只要再進行相同的位元反轉就可以了，看看範例 3.20 的執行結果：

編碼前：A

編碼後：F

解碼：A

在位元運算上，Java 還有左移（<<）與右移（>>）兩個運算子，左移運算子會將所有的位元往左移指定的位數，左邊被擠出去的位元會被丟棄，而右邊會補上0；右移運算則是相反，會將所有的位元往右移指定的位數，右邊被擠出去的位元會被丟棄，至於最左邊補上原來的位元，如果左邊原來是 0 就補 0，1 就補 1。另外還有 >>> 運算子，這個運算子在右移後，一定在最左邊補上 0。

範例 3.21 使用左移運算來作簡單的2次方運算示範。

public class ShiftOperator {

public static void main(String[] args) {

int number = 1;

System.out.println( "2的0次: " + number);

number = number << 1;

System.out.println("2的1次: " + number);

number = number << 1;

System.out.println("2的2次: " + number);

number = number << 1;

System.out.println("2的3次：" + number);

}

}

執行結果：

2的0次: 1

2的1次: 2

2的2次: 4

2的3次：8

實際來左移看看就知道為何可以如此作次方運算了：

00000001 -> 1

00000010 -> 2

00000100 -> 4

00001000 -> 8

遞增（Increment）、遞減（Decrement）與指定（Assignment）運算子，老實說常成為初學者的一個惡夢，因為有些程式中若寫得精簡，這幾個運算子容易讓初學者搞不清楚程式的真正運算結果是什麼；事實上，使用這幾種運算子的目的除了使讓程式看來比較簡潔之外，還可以稍微增加一些程式執行的效率。

在程式中對變數遞增1或遞減1是很常見的運算，例如：

int i = 0;

i = i + 1;

System.out.println(i);

i = i - 1;

System.out.println(i);

這段程式會分別顯示出 1 與 0 兩個數，您可以使用遞增、遞減運算子來撰寫程式：

public class IncrementDecrement {

public static void main(String[] args) {

int i = 0;

System.out.println(++i);

System.out.println(--i);

}

}

其中寫在變數 i 之前的 ++ 與 -- 就是「遞增運算子」（Increment operator）與「遞減運算子」（Decrement operator），當它們撰寫在變數之前時，其作用就相當於將變數遞增 1 與遞減 1：

++i; // 相當於 i = i + 1;

--i; // 相當於 i = i - 1;

您可以將遞增或遞減運算子撰寫在變數之前或變數之後，但其實兩種寫法是有差別的，將遞增（遞減）運算子撰寫在變數前時，表示先將變數的值加（減）1，然後再傳回變數的值，將遞增（遞減）運算子撰寫在變數之後，表示先傳回變數值，然後再對變數加（減）1，例如：

public class IncrementDecrement2 {

public static void main(String[] args) {

int i = 0;

int number = 0;

number = ++i; // 相當於i = i + 1; number = i;

System.out.println(number);

number = --i; // 相當於i = i - 1; number = i;

System.out.println(number);

}

}

在這段程式中，number 的值會前後分別顯示為 1 與 0，再看看範例 3.24。

public class IncrementDecrement3 {

public static void main(String[] args) {

int i = 0;

int number = 0;

number = i++; // 相當於number = i; i = i + 1;

System.out.println(number);

number = i--; // 相當於 number = i; i = i - 1;

System.out.println(number);

}

}

在這段程式中，number 的值會前後分別顯示為 0 與 1。

接下來看「指定運算子」（Assignment operator），到目前為止您只看過一個指定運算子，也就是 '=' 這個運算子，事實上指定運算子還有以下的幾個：

| 指定運算子| 範例 | 結果

| :-------- | :----- | :------

| += | a += b | a = a + b

| -= | a -= b | a = a - b

| *= | a *= b | a = a * b

| /= | a /= b | a = a / b

| %= | a %= b | a = a % b

| &= | a &= b | a = a & b

| \|= | a \|= b | a = a \| b

| ^= | a ^= b | a = a ^ b

| <<= | a <<= b | a = a << b

| \>>= | a >>= b | a = a >> b

每個指定運算子的作用如上所示，但老實說若不是常寫程式的老手，當遇到這些指定運算子時，有時可能會楞一下，因為不常用的話，這些語法並不是那麼的直覺。

使用 ++、- - 或指定運算子，由於程式可以直接在變數的記憶體空間中運算，而不用取出變數值、運算再將數值存回變數的記憶體空間，所以可以增加運算的效率，但以現在電腦的運算速度來看，這一點的效率可能有些微不足道，除非您這類的運算相當的頻繁，否則是看不出這點效率所帶來的改善，就現在程式撰寫的規模來看，程式的易懂易讀易維護會比效率來的重要，可以的話儘量將程式寫的詳細一些會比較好，千萬不要為了賣弄語法而濫用這些運算子。

就單一個陳述而言，使用 ++、- - 或指定運算子是還算可以理解，但與其它陳述結合時可就得考慮一下，例如：

int i = 5;

arr[--i %= 10] = 10;

像這樣的式子，要想知道變數 i 是多少，以及陣列的指定索引位置在哪可就得想一下了（有興趣算一下的話，i 最後會是 4，而陣列的指定索引也是 4），總之，如何使用與何時使用，自己得拿捏著點。