Transcript JAVA工作平台

程式、程式語言、程式架構



程式語言(Programming Language):
 使用者和電腦之間必一個溝通的工具，讓使用者下達指
示，這個溝通的工具稱為“電腦語言”，它是一種特殊
的語言，以固定的格式，命令電腦做各項動作。
程式(Program):
 針對不同事情所規劃，在不同時間或情形下，由使用者
在事先規劃並且準備好指示電腦去執行的一連串動作。
程式架構:
 學習Java程式一定要知道Java的程式”架構”，”架構”
是指一個Java程式所要包含的部份，就像一台汽車的架
構上要有引擎、輪胎等部份，沒有這些部份汽車就無法
正常運作了。而且屬於架構部份的事物既不能多也不能
少，並且要有一定的位置及方法，稱之為"語法
"(Syntax)。
程式基本架構
// 儲存檔名：c:\Hello.java
// 檔案功能：招呼程式
public class Hello
{
public static void main(String[] args)
{
System.out.println(“嗨，大家好！”);
}
}
Java 程式的基本架構
class Program-Name //程式名 {// 程式內容(Program-Body) }
 程式名稱（Program-Name）：





用來指定特定的一個程式，以區別其它程式，就像車子的車牌號
碼，指定車號，就可以指出某一台車子。
Java程式的名字沒有長度的限制，第一個字可以是英文字母、底
線“_”或錢字號“$”起頭，之後可以跟英文字母、底線、錢字
號及數字
如CodingInJava、Coding_in_java、$500CodingInJava都是合法
的命名。
好的命名習慣，在本書附錄A中，建議了各種Java程式寫作的習慣，
請讀者參考。
程式內容（Program-Body）：

程式內容指定要執行的工作，一定要包含在一對左右大刮弧中
“{ }"，它用以表示程式所要完成的事項。
流程 (Flow)與資料(Data)

程式的內容中，可以分成二大類:描述執行的步驟，稱為"流程"(Flow);
描述處理的對象，在電腦的世界中，就是資料(Data)。
【說明】程式的內容(Program-Body)="流程"(Flow)+"資料"(Data)


一個Java程式（其它程式也都一樣），程式的內容分為兩大部分，
分別是描述要處理的流程及所需的資料，流程部分就是決定內容
如何去運作的相關資料。
我們以到戶政事務所申請戶口名簿作為例子，說明程式的流程和
資料關係,要完成一件事情，只有步驟流程或只帶資料是不夠的，
必須要包含所執行的流程及相關的資料。
輸出字串後跳行

System.out.println(字串);

範例
System.out.println("嗨，大家好！");
int iNumber = 13;
System.out.println("Thirteen = "+iNumber);
System.out.println(1+3+5);
System.out.println('1'+3+5);
System.out.println('1'+(3+5));
//輸出字串資料
//輸出字串與iNumber
//輸出9
//輸出135
//輸出18
輸出字串不跳行

System.out.print(字串);

範例
int iNumber = 13;
System.out.print("Thirteen = ");
System.out.println(iNumber);
//輸出Thirteen=後不跳行
//輸出iNumber值後跳行
流程與資料之範例
01 class DemoArch{
02
public static void main(String args[]) {
03
int Payrate=1385;
//工作時薪
04
final int Hours=24;
//工作時數
05
int Payment;
//給付薪資
06
Payment = Payrate*Hours;
07
System.out.println("My payment is " + Payment + "
dallors.");
08
// 在螢幕上顯現出內容
09
}
10
}
【執行結果】
My payment is 33240 dallors.
流程與資料之範例說明
【範例說明】
[第1行] 命名程式為"DemoArch
[第2行] “public static void main() {” 中“public static void”
是Java的固定語法，main( )是指定此程式被執行時，流程是從這裡
開始，接著的“{” 是指定架構中程式內容的開始。
[第3~5行] int Payrate=1385; int Hours=24; int Payment; 定義
Payrate，Hours、Payment三個整數(int) 資料。Java程式的內容中，
規定要以“;” 放在每個命令的後面表示一個命令的結束。
[第6行] Payment = Payrate*Hours;將工作時薪Payrate乘上工作時數
Hours計算出給付薪資Payment。
[第7行] System.out.println(“My payment is ” + Payment +
“ dallors.”);是在螢幕上印出給付薪資Payment的結果。
[程式第9、10行]"}" 各表示main() 及class 的結束,對應到程式開始
的"{"符號。
Ex2_1_3
總學分費的範例
01.class DemoArch2{
02. public static void main(String args[]) {
03. int PaySchoolScore=3000; //學分費
04. int Number=24;
//學分數
05. int Payment;
//總學分費
06. Payment = PaySchoolScore*Number;
07. System.out.println("我的總學分費共新台幣 "
+Payment + " 元");
08.
// 在螢幕上顯現出內容
09.
}
10. }
Ex2_1_3
總學分費的範例說明
〔第 1 行〕class DemoArch { ， 將程式命名為 "DemoArch“
〔第 2 行〕 public static void main() {
"public static void" 也是 Java 的固定語法。main( ) 是指定此
Java 的應用程式執行時，流程是從這裡開始。接著的 "{" 是指定架構
中程式內容的開始。
〔第 3~5 行〕 int PaySchoolScore=3000;
//學分費
int Number=24;
//學分數
int Payment;
//總學分費
定義 PaySchoolScore、Number、Payment 三個整數 (int) 資料；分別
代表在程式開始執行時學分費預設值為 3000、學分數預設值為 24、而
總學分費的薪資值為未知。在每個命令的後面放置半分號 ";" 表示一個
命令的結束。註解 "//學分費"、"//學分數" 及 "//總學分費"，程式不
會去執行，用以註記前述三個整數資料的用途。
〔第 6 行〕Payment = PaySchoolScore*Number;
本行是本程式唯一的也是最重要的計算部分，將學分費 PaySchoolScore
乘上學分數 Number 計算出總學分費 Payment。
〔第 7~10 行〕System.out.println("我的總學分費共新台幣 " + Payment
+ " 元");
// 在螢幕上顯現出內容
在螢幕上顯示出總學分費計算的結果。
變數與資料型態

資料項目:


變數名稱(簡稱變數Variable):


資料項目的名稱。
變數型態或稱為資料型態(Data Types):


存放計算數值的地方,是程式組成的主要成分。
所儲存資料的型式。
變數宣告（Declare）:




預先說明變數的名字、型態及大小。
把“變數”想像成日常生活中用來存放東西的箱子，存放的內容
就是資料的值。
在使用箱子前，我們需要先知道箱子的名字、大小，箱子是用來
裝甚麼樣子的東西，然後取得所需要數量的箱子，這個過程就是
變數宣告。
範例2-2中的int Payrate=1385是宣告(告訴電腦)有一個變數，它
是用來儲存int (整數)型態資料的箱子（這同時也就知道了箱子
的大小），並命名為Payrate(箱子名)，事先請放入一個整數值為
1385。
保留字

在宣告變數時，變數名稱不可以用到系統已內定的保
留字(Reserved Words) 。

保留字是在電腦語言中保留下來，用以代表特殊意義
的用字。程式設計時要避免把保留字當成變數名稱，
如此才不會與系統產生混淆導致程式執行時發生錯誤。

表2－1列出Java程式所使用的保留字。
保留字
abstract
double
int
strictfp
do
boolean
else
interface
super
while
break
extends
long
volatile
byte
final
native
case
finally
new
switch
synchronize
d
this
catch
float
package
throw
import
char
for
private
throws
instanceof
class
goto
protected
transient
default
const
if
implement
s
public
try
return
void
continue
short
static
變數宣告的語法

【語法】 資料型態

變數名稱[=初始值]；
用來告訴電腦在程式中所會用到變數的三件事情:
型態
 名稱
 〔初始值〕
(註:語法說明內的中括號[ ]，在習慣上表示撰寫程式時，可以存在或不
存在的部分)


【語法說明】




變數宣告中的“資料型態”，是用以指定變數所要儲存之資料值
的類型;
“變數名稱”是指定變數的名字，如Payment；
“[=初始值]”是可以存在或不存在的部份，如在範例中int
Payrate=1385;是初始值存在而符合Java語法的情形。
另int Payment；則是初始值不存的情形，在但也符合Java語法。
基本資料型態

Java語言預先定義好可以直接使用的資料型態，稱為”基本資料型態
“ (Primitive Data Types)，如表2-2示;相對於基本資料型態。

有一種非基本的參考資料型態，會在後續的章節中介紹。

Java語言有八種基本資料型態,分成三類:



整數(integer)
實數(real numbers)
其他(others)
2-2、變數與資料型態
基本資料型態表
基本資料型態名稱
佔用記憶體長
度
最小值
最大值
預設值
整數(integer)
byte（位元組）
8-bit
-128
+127
(byte)0
short（短整數）
16-bit
-2 15
+2 15 – 1
(short)0
int（整數）
32-bit
-2 31
+2 31 – 1
0
long（長整數）
64-bit
-2 63
+2 63 – 1
0L
實數(real number)
float（浮點數）
32-bit
IEEE754
IEEE754
0.0f
double（倍精數）
64-bit
IEEE754
IEEE754
0.0d
‘\u0000’
‘\uFFFF’
‘\u0000’(null)
–
–
false
其他(others)
char（字元）
16-bit
boolean（布林變數） 1-bit
Java基本資料型態說明(一、整數 )

第一類、整數
包含byte(位元組)、short（短整數）、int（整數）、long
（長整數)。可以包含正整數、負整數及0，由所佔用的記憶
體大小，對應出可以表示數值極限的大小。
byte:
 的大小為8位元，用來存放8個位元長度的數字。
所以可表示2的8次方種可能值，對應出來的值為自最小值為
-128到最大值為127共256個值，其中預設值為0 。
short、int、long:
 也可以存放整數，差異為該資料變數的存放空間大小不同，
請對應表2-2的內容，空間大者可以表示的範圍值較大，但
在儲存及執行時所佔用的電腦空間就較大且執行時會耗用較
多的時間。


Java基本資料型態說明(二、實數)
第二類、實數
是用來表示含有小數點數值的資料，包含有float（浮點
數）、double（倍精數）二種資料型態。

float(浮點數-floating point):
 用來表示含有小數數值的方法
若你對浮點數的詳細原理不瞭解，請參考相關電腦基本
概念的書籍。
Double(雙精密度的浮點數):
 通常在科學運算上需要用到數值很大或是精確度很高的
資料，float型態的資料不能符合這項需求時，就可以使
用double的資料型態增加變數可表示及計算的準確度。


Java基本資料型態說明(三、其它)
第三類、其它
包含有有char（字元）及boolean（布林）兩種。
 char(字元):




存放十六位元的國際碼（unicode）內碼
當Java程式在程式中要求將此資料項目以字元型態（char）表現
出來時，電腦會透過一個對照表將所代表字形列印出來。
char佔記憶體的儲存空間大小為16位元，最小值為“\u000 ”；
最大值為“\uFFFF”，也就是國際碼（unicode）的最小值與最大
值。
boolean(布林型態):




表示一個條件成立與否的情形，所以它能表示的值只有代表成立
的真（true）及不成立的偽（false）兩種，
只佔用記憶體長度1個bit
也可代表boolean變數或資料經過“邏輯運算”- 及(and)、或
(or)、否定(not)等所得到的值。
也可以代表“比較運算”-大於(>)、小於(<)及等於(==)等的運算
結果。
Ex2_2_1 Java基本資料型態範例
class DemoMaxVariables {
public static void main(String args[]) {
// integers
byte largestByte = Byte.MAX_VALUE; //位元最大值
short largestShort = Short.MAX_VALUE;
//短整數最大值
int largestInteger = Integer.MAX_VALUE;
//整數最大值
long largestLong = Long.MAX_VALUE; //長整數最大值
// real numbers
float largestFloat = Float.MAX_VALUE;
//浮點數最大值
double largestDouble = Double.MAX_VALUE;
//倍精數最大值
// other primitive types
boolean aBoolean = true;
//布林運算值為真
// display them all
System.out.println("The largest byte value is " + largestByte);
System.out.println("The largest short value is " + largestShort);
System.out.println("The largest integer value is " + largestInteger);
System.out.println("The largest long value is " + largestLong);
System.out.println("The largest float value is " + largestFloat);
System.out.println("The largest double value is " + largestDouble);
System.out.println("The value of aBoolean is " + aBoolean);
}
}
Java基本資料型態範例結果
【執行結果】
The
The
The
The
The
The
The
largest byte value is 127
largest short value is 32767
largest integer value is 2147483647
largest long value is 9223372036854775807
largest float value is 3.4028235E38
largest double value is 1.7976931348623157E308
value of aBoolean is true
Java基本資料型態範例說明
[第1~2行]
宣告為類別“DemoMaxVariables”及方法“main”的宣告。
[第3行]// integers 為註解，說明其後的範例為“整數”相關的說明。
[第4行]宣告一個型態別為byte 的變數由，命名為 largestByte, 初始值設
為Byte.MAX_VALUE 。
【註解】這是一個特殊用法，Java語言預先定義了幾個基本資料型態的物件，
各基本資料型態的最大值各以xxx.Max_VALUE的方式表示，其中xxx所對
應之資料型態的種類各為Byte、Short、Integer、Long、Float、Double
等。
【註解】Java語言提供了許多內定物件並設定了這些內定物件的屬性，所謂
屬性是指一個屬於該物件的一個特徵值，例如範例中，我們藉由使用整
數基本資料型態物件的一個屬性MAX_VALUE，來取得整數資料型態變數值
的最大值。透過“.”這個符號可以存取基本資料型態物件的屬性資料，
用法如 Integer. MAX_VALUE。讀者可以透過程式手冊查詢屬性的名稱及
種類，有關物件及屬性相關的性質會在物件導向程式概念的章節中詳細
介紹。
Java基本資料型態範例說明[續]
[5~10行]short largestShort = Short.MAX_VALUE;//短整數最大值
….
各行指令以xxx.MAX_VALUE的方式取得各種資料型態的最大值並將取
得的最大值設定為每個變數的初始值。
[11~12行]
// other primitive types
boolean aBoolean = true;//布林運算值為真
宣告一個布林型態的變數aBoolean，初始值為ture。
[13~20行]
以System.out.println輸出每個變數的內容。
System.out.println("The largest byte value is " +
largestByte);的作用是在largestByte前加上文字"The largest
byte value is ",然後再列印出結果,程式其它部份和此相似。
範例
01.public class DemoMinVariables{
02.public static void main(String
args[]){
03.// integers
04.byte smallestByte =Byte.MIN_VALUE;
05.//位元最小值
06.short smallestShort = Short.MIN_VALUE;
07.//短整數最小值
08.int smallestInteger =
Integer.MIN_VALUE;
09.//整數最小值
10.long smallestLong = Long.MIN_VALUE;
11.//長整數最小值
12.// real numbers
13.float smallestFloat = Float.MIN_VALUE;
14.//浮點數最小值
15.double smallestDouble=
Double.MIN_VALUE;
16.//倍精數最小值
17. // other primitive types
18.boolean aBoolean = false;//布林運算值
為假
19.
// display them all
20. System.out.println("The smallest byte
value is " + smallestByte);
21. System.out.println("The smallest short
value is " + smallestShort);
22. System.out.println("The smallest intege
value is " + smallestInteger);
23. System.out.println("The smallest long
value is " + smallestLong);
24. System.out.println("The smallest float
value is " + smallestFloat);
25. System.out.println("The smallest doubl
value is " + smallestDouble);
26. System.out.println("The value of
aBoolean is " + aBoolean);
27.
}
28. }
執行結果：
The
The
The
The
The
The
The
smallest
smallest
smallest
smallest
smallest
smallest
value of
byte value is -128
short value is -32768
integer value is -2147483648
long value is -9223372036854775808
float value is 1.4E-45
double value is 4.9E-324
aBoolean is false
<<範例說明>>
〔 4~5 行〕
宣告一個型態別為 byte 的變數，命名為 smallestByte，初始值設
為 Byte.MIN_VALUE。和前例相同，Java 語言預先定義了幾個基本資
料型態的物件，各基本資料型態的最小值各以 xxx.MIN_VALUE 的方
式表示，其中 xxx 為對應各種資料型態，可以是 Byte、Short、
Integer、Long、Float、Double ……等。
〔第 6~16 行〕
以 xxx.MIN_VALUE 的方式取得各種資料型態的最小值並將取得的最
小值設定給每個變數作為初始值。
〔第 17~18 行〕
宣告一個布林型態的變數 aBoolean，初始值為 false。
〔第 19~26 行〕
以 System.out.println 指令輸出各個變數的內容。例如
System.out.println(“The smallest double value is ” +
smallestByte); 的作用是在 smallestByte 前加上文字“The
smallest byte value is ”，然後再列印出結果，程式其它部份和
此行相似。
列印控制字元
說明
Unicode
designation
Character string
Backspace
BS
\b
Backslash
\
\\
Carriage Return
CR
\r
Double Quote
"
\"
Form Feed
FF
\f
Horizontal Tab
HT
\t
Single Quote
'
\'
Unicode Character
0x####
\u####
２－３、 常數
常數是指在程式執行的過程中，值為固定不變的資料項目。例如，
一年中的月份數為12，每天的時數為24，都可以視為常數。在
Java中是以保留字“final”來宣告常數。
【語法】 final 型態 常數名稱[=初始值]；
【語法說明】
 final是常數宣告的保留字不可省略



常數的型態可以是基本資料型態
常數名稱命名時的規則和變數的一樣，並且要注意不可使用
保留字
初始值可以在宣告時決定給或不給，但無初始值時表示在程
式中會給定一個值，而且只會有一次設定的機會，設定後就
不可以再改變
Ex2_3_1
常數範例程式
class DemoConstants {
public static void main(String args[]) {
final int workhour=44;
final int workday;
workday=5;
System.out.println("In the future, labors must work
" + workhour + "
hours in " + workday + " days."); // 在螢幕上顯現
出內容
}
}
【執行結果】
In the future, labors must work 44 hours in 5 days.
Ex2_3_1常數範例程式說明
【範例說明】
第3行: final int workhour=44;
宣告一個常數其型態為int (整數) 命名為 workhour初始值定為
44。
第4行:final int workday;
宣告一個常數其型態也為int 命名為 workday但無初始值。
第5行:workday=5;
將workday的值設定為5。
第6行: System.out.println("In the future, labors must work " +
workhour + " hours in " + workday + " days.");
將結果顯示出來。
２－４、 運算式、運算子和運算元
運算元(Operand):
 表示作用的對象。如範例2-2程式段落Payment=Payrate*Hours中，
Payrate、Payment、Hours等資料變數。
 運算子(Operator):
 表示作用的方式。如“=”(等號)、“*”(乘號) 等。
 運算式(Expression):
 經由運算子，將由常數或變數所代表的運算元經由運算子組合而
成的一列式子。
 Java的運算子分為:
（1）設定(assignment)運算子
（2）算數(arithmetic)運算子
（3）比較(compare)運算子
（4）邏輯(logic)或稱為布林(boolean)運算子四類來說明。

變數的模型



變數的名稱
位址 (左值)
儲存值 (右值)

例如 x=24，其中 "=" (等號) 是設定運算子，電
腦會將數值 24 (右值)，放到變數 x 這個箱子裡。
變數
名稱
位址
儲存
值
例如
X
100
24
設定運算子
設定運算子（assignment operator）
【語法】 變數 = 變數|數值|運算式；
（註: “|” 表示“或”的關係，只要變數、數值或運算式一個以
上存在，就合乎本語法。）
【語法說明】
 使用設定運算子時，運算子(=)左邊只能放變數(箱子)，例
如不能將運算式寫成 x+2=24。而等號的右邊可是一個變數、
數字或組合而成的運算式


例如x=y;x=10;x=x+y;z=3.24;都是可允許的方式，但要注意
等號的左右兩邊的資料型態要一致才行。
設定運算子可與算數運算子、邏輯運算子、比較運算子合併
使用，並以一種精簡的方式來表示，表2-3列出了一些設定
運算子合併其它運算子的精簡表示法。
算術運算符號
符號
功能
範例
+
加法
a = x+y
-
減法
a = x-y
*
乘法
a = x*y
/
除法
a = x/y
%
取餘數
a = x%y
++x
運算前增量
a = ++x + y
X++
運算後增量
a = x++ +y
--x
運算前減量
a = --x + y
X--
運算後減量
a = x-- + y
-x
負號
a = -x
+x
正號
a = +x
關係與邏輯運算符號
符號
==
!=
>
<
>=
<=
!
&&
||
功能
等於
不等於
大於
小於
大於等於
小於等於
邏輯 NOT
邏輯 AND
邏輯 OR
範例
a == b
a != b
a>b
a<b
a >=b
a <= b
!(a=1)
a>1 && a<9
a<1 || a>9
位元運算符號
符號
功能
範例
~
NOT
~x
&
AND
x&y
|
OR
x|y
^
XOR
x^y
>>>
邏輯右移
x>>>y
>>
算術右移
x>>y
<<
算術左移
x<<y
表2-4 運算子合併精簡使用
運算子
使用方式
相當作用的方式
備註
+=
運算元 1 += 運算元
2
運算元 1 = 運算元 1 + 運算
元 2
加
-=
運算元 1 -= 運算元
2
運算元 1 = 運算元 1 - 運算
元 2
減
*=
運算元 1 *= 運算元
2
運算元 1 = 運算元 1 * 運算
元 2
乘
/=
運算元 1 /= 運算元
2
運算元 1 = 運算元 1 / 運算
元 2
除
%=
運算元 1 %= 運算元
2
運算元 1 = 運算元 1 % 運算
元 2
取餘數
&=
運算元 1 &= 運算元
2
運算元 1 = 運算元 1 & 運算
元 2
位元及
|=
運算元 1 |= 運算元
2
運算元 1 = 運算元 1 | 運算
元 2
位元或
^=
運算元 1 ^= 運算元
2
運算元 1 = 運算元 1 ^ 運算
元 2
位元互斥
或
Ex2_4_1
運算子合併精簡使用範
例
class DemoOperators {
public static void main(String args[]) {
int a=20,b=3,c=5;
c *=5;
b +=(2*c)+1;
a %=((c-=18)-1);
System.out.println("a=" + a + ",b=" + b + ",c=" +
c );
}
}
【執行結果】
a=2,b=54,c=7
運算子合併精簡使用範例說明
第3行:int a=20，b=3，c=5；宣告a、b、c三個型態都為整數
變數，透過設定運算子分別設定其初始值為20,3,5。
第4行:c*=5；表示相當於c=c*5的運算式，意義為將c本身的值
乘上5後設定回變數c中。
第5~6行：b +=(2*c)+1; a %=((c-=18)-1);請參考表2-4，該
表列出了程式各行執行時，每個變數變化的值。
第7行: System.out.println("a=" + a + "，b=" + b + "，
c=" + c )；將變數的內容印在螢幕上。
執行行號
運算式\變數
a
b
c
4
c *=5;
20
3
25
5
b +=(2*c)+1;
20
54
25
6
a %=((c-=18)-1);
2
54
7
DemoOperators2.java
01.class DemoOperators2 {
02. public static void main(String args[]) {
03.
int a=75,b=15,c=25;
04.
System.out.println("a=" + a + ",b=" + b
05.
c *=3;
06.
System.out.println("c *=3");
07.
System.out.println("a=" + a + ",b=" + b
08.
a %=b+5;
09.
System.out.println("a %=b+5");
10.
System.out.println("a=" + a + ",b=" + b
11.
b ^=((a &= 18) + (c |= 12));
12.
System.out.println("b ^=((a &= 18) + (c
13.
System.out.println("a=" + a + ",b=" + b
14.
}
15.}
+ ",c=" + c );
+ ",c=" + c );
+ ",c=" + c );
|= 12))");
+ ",c=" + c );
執行結果：
a=75,b=15,c=25
c *=3
a=75,b=15,c=75
a %=b+5
a=15,b=15,c=75
b ^=((a &= 18) + (c |= 12))
a=2,b=94,c=79
在範例 Ex2_4_2 的程式中
□【第 3 行】：先以 int a=75，b=15，c=25；宣告 a、b、c 三個型
態都為整數的變數，透過設定運算子分別設定其初始值為 75，15，
25。
□【第 5 行】：以 c*=3 表示相當於 c=c*3 的運算式，意義為將 c
本身的值乘上 3 後設定回變數 c 中。
□【第 6、9、12 行】：在螢幕上程式各行執行時，每個變數變化的值。
其中 a%-b+5 相當於 a=a%b+5，由於加法優先權高於餘數，所以又相
當於 a=a%(15+16)，則 a=75%20，所以 a=15。
□【第 4、7、10、13 行】：System.out.println(“a=” + a + “，
b=” + b + “，c=” + c )；將變數的內容印在螢幕上。
b^=((a&18)+(c1=12)) 相等於 b=b^((a&=18)+(c1=12))，其中
先將 a 設定為 a&18，a 此時為 15=(01111)2，18=(10010)2，所以
a=(01111)2 & (10010)2 = (00010)2 = 2，再將 c 設定為 c|12，此
時 c 為 75=(1001011)2 ，12=(0001100)2 ，所以 c 設定為
(1001011)2|(0001100)2 =(1001111)2 =79，最後，b 為 15^8| 為
(1111)2^(1010001)2，互斥結果值為 94。
遞增、遞減運算子





“++” (遞增)和“--”(遞減)，隱含有運算完後“設定”的意義。
如x++表示將變數x的值加一後設定回變數x。
“前置”表示執行運算式前將運算元先加一或減一。
“後置”表示先執行運算式，再將運算元加一或減一。
表2-5列出遞增、遞減的使用方式與代表的意義：
遞增、遞減運算子
運算子
使用方式
說明
++ (後置遞增)
運算元++
執行運算式後，再將運算元加一
++ (前置遞增）
++運算元
將運算元先加一，再執行運算式
-- (後置遞減)
運算元--
執行運算式後，再將運算元減一
-- (前置遞減)
--運算元
先將運算元減一，再執行運算式
Ex2_4_3
遞增、遞減運算子範例
class DemoIncreasement {
public static void main(String args[]) {
int a=7,b=3;
int x=0,y=0,z=0;
x=((--a)*3)+2;
y=((b--)+8)*3;
z=6*(a++)+8*(--b);
System.out.println("a=" + a + ",b=" + b + ",x=" +
x+ ",y=" + y+ ",z=" + z );
}
}
【執行結果】
a=7，b=1，x=20，y=33，z=44
遞增、遞減運算子範例說明
【範例說明】
第3~4行：int a=7,b=3; int x=0,y=0,z=0;
 程式一開始宣告整數變數a、b、x、y、z並設定其初始值各為
7,3,0,0,0。
第5行：x=((--a)*3)+2；
 由於--a為前置遞減，所以執行運算式前，先將運算元減一，所以
a的值由7變為6，再將(a*3)+2得到的值設定給x，所以x的值為20，
其它的變數因為都在設定運算的右邊，並沒有設定改變它們的值，
所以維持b為3,y為0,z為0。
第6~7行：y=((b--)+8)*3; z=6*(a++)+8*(--b);
 因為b--為後置遞減，所以先執行運算式，再將運算元變數b減一，
所以先將(b+8)*3得到的值(b的值為3)33設定給y，再將b的值遞減
成2，其它的值也保持不變。其它程式執行時各變數的值表示在表
2-6中，其中(--a)及(--b)為先遞減再作運算，而(b--)及(a++)為
先運算再遞減、遞增。
遞增、遞減運算子範例說明(續)
第8行：System.out.println("a=" + a + ",b=" + b + ",x=" +
x+ ",y=" + y+ ",z=" + z );
 程式System.out.println()分別將變數的內容印在螢幕
上。
範例變數的數值變化
變數
運算式
a
b
x
y
z
x=((--a)*3)+2;
6
3
20
0
0
y=((b--)+8)*3;
6
2
20
33
0
z=6*(a++)+8*(--b);
7
1
20
33
44
DemoIncreasement2.java
01.class DemoIncreasement2 {
02.
public static void main(String args[]){
03.
int a=12;
04.
int x=0,y=0,z=0;
05.
System.out.println("a=" + a + ",x=" + x+ ",y="
+ y+ ",z=" + z);
06.
x=((--a)*3)+2;
07.
System.out.println("x=((--a)*3)+2");
08.
System.out.println("a=" + a + ",x=" + x+ ",y="
+ y+ ",z=" + z);
09.
y=((a--)+8)*3;
10.
System.out.println("y=((a--)+8)*3");
11.
System.out.println("a=" + a + ",x=" + x+
",y=" + y+ ",z=" + z);
12.
z=6*(a++)+8*(--a);
13.
System.out.println("z=6*(a++)+8*(--a)");
14.
System.out.println("a=" + a + ",x=" + x+ ",y="
+ y+ ",z=" + z);
15.
}
16.}
執行結果：
a=12,x=0,y=0,z=0
x=((--a)*3)+2
a=11,x=35,y=0,z=0
y=((a--)+8)*3
a=10,x=35,y=57,z=0
z=6*(a++)+8*(--a)
a=10,x=35,y=57,z=140
範例說明
在範例 Ex2_4_4 中，程式在第 3、4 行宣告整數變數 a、x、
y、z 並設定其初始值各為 12、0、0、0。
然後執行 x=((--a)*3)+2，其中由於 --a 為前置遞減，所以
執行運算式前，先將運算元減一，所以 a 的值由 12 變為 11，
再將 (a*3)+2 得到的值設定給 x，所以 x 的值為 35，其它的變
數並沒有改變它們的值，所以維持 y 為 0，z 為 0。
下一行指令為 y=((a--)+8)*3；因為 a-- 為後置遞減，所以
先執行運算式，再將運算元變數 a 減一，所以先將 (a+8)*3 得
到的值 57 設定給 y，再將 a 的值遞減成 10，其它的值也保持
不變。
算數運算子

算數運算子是用來進行一般的數學運算，例如：加、減、乘、除
等。
表2-8 算數運算子
運算
使用方式
說明
子
運算元1 + 運算元2
運算元1 加上 運算元2
+
-
運算元1 - 運算元2
運算元1 減去 運算元2
*
運算元1 * 運算元2
運算元1 乘上 運算元2
/
運算元1 / 運算元2
運算元1 除以 運算元2
%
運算元1 % 運算元2
運算元1 除以 運算元2的餘數
比較運算子


比較運算子是用來比較兩個運算元的大小 (可以是變數、常數、算式或
是它們的組合)以決定其間關係是否成立，結果是一個只包含“真”或是
“偽”的“布林值”。
若關係成立，用真（true）表示，反之用偽（false）表示，比如說之
5>3是真，10<7是偽。
比較運算子
運算元
使用方式
以下狀況發生時，回應true
>
運算元1 > 運算元2
運算元1 大於 運算元2
>=
運算元1 >= 運算元2
運算元1 大於或等於 運算元2
<
運算元1 < 運算元2
運算元1 小於 運算元2
<=
運算元1 <= 運算元2
運算元1 小於或等於 運算元2
==
運算元1 == 運算元2
運算元1等於 運算元2
!=
運算元1 != 運算元2
運算元1 不等於 運算元2
2-4、 運算式、運算子和運算元
Ex2_4_7 比較運算子範例
class DemoCompare {
public static void main(String[] args) {
int x = 27;
int y = 36; //宣告變數
System.out.println("Variable values as follows...");
System.out.println("
x = " + x);
System.out.println("
y = " + y);
System.out.println("Greater than...");
System.out.println("
x > y is " + (x > y)); //大於
(略)
}
}
【執行結果】
Variable values as follows...
x = 27
y = 36

(略)
比較運算子範例說明




在範例中，int x=27;int y=36;宣告了兩個整數變數
並指定其初始值(x值為27，y值為36)。
接下來先以三行System.out.println( )列出x及y的
值，在螢幕上顯示"Variable values as
follows..."，"x = 27"及"y = 36”。
再用比較運算子決定關係是否成立，由
System.out.println(“Greater than...”);先印出
比較的訊息，System.out.println(“
x > y is ”
+ (x > y));印出“ x > y is”及(x>y)相當於
(27>36)等於false的結果值。
程式其它部份是計算及列印出其它比較的結果，和此
前面的程式片段相似。
邏輯運算子


在真實的世界中，我們常會需要同時判斷幾個條件的組合是否成立，
得到的結果可能會決定後續動作的執行，此時就需要用到邏輯運算
子以組合不同的條件。
邏輯運算子的運算元及判斷的結果，也都是只有真（成立時）或偽
（不成立 ）的布林值，表2-9列出Java語言使用的邏輯運算子：
名稱
運算子
使用方式
結果為真偽之情形及相關說明
條件及
&&
op1 && op2
op1 及 op2 均為真時，結果為真；
op1 為真之條件下才對 op2 取右值
條件或
||
op1 || op2
op1 或 op2 任一為真時，結果為真；
op1 為真之條件下才對 op2 取右值
非
!
! op
及
&
op1 & op2
op1 及 op2 均為真時，結果為真
或
|
op1 ! op2
op1 或 op2 任一為真時，結果為真
互斥或
^
op1 ^ op22
op1、op2 二值相同時 (均為真或均
為偽)，結果為真
op 值為偽時，結果為真
邏輯運算子
在表示的習慣上，我們會把運算元所有真(T)及偽(F)的組合及
邏輯運算的結果，對應在一個表中，稱為真偽值表(truth table)，
如表2-10所示。
運算元1
運算元2
運算元1 && 運算
元2
運算元1 | | 運算元2
! 運算元1
F
F
F
F
T
F
T
F
T
T
T
F
F
T
F
T
T
T
T
F
Ex2_4_9 邏輯運算子範例
class DemoLogic {
public static void main(String args[]) {
boolean x,y;
int i=10;
x= (i >5) && (3>2);
y=( i <5) && (3<2);
System.out.println("x=" + x + ",y=" + y);
}
}
【執行結果】
x=true，y=false
邏輯運算子範例說明
第4行：int i=10;
 程式先宣告整數變數i的初始值為10。
第5行：x= (i >5) && (3>2);
 x設定為(i>5)&&(3>2)的運算過程：



－＞
－＞
真
(i >5) && (3>2)
&&
真
真
第6行：y=( i <5) && (3<2);
 y設定為( i <5) && (3<2)的運算過程：



－＞ 偽
－＞
(i <5) && (3<2)
&& 偽
偽
邏輯運算子範例【註解】
在範例中，我們在使用運算子時，可以用“（）”括號來調整運算式
的優先順序，例如下面的範例：
!(((10<7)||(7 >5)) && ((6>=10)&&(3>2)));
－＞!（（ 偽 || 真） &&（ 偽
&& 真 ））
－＞!（
真
） && （
偽
）
－＞!（真）
－＞ 偽
邏輯運算子和比較運算子常合併使用表示更複雜的判斷；例如，
若電影票價是依照年齡來決定：年齡<18歲，票價為50元；
18≦年齡<60，票價為100元；年齡≧60，票價為70元；則針對
售票規則，我們可以合併應用邏輯運算子和比較運算子來決定
票價 。
邏輯運算子複雜判斷範例
class DemoPrice{
public static void main(String args[]){
int age=53;
int price=0;
if(age<18) price=50;
if(age>=18 && age<60) price=100;
if(age>=60) price=70;
System.out.println("The price is "+ price + " dollars.");
}
【執行結果】
The price is 100 dollars.
邏輯運算子複雜判斷範例說明
第3~4行：int age=53; int price=0;
程式宣告整數變數price及age，並設定age初始值為53歲。
第5~7行：
if(age<18) price=50;
if(age>=18 && age<60) price=100;
if(age>=60) price=70;
if敘述(詳細語法請參考第三章)用來判斷年齡應該屬於哪一段
票價，首先程式執行到if(age<18)，其中(age <18)相當於
(53<18)等於偽，所以其後的指令price=50;不會執行，而下一
個if中(age>=18)&&(age<60) 相當於(53>=18)&&(53<60) ,相
當於(ture)&&(true)，所以結果為true，並設定price=100，
下一個if 的條件為(age>60)相當於(53>60) 等於false，所以
price 的值不會改變。
第8行：System.out.println("The price is "+ price + "
dollars.");
最後程式以System.out.println()將price內容，印在螢幕上。
Ex2_4_12 DemoPrice2.java
01.class DemoPrice2{
02. public static void main(String args[]){
03.
int score=85; //王同學本次考試平均成績
04.
if(score<55)
05.
System.out.println("王同學的考試成績為"+
比不及格" );
06.
if(score>=55 && score<=65)
07.
System.out.println("王同學的考試成績為"+
評比為及格邊緣" );
08.
System.out.println("王同學的考試成績為"+
評比為尚可" );
09.
if(score>80)
10.
System.out.println("王同學的考試成績為"+
評比為高分" );
11. }
12.}
score + "分,評
score + "分,
score + "分,
score + "分,
執行結果
執行結果
王同學的考試成績為 85 分,評比為高分
<<範例說明>>
在範例 Ex2_4_12，程式宣告整數變數 score，
並設定 score 為 85 (分)，利用 if 以及邏
輯比較的語法，來評比王同學的成績是屬於何
種範圍。若改變 score 的值，顯示結果便會
不同。
位元處理運算子
 轉在位元層次處理資料:也就可以想像成先將資料成二進位，
再在二進位位元的每個位址上進行 AND、OR、XOR 等運算。如：
3 AND 6 可轉成二進位 (011)2 & (110)2 = (010)2 為 2 。

例如：典型的電腦控制程式，常以每個位元代表一個開關的狀
態，一個位元組即可表示 8 個開關，可經過另一個位元組形
成的條件選擇要處理的開關，如 (00001001)2，即選擇了第 1
及 4 號開關，再和狀態位元組，如 (00001111) 表示開關現
在狀況為第 1~4 號為開，5~8 號為關，即可使用
(00001001)&(00001111)=(00001001) 找到第 1 及 4 號開關
狀態，而 5~8 號開關則不考慮的結果。
表 2-13 低階邏輯的運算
運算元
使用情形
說明
&
op1 & op2
位元階層的及運算
|
op1 | op2
位元階層的或運算
^
op1 ^ op2
位元階層的互斥或運算
~
~ op
求 op 的補數
型態轉換
型態轉換(Type Conversions)



進行運算時要注意，運算元要配合運算子的規定才可以正常運作，
例如相同型態的資料才可以做比較及數學運算或其它的運算。
以人工計算5+3.154，是習慣而平常的，但電腦進行此計算時就要
包含一連串的動作。
Java程式語言在編譯程式時會檢查資料型態，如果以資料型態不
同的資料作運算，則在編譯時會產生錯誤 。
2-4、 運算式、運算子和運算元
Ex2_4_13 型態轉換範例
class DemoTypeConverse {
public static void main(String[] args) {
int x=3;
double y=2.0;
x=x+y;
System.out.println(x);
}
}
【執行結果】
1 error
(因為X為整數，而Y為雙精密浮點數)
2-4、 運算式、運算子和運算元
型態轉換範例說明
【範例說明】
第3~4行：int x=3; double y=2.0;
宣告了整數變數x及雙精密浮點數變數y(初始值為2.0)
該程式在編譯時產生了錯鋘訊息，如圖2-1所示，“possible loss of
precision”；Java編輯器不能確定是要把整數x轉型成浮點數，還是要
把浮點數y轉型成整數(在做型態轉換時，可能會使資料精密度因轉換而
改變)。此時程式設計師要以人工的方式強迫轉換資料型態才可以解決問
題。
圖2-1 執行結果
Ex2_4_14 強迫型態轉換範例
class DemoManulTypeConverse {
public static void main(String[] args) {
double x=3.0;
int y=2;
x=x+(double)y;
System.out.println(x);
}
}
【執行結果】
5.0
強迫型態轉換範例說明
第5行：x=x+(double)y;


藉由強迫型態轉換後，可避免程式發生錯
誤；
但請注意將儲 存空間大的資料，轉成空間
小者，可能導致資料內容值被捨 去而產生
無徵兆的錯誤結果，所以應避免將較高精確
度的資 料型態轉換成較低精確度的資料型
態(如將浮點數轉成整數) 。
型態轉換原則
1.若有任一運算元為倍精數時，則結果為倍
精數。
2.若不是項目 1 的情形，有任一運算元為浮
點數，則結果為浮點數。
3.若非項目 1、2 的情形，有任一運算元為
長整數時，則結果為長整數。
4.若不是以上 3 種狀況，結果為整數。
表2-14 型態轉換表
byte
short
int
long
char
floot
double
byte
int
int
int
long
int
floot
double
short
int
int
int
long
int
floot
double
int
int
int
int
long
int
floot
double
long
long
long
long
long
long
floot
double
char
Int
int
int
long
int
floot
double
floot
floot
floot
floot
floot
floot
floot
double
double double double double double double double double
[習題]
假設天然瓦斯計費標準如下:若度數<20，瓦斯費為150元;若度數>=20，
瓦斯費為(度數-20)*4+100。設計一Java程式運算式來表示應收的費
用。