本章大綱 ２－１、程式、程式語言、程式架構 ２－２、變數與資料型態 ２－３、常數 ２－４、 運算式、運算子和運算元

Presentation on theme: "本章大綱 ２－１、程式、程式語言、程式架構 ２－２、變數與資料型態 ２－３、常數 ２－４、 運算式、運算子和運算元"— Presentation transcript:

1 本章大綱 ２－１、程式、程式語言、程式架構 ２－２、變數與資料型態 ２－３、常數 ２－４、 運算式、運算子和運算元
第一節、程式、程式語言、程式架構 第二章、程式語言基本觀念及資料 本章大綱 ２－１、程式、程式語言、程式架構 ２－２、變數與資料型態 ２－３、常數 ２－４、 運算式、運算子和運算元 [ Java2語言實務 ]

2 ２－１、程式、程式語言、程式架構 ２－１、程式、程式語言、程式架構 [ Java2語言實務 ]

3 ２－１、程式、程式語言、程式架構 程式語言(Programming Language):
第一節、程式、程式語言、程式架構 ２－１、程式、程式語言、程式架構 程式語言(Programming Language): 使用者和電腦之間必一個溝通的工具，讓使用者下達指示，這個溝通的工具稱為“電腦語言”，它是一種特殊的語言，以固定的格式，命令電腦做各項動作。 程式(Program): 針對不同事情所規劃，在不同時間或情形下，由使用者在事先規劃並且準備好指示電腦去執行的一連串動作。 程式架構: 學習Java程式一定要知道Java的程式”架構”，”架構”是指一個Java程式所要包含的部份，就像一台汽車的架構上要有引擎、輪胎等部份，沒有這些部份汽車就無法正常運作了。而且屬於架構部份的事物既不能多也不能少，並且要有一定的位置及方法，稱之為"語法"(Syntax)。 2-1程式、程式語言、程式架構 [ Java2語言實務 ]

4 01. class Program-Name //程式名 02. { 03. // 程式內容(Program-Body) 04. }
Ex2_1_1 Java 程式的基本架構 01. class Program-Name //程式名 02. { 03. // 程式內容(Program-Body) 04. } [ Java2語言實務 ]

5 Java 程式的基本架構 class Program-Name //程式名 {// 程式內容(Program-Body) }
用來指定特定的一個程式，以區別其它程式，就像車子的車牌號碼，指定車號，就可以指出某一台車子。 Java程式的名字沒有長度的限制，第一個字可以是英文字母、底線“_”或錢字號“$”起頭，之後可以跟英文字母、底線、錢字號及數字 如CodingInJava、Coding_in_java、$500CodingInJava都是合法的命名。 好的命名習慣，在本書附錄A中，建議了各種Java程式寫作的習慣，請讀者參考。 程式內容（Program-Body）： 程式內容指定要執行的工作，一定要包含在一對左右大刮弧中“{ }"，它用以表示程式所要完成的事項。 2-1程式、程式語言、程式架構 [ Java2語言實務 ]

6 Ex2_1_2 流程 (Flow)與資料(Data)
第一節、程式、程式語言、程式架構 Ex2_1_2　流程 (Flow)與資料(Data) 程式的內容中，可以分成二大類:描述執行的步驟，稱為"流程"(Flow);描述處理的對象，在電腦的世界中，就是資料(Data)。 【說明】程式的內容(Program-Body)="流程"(Flow)+"資料"(Data) 一個Java程式（其它程式也都一樣），程式的內容分為兩大部分，分別是描述要處理的流程及所需的資料，流程部分就是決定內容如何去運作的相關資料。 我們以到戶政事務所申請戶口名簿作為例子，說明程式的流程和資料關係,要完成一件事情，只有步驟流程或只帶資料是不夠的，必須要包含所執行的流程及相關的資料。 2-1程式、程式語言、程式架構 [ Java2語言實務 ]

7 流程與資料之範例 01 class DemoArch{
02 public static void main(String args[]) { int Payrate=1385; //工作時薪 final int Hours=24; //工作時數 int Payment; //給付薪資 Payment = Payrate*Hours; 07 System.out.println("My payment is " + Payment + " dallors."); 08 // 在螢幕上顯現出內容 } 10 } 【執行結果】 My payment is dallors. 2-1程式、程式語言、程式架構 [ Java2語言實務 ]

8 流程與資料之範例說明 【範例說明】 [第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 的結束,對應到程式開始的"{"符號。 2-1程式、程式語言、程式架構 [ Java2語言實務 ]

9 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 + " 元"); // 在螢幕上顯現出內容 09. } 10. } [ Java2語言實務 ]

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 + " 元"); // 在螢幕上顯現出內容 在螢幕上顯示出總學分費計算的結果。 [ Java2語言實務 ]

11 ２－２、變數與資料型態 ２－２、變數與資料型態 [ Java2語言實務 ]

12 ２－２、變數與資料型態 資料項目: 存放計算數值的地方,是程式組成的主要成分。 變數名稱(簡稱變數Variable): 資料項目的名稱。
變數型態或稱為資料型態(Data Types): 所儲存資料的型式。 變數宣告（Declare）: 預先說明變數的名字、型態及大小。 把“變數”想像成日常生活中用來存放東西的箱子，存放的內容就是資料的值。 在使用箱子前，我們需要先知道箱子的名字、大小，箱子是用來裝甚麼樣子的東西，然後取得所需要數量的箱子，這個過程就是變數宣告。 範例2-2中的int Payrate=1385是宣告(告訴電腦)有一個變數，它是用來儲存int (整數)型態資料的箱子（這同時也就知道了箱子的大小），並命名為Payrate(箱子名)，事先請放入一個整數值為1385。 2-2、變數與資料型態 [ Java2語言實務 ]

13 保留字 在宣告變數時，變數名稱不可以用到系統已內定的保留字(Reserved Words) 。
保留字是在電腦語言中保留下來，用以代表特殊意義的用字。程式設計時要避免把保留字當成變數名稱，如此才不會與系統產生混淆導致程式執行時發生錯誤。 表2－1列出Java程式所使用的保留字。 2-2、變數與資料型態 [ Java2語言實務 ]

14 保留字 表2－1、Java程式所使用的保留字 abstract double int strictfp do boolean else
interface super while break extends long switch volatile byte final native synchronized short case finally new this static catch float package throw import char for private throws instanceof class goto protected transient default const if public try continue implements return void 2-2、變數與資料型態 [ Java2語言實務 ]

15 本書在第 4 章前為基本語法部分，為了要讓讀者有一個一致而清晰的學習方法，所以在介紹 Java 基本語法時，會以
語法單元概念用法的說明 本書在第 4 章前為基本語法部分，為了要讓讀者有一個一致而清晰的學習方法，所以在介紹 Java 基本語法時，會以 【語法】 【語法說明】 【語法範例】 【範例說明】 的方式，說明每一個語法單元的概念和用法 [ Java2語言實務 ]

16 變數宣告的語法 【語法】 資料型態 變數名稱[=初始值]； 用來告訴電腦在程式中所會用到變數的三件事情: 【語法說明】
【語法】 資料型態 變數名稱[=初始值]； 用來告訴電腦在程式中所會用到變數的三件事情: 型態 名稱 〔初始值〕 (註:語法說明內的中括號[ ]，在習慣上表示撰寫程式時，可以存在或不存在的部分) 【語法說明】 變數宣告中的“資料型態”，是用以指定變數所要儲存之資料值的類型; “變數名稱”是指定變數的名字，如Payment； “[=初始值]”是可以存在或不存在的部份，如在範例中int Payrate=1385;是初始值存在而符合Java語法的情形。 另int Payment；則是初始值不存的情形，在但也符合Java語法。 2-2、變數與資料型態 [ Java2語言實務 ]

17 基本資料型態 Java語言預先定義好可以直接使用的資料型態，稱為”基本資料型態“ (Primitive Data Types)，如表2-2示;相對於基本資料型態。 有一種非基本的參考資料型態，會在後續的章節中介紹。 Java語言有八種基本資料型態,分成三類: 整數(integer) 實數(real numbers) 其他(others) 2-2、變數與資料型態 [ Java2語言實務 ]

18 基本資料型態表 基本資料型態名稱 佔用記憶體長度 最小值 最大值 預設值 整數(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 long（長整數） 64-bit -2 63 +2 63 – 1 0L 實數(real number) float（浮點數） IEEE754 0.0f double（倍精數） 0.0d 其他(others) char（字元） ‘\u0000’ ‘\uFFFF’ ‘\u0000’(null) boolean（布林變數） 1-bit – false 2-2、變數與資料型態 [ Java2語言實務 ]

19 Java基本資料型態說明(一、整數 ) 第一類、整數 byte: 的大小為8位元，用來存放8個位元長度的數字。
包含byte(位元組)、short（短整數）、int（整數）、long（長整數)。可以包含正整數、負整數及0，由所佔用的記憶體大小，對應出可以表示數值極限的大小。 byte: 的大小為8位元，用來存放8個位元長度的數字。 所以可表示2的8次方種可能值，對應出來的值為自最小值為-128到最大值為127共256個值，其中預設值為0 。 short、int、long: 也可以存放整數，差異為該資料變數的存放空間大小不同，請對應表2-2的內容，空間大者可以表示的範圍值較大，但在儲存及執行時所佔用的電腦空間就較大且執行時會耗用較多的時間。 2-2、變數與資料型態 [ Java2語言實務 ]

20 Java基本資料型態說明(二、實數) 第二類、實數
是用來表示含有小數點數值的資料，包含有float（浮點數）、double（倍精數）二種資料型態。 float(浮點數-floating point): 用來表示含有小數數值的方法 若你對浮點數的詳細原理不瞭解，請參考相關電腦基本概念的書籍。 Double(雙精密度的浮點數): 通常在科學運算上需要用到數值很大或是精確度很高的資料，float型態的資料不能符合這項需求時，就可以使用double的資料型態增加變數可表示及計算的準確度。 2-2、變數與資料型態 [ Java2語言實務 ]

21 Java基本資料型態說明(三、其它) 第三類、其它 包含有有char（字元）及boolean（布林）兩種。 char(字元):
存放十六位元的國際碼（unicode）內碼 當Java程式在程式中要求將此資料項目以字元型態（char）表現出來時，電腦會透過一個對照表將所代表字形列印出來。 char佔記憶體的儲存空間大小為16位元，最小值為“\u000 ”；最大值為“\uFFFF”，也就是國際碼（unicode）的最小值與最大值。 boolean(布林型態): 表示一個條件成立與否的情形，所以它能表示的值只有代表成立的真（true）及不成立的偽（false）兩種， 只佔用記憶體長度1個bit 也可代表boolean變數或資料經過“邏輯運算”- 及(and)、或(or)、否定(not)等所得到的值。 也可以代表“比較運算”-大於(>)、小於(<)及等於(==)等的運算結果。 2-2、變數與資料型態 [ Java2語言實務 ]

22 Ex2_2_1 Java基本資料型態範例 2-2、變數與資料型態 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); } 2-2、變數與資料型態 [ Java2語言實務 ]

23 Java基本資料型態範例結果 【執行結果】 The largest byte value is 127
The largest short value is 32767 The largest integer value is The largest long value is The largest float value is E38 The largest double value is E308 The value of aBoolean is true 2-2、變數與資料型態 [ Java2語言實務 ]

24 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。讀者可以透過程式手冊查詢屬性的名稱及種類，有關物件及屬性相關的性質會在物件導向程式概念的章節中詳細介紹。 2-2、變數與資料型態 [ Java2語言實務 ]

25 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 ",然後再列印出結果,程式其它部份和此相似。 2-2、變數與資料型態 [ Java2語言實務 ]

26 範例 Ex2_2_2 01.public class DemoMinVariables{ 19. // display them all
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.//倍精數最小值 // 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 integer 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 double value is " + smallestDouble); 26. System.out.println("The value of aBoolean is " + aBoolean); 27. } 28. } [ Java2語言實務 ]

27 執行結果： The smallest byte value is -128
The smallest short value is The smallest integer value is The smallest long value is The smallest float value is 1.4E-45 The smallest double value is 4.9E-324 The value of aBoolean is false [ Java2語言實務 ]

28 <<範例說明>>
〔 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 ”，然後再列印出結果，程式其它部份和此行相似。 [ Java2語言實務 ]

29 列印控制字元 說明 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#### [ Java2語言實務 ]

30 ２－３、 常數 常數是指在程式執行的過程中，值為固定不變的資料項目。例如，一年中的月份數為12，每天的時數為24，都可以視為常數。在Java中是以保留字“final”來宣告常數。 【語法】 final 型態 常數名稱[=初始值]； 【語法說明】 final是常數宣告的保留字不可省略 常數的型態可以是基本資料型態 常數名稱命名時的規則和變數的一樣，並且要注意不可使用保留字 初始值可以在宣告時決定給或不給，但無初始值時表示在程式中會給定一個值，而且只會有一次設定的機會，設定後就不可以再改變 2-3、 常數 [ Java2語言實務 ]

31 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. 2-3、 常數 [ Java2語言實務 ]

32 Ex2_3_1常數範例程式說明 第3行: final int workhour=44;
【範例說明】 第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."); 將結果顯示出來。 2-3、 常數 [ Java2語言實務 ]

33 範例 Ex2_3_2 計算 30 天工資 Ex2_3_2 DemoConstants2.java
01. class DemoConstants2{ 02. public static void main(String args[]) { 03. final int daypayment=3000; 04. final int workday=30; 05. final int money=daypayment*workday; 06. System.out.println("I earn " + daypayment + " everyday, so I earn " + money + " every " + workday + "days."); // 在螢幕上顯現出內容 08. } 09.. } 執行結果： I earn 3000 everyday, so I earn every 30 days. [ Java2語言實務 ]

34 範例 Ex2_3_2 說明 〔第 3 行〕final int daypayment=3000;
〔第 4 行〕final int workday=30; 宣告一個常數其型態也為 int，命名為 workday，其值設定為 30。 〔第 5 行〕final int money=daypayment*workday; 定義 money 的其型態為 int，預設值為 daypayment 與 workday 的乘積。 〔第 6 行〕System.out.println("I earn " + daypayment + " everyday, so I earn " + money + " every + workday + "days)."); 將結果顯示出來。 [ Java2語言實務 ]

35 ２－４、 運算式、運算子和運算元 運算元(Operand): 運算子(Operator): 運算式(Expression):
表示作用的對象。如範例2-2程式段落Payment=Payrate*Hours中， Payrate、Payment、Hours等資料變數。 運算子(Operator): 表示作用的方式。如“=”(等號)、“*”(乘號) 等。 運算式(Expression): 經由運算子，將由常數或變數所代表的運算元經由運算子組合而成的一列式子。 Java的運算子分為: （1）設定(assignment)運算子 （2）算數(arithmetic)運算子 （3）比較(compare)運算子 （4）邏輯(logic)或稱為布林(boolean)運算子四類來說明。 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

36 變數的模型 變數的名稱 位址 (左值) 儲存值 (右值)
例如 x=24，其中 "=" (等號) 是設定運算子，電腦會將數值 24 (右值)，放到變數 x 這個箱子裡。 名稱 變數 位址 儲存值 X 例如 100 24 [ Java2語言實務 ]

37 設定運算子（assignment operator）
【語法】 變數 = 變數|數值|運算式； （註: “|” 表示“或”的關係，只要變數、數值或運算式一個以上存在，就合乎本語法。） 【語法說明】 使用設定運算子時，運算子(=)左邊只能放變數(箱子)，例如不能將運算式寫成 x+2=24。而等號的右邊可是一個變數、數字或組合而成的運算式 例如x=y;x=10;x=x+y;z=3.24;都是可允許的方式，但要注意等號的左右兩邊的資料型態要一致才行。 設定運算子可與算數運算子、邏輯運算子、比較運算子合併使用，並以一種精簡的方式來表示，表2-3列出了一些設定運算子合併其它運算子的精簡表示法。 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

38 表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 位元互斥或 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

39 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 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

40 Ex2_4_1　運算子合併精簡使用範例說明 第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; 54 6 a %=((c-=18)-1); 2 7 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

41 Ex2_4_2 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 + ",c=" + c ); 05. c *=3; 06. System.out.println("c *=3"); 07. System.out.println("a=" + a + ",b=" + b + ",c=" + c ); 08. a %=b+5; 09. System.out.println("a %=b+5"); 10. System.out.println("a=" + a + ",b=" + b + ",c=" + c ); 11. b ^=((a &= 18) + (c |= 12)); 12. System.out.println("b ^=((a &= 18) + (c |= 12))"); 13. System.out.println("a=" + a + ",b=" + b + ",c=" + c ); 14. } 15.} [ Java2語言實務 ]

42 執行結果： 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 [ Java2語言實務 ]

43 在範例 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=( )2 ，12=( )2 ，所以 c 設定為 ( )2|( )2 =( )2 =79，最後，b 為 15^8| 為 (1111)2^( )2，互斥結果值為 94。 [ Java2語言實務 ]

44 遞增、遞減運算子 “++” (遞增)和“--”(遞減)，隱含有運算完後“設定”的意義。 如x++表示將變數x的值加一後設定回變數x。
“前置”表示執行運算式前將運算元先加一或減一。 “後置”表示先執行運算式，再將運算元加一或減一。 表2-5列出遞增、遞減的使用方式與代表的意義： 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

45 遞增、遞減運算子 表 2-6 遞增、遞減運算子 運算子 使用方式 說明 ++ (後置遞增) 運算元++ 執行運算式後，再將運算元加一
++ (前置遞增） ++運算元 將運算元先加一，再執行運算式 -- (後置遞減) 運算元-- 執行運算式後，再將運算元減一 -- (前置遞減) --運算元 先將運算元減一，再執行運算式 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

46 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 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

47 遞增、遞減運算子範例說明 【範例說明】 第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++)為先運算再遞減、遞增。 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

48 遞增、遞減運算子範例說明(續) 第8行：System.out.println("a=" + a + ",b=" + b + ",x=" + x+ ",y=" + y+ ",z=" + z ); 程式System.out.println()分別將變數的內容印在螢幕上。 表2-7 範例變數的數值變化 變數 運算式 a b x y z x=((--a)*3)+2; 6 3 20 y=((b--)+8)*3; 2 33 z=6*(a++)+8*(--b); 7 1 44 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

49 Ex2_4_4 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=" 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=" 15. } 16. } [ Java2語言實務 ]

50 執行結果： a=12,x=0,y=0,z=0 x=((--a)*3)+2 a=11,x=35,y=0,z=0 y=((a--)+8)*3
z=6*(a++)+8*(--a) a=10,x=35,y=57,z=140 [ Java2語言實務 ]

51 範例說明 在範例 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，其它的值也保持不變。 [ Java2語言實務 ]

52 算數運算子 算數運算子是用來進行一般的數學運算，例如：加、減、乘、除等。 表2-8 算數運算子 運算子 使用方式 說明 +
運算元1 + 運算元2 運算元1 加上 運算元2 - 運算元1 - 運算元2 運算元1 減去 運算元2 * 運算元1 * 運算元2 運算元1 乘上 運算元2 / 運算元1 / 運算元2 運算元1 除以 運算元2 % 運算元1 % 運算元2 運算元1 除以 運算元2的餘數 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

53 Ex2_4_5 算數運算子範例 class DemoMath {
public static void main(String args[]) {        int x,y,z,q; int I=9; int mod; int J=3; x=I+J; //x=12 y=I-J; //y=6 z=I*J; //z=27 q=I/J; //q=3 mod=19%5; //mod=4 System.out.println("x=" + x + ",y=" + y + ",z=" + z + ",q=" + q+ ",mod=" + mod);    } 【執行結果】 x=12,y=6,z=27,q=3,mod=4 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

54 算數運算子範例說明 第3~6行：int x,y,z,q;int I=9;int mod; int J=3;程式開始宣告整數變數x, y, z, q, I=9, J=3及mod。 第7行：x=I+J; //x=12 進行數學運算，將x的值設定成I+J的結果，所以x=9+3等於12。 第8~11行：y=I-J; //y=6 z=I*J; //z=27 q=I/J; //q=3 mod=19%5; //mod=4 將y設定為I-J相當於9-3等於6，z設定為I*J相當於9*3等於27，q設定為I/J相當於9/3等於3，最後以19除以5的餘數4設定給變數mod。 第12行： System.out.println("x=" + x + ",y=" + y + ",z=" + z + ",q=" + q+ ",mod=" + mod); 以System.out.print( )列印出結果。 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

55 Ex2_4_6 DemoMath2.java 01 class DemoMath2{
02. public static void main(String args[]) { 03. int x=5; 04. int y=7; 05. int a=9; 06. int b=20; 07. int z=3; 08. int sum1,sum2,num1,num2,mod1,mod2; 09. System.out.println("香蕉有" + x + "根,芭樂有" + y + "顆," + "香蕉一根"+a + "元,芭樂一顆" + b + "元,小孩有" + z + "人"); 10. sum1=x*a; 11. sum2=y*b; 12. num1=x/z; 13. num2=y/z; 14. mod1=x%z; 15. mod2=y%z; 16. System.out.println("香蕉共計" + sum1 + "元" + "\n" + "芭樂共計"+ sum2 +"元" + "\n"+ "小孩一人可分得" + num1 + "根香蕉以及"+ num2 + "顆芭樂,最後還剩" +mod1 + "條香蕉以及"+ mod2 + "顆芭樂"); 17. } 18. } [ Java2語言實務 ]

56 香蕉有 5 根,芭樂有 7 顆,香蕉一根 9 元,芭樂一顆 20 元,小孩有 3 人 香蕉共值 45 元 芭樂共值 140 元
執行結果 香蕉有 5 根,芭樂有 7 顆,香蕉一根 9 元,芭樂一顆 20 元,小孩有 3 人 香蕉共值 45 元 芭樂共值 140 元 小孩一人可分得 1 根香蕉以及 2 顆芭樂,最後還剩 2 條香蕉以及 1 顆芭樂 [ Java2語言實務 ]

57 <<範例說明>>
程式 1~8 行宣告整數變數 x、y、a、b、z 各表示香蕉個數、芭樂個數、香蕉以及芭樂單價以及小孩人數；sum1 代表香蕉總價，sum2 代表芭樂總價，num1 代表小孩可分得香蕉個數，num2 則代表可分得芭樂個數，mod1 為香蕉剩下個數，mod2 則為芭樂剩下個數，並再以 System.out.print( ) 列印出結果。 所有運算子都有優先順序，會決定運算結果是否正確。Java 優先訊序在 Java 規範中規定如下表所示。若優先順序相等的運算子在同一個運算式中，則依照由左至右順序計算，Java 程式也可以透過使用括號來改變計算的優先順序。 [ Java2語言實務 ]

58 運算子的優先順序 postfix operators [] (params) exprt++ expr-- unary operators
++expr --expr +expr -expr ~ ! creation or cast new (type) expr multiplicative * / % additive + - shift << >> >>> relational < > <= >= instanceof equality == != bitwise AND & bitwise exclusive OR ^ bitwise inclusive OR | logical AND && logical OR || conditional ? : assignment = += -= *= /= %= &= ^= |= <<= >>= >>>= 運算子的優先順序 [ Java2語言實務 ]

59 比較運算子 比較運算子是用來比較兩個運算元的大小 (可以是變數、常數、算式或是它們的組合)以決定其間關係是否成立，結果是一個只包含“真”或是“偽”的“布林值”。 若關係成立，用真（true）表示，反之用偽（false）表示，比如說之5>3是真，10<7是偽。 表2-10 比較運算子 運算元 使用方式 以下狀況發生時，回應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、 運算式、運算子和運算元 [ Java2語言實務 ]

60 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 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

61 比較運算子範例說明 在範例中，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-4、 運算式、運算子和運算元 [ Java2語言實務 ]

62 Ex2_4_8 DemoCompare2.java 19.//小於等於 20.System.out.println("小於或等於的範例");
01. class DemoCompare2 { 02. public static void main(String[] args) { 03. //宣告變數 04. int x = 91; 05. int y = 87; 06. System.out.println("F 學生的成績為" + x + "分,"+"L 學生的成績為" + y + "分"); 07. //大於 08. System.out.println("大於的範例"); 09. System.out.println("F 學生成績高於 L 學生成績為" + (x > y)); 10. System.out.println("L 學生成績高於 F 學生成績為" + (x < y)); 11. //大於等於 12. System.out.println("大於或等於的範例"); 13. System.out.println("F 學生成績高於且等於 L 學生成績為"+ (x >= y)); 14. System.out.println("L 學生成績高於且等於 F 學生成績為"+ (x <= y)); 15. //小於 16.System.out.println("小於的範例"); 17.System.out.println(“F 學生成績低於L 學生成績為" + (x < y)); 18.System.out.println(“L 學生成績低於F 學生成績為" + (x > y)); 19.//小於等於 20.System.out.println("小於或等於的範例"); 21.System.out.println("F 學生成績低於且等於 L 學生成績為"+ (x <= y)); 22.System.out.println("L 學生成績低於且等於 F 學生成績為"+ (x >= y)); 23.//等於 24.System.out.println("等於的範例"); 25.System.out.println("F 學生成績等於 L 學生成績為" + (x == y)); 26.//不等於 27.System.out.println("不等於的範例"); 28.System.out.println("F 學生成績不等於 L 學生成績為" + (x != y)); 29. } 30.} [ Java2語言實務 ]

63 執行結果： F 學生的成績為 91 分,L 學生的成績為 87 分 大於的範例 F 學生成績高於 L 學生成績為 true
L 學生成績高於 F 學生成績為 false 大於或等於的範例 F 學生成績高於且等於 L 學生成績為 true L 學生成績高於且等於 F 學生成績為 false 小於的範例 F 學生成績低於 L 學生成績為 false L 學生成績低於 F 學生成績為 true 小於或等於的範例 F 學生成績低於且等於 L 學生成績為 false L 學生成績低於且等於 F 學生成績為 true 等於的範例 F 學生成績等於 L 學生成績為 false 不等於的範例 F 學生成績不等於 L 學生成績為 true [ Java2語言實務 ]

64 <<範例說明>>
在範例 Ex2_4_8 中，int x=91;int y=87; 宣告了兩個整數變數並指定其初始值 (x 值為 91，y 值為 87)，接下來的程式，則是利用布林代數的方式，比較兩個學生的成績高低，藉以判決真假並印出結果。 [ Java2語言實務 ]

65 邏輯運算子 在真實的世界中，我們常會需要同時判斷幾個條件的組合是否成立，得到的結果可能會決定後續動作的執行，此時就需要用到邏輯運算子以組合不同的條件。 邏輯運算子的運算元及判斷的結果，也都是只有真（成立時）或偽（不成立 ）的布林值，表2-9列出Java語言使用的邏輯運算子： 表2-11 邏輯運算子 名稱 運算子 使用方式 結果為真偽之情形及相關說明 條件及 && op1 && op2 op1 及 op2 均為真時，結果為真； op1 為真之條件下才對 op2 取右值 條件或 || op1 || op2 op1 或 op2 任一為真時，結果為真； 非 ! ! op op 值為偽時，結果為真 及 & op1 & op2 op1 及 op2 均為真時，結果為真 或 | op1 ! op2 op1 或 op2 任一為真時，結果為真 互斥或 ^ op1 ^ op22 op1、op2 二值相同時 (均為真或均為偽)，結果為真 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

66 邏輯運算子 在表示的習慣上，我們會把運算元所有真(T)及偽(F)的組合及邏輯運算的結果，對應在一個表中，稱為真偽值表(truth table)，如表2-10所示。 表2-12 邏輯運算真偽值表 運算元1 運算元2 運算元1 && 運算元2 運算元1 | | 運算元2 ! 運算元1 F T 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

67 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 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

68 邏輯運算子範例說明 第4行：int i=10; 第5行：x= (i >5) && (3>2);
－＞ 真 && 真 －＞ 真 第6行：y=( i <5) && (3<2); y設定為( i <5) && (3<2)的運算過程： (i <5) && (3<2) －＞ 偽 && 偽 －＞ 偽 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

69 邏輯運算子範例【註解】 在範例中，我們在使用運算子時，可以用“（）”括號來調整運算式 的優先順序，例如下面的範例：
!(((10<7)||(7 >5)) && ((6>=10)&&(3>2))); －＞!（（ 偽 || 真） &&（ 偽 && 真 ）） －＞!（ 真 ） && （ 偽 ） －＞!（真） －＞ 偽 邏輯運算子和比較運算子常合併使用表示更複雜的判斷；例如， 若電影票價是依照年齡來決定：年齡<18歲，票價為50元； 18≦年齡<60，票價為100元；年齡≧60，票價為70元；則針對 售票規則，我們可以合併應用邏輯運算子和比較運算子來決定 票價 。 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

70 Ex2_4_10 classDemoLogic2.java
02. public static void main(Stringargs[]){ 03. boolean x; 04. int i=10; 05. System.out.println("i 為正整數"+i); 06. x=(i>5)&&(3>2); 07. System.out.println("'i>5 且 3>2'這個描述為"+x); 08. x=(i<5)&&(3>2); 09. System.out.println("'i<5 且 3>2'這個描述為"+x); 10. x=(i<5)&&(3<2); 11. System.out.println("'i<5 且 3<2'這個描述為"+x); 12. x=(i>5)||(3>2); 13. System.out.println("'i>5 或 3>2'這個描述為"+x); 14. x=(i<5)||(3>2); 15. System.out.println("'i<5 或 3>2'這個描述為"+x); 16. x=(i<5)||(3<2); 17. System.out.println("'i<5 或 3<2'這個描述為"+x); 18. x=!(i>5); 19. System.out.println("'i>5 是錯的'這個描述為"+x); 20. x=!(i<5); 21. System.out.println("'i<5 是錯的'這個描述為"+x); 22. } 23. } [ Java2語言實務 ]

71 i<5 且 3>2 此件事實為 false i<5 且 3<2 此件事實為 false
執行結果： i 為正整數 10 i>5 且 3>2 此件事實為 true i<5 且 3>2 此件事實為 false i<5 且 3<2 此件事實為 false i>5 或 3>2 此件事實為 true i<5 或 3>2 此件事實為 true i<5 或 3<2 此件事實為 false 'i>5 是錯的'這個描述為 false 'i<5 是錯的'這個描述為 true [ Java2語言實務 ]

72 <<範例說明>>
程式先宣告整數變數 i ，並將其初始值設定為 10，接著就利用表 2-9 邏輯運算子的方法來做比較，並將事實及描述的真假列印在螢幕上。例如程式第 6 行中 "i>5" 以及 "3>2" 這兩項敘述都是正確的，所以在第 7 行列印出 x 值則為 true。 [ Java2語言實務 ]

73 2_4_11 邏輯運算子複雜判斷範例 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. 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

74 邏輯運算子複雜判斷範例說明 第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內容，印在螢幕上。 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

75 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("王同學的考試成績為"+ score + "分, 評比不及格" ); 06. if(score>=55 && score<=65) 07. System.out.println("王同學的考試成績為"+ score + "分, 評比為及格邊緣" ); 08. System.out.println("王同學的考試成績為"+ score + "分, 評比為尚可" ); 09. if(score>80) 10. System.out.println("王同學的考試成績為"+ score + "分, 評比為高分" ); 11. } 12.} [ Java2語言實務 ]

76 <<範例說明>>
執行結果 執行結果 王同學的考試成績為 85 分,評比為高分 <<範例說明>> 在範例 Ex2_4_12，程式宣告整數變數 score，並設定 score 為 85 (分)，利用 if 以及邏輯比較的語法，來評比王同學的成績是屬於何種範圍。若改變 score 的值，顯示結果便會不同。 [ Java2語言實務 ]

77 位元處理運算子 轉在位元層次處理資料:也就可以想像成先將資料成二進位，再在二進位位元的每個位址上進行 AND、OR、XOR 等運算。如： 3 AND 6 可轉成二進位 (011)2 & (110)2 = (010)2 為 2 。 例如：典型的電腦控制程式，常以每個位元代表一個開關的狀態，一個位元組即可表示 8 個開關，可經過另一個位元組形成的條件選擇要處理的開關，如 ( )2，即選擇了第 1 及 4 號開關，再和狀態位元組，如 ( ) 表示開關現在狀況為第 1~4 號為開，5~8 號為關，即可使用 ( )&( )=( ) 找到第 1 及 4 號開關狀態，而 5~8 號開關則不考慮的結果。 [ Java2語言實務 ]

78 表 2-13 低階邏輯的運算 運算元 使用情形 說明 & op1 & op2 位元階層的及運算 | op1 | op2 位元階層的或運算 ^
位元階層的互斥或運算 ~ ~ op 求 op 的補數 [ Java2語言實務 ]

79 型態轉換(Type Conversions)
進行運算時要注意，運算元要配合運算子的規定才可以正常運作，例如相同型態的資料才可以做比較及數學運算或其它的運算。 以人工計算 ，是習慣而平常的，但電腦進行此計算時就要包含一連串的動作。 Java程式語言在編譯程式時會檢查資料型態，如果以資料型態不同的資料作運算，則在編譯時會產生錯誤 。 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

80 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、 運算式、運算子和運算元 [ Java2語言實務 ]

81 型態轉換範例說明 【範例說明】 第3~4行：int x=3; double y=2.0;
宣告了整數變數x及雙精密浮點數變數y(初始值為2.0) 該程式在編譯時產生了錯鋘訊息，如圖2-1所示，“possible loss of precision”；Java編輯器不能確定是要把整數x轉型成浮點數，還是要把浮點數y轉型成整數(在做型態轉換時，可能會使資料精密度因轉換而改變)。此時程式設計師要以人工的方式強迫轉換資料型態才可以解決問題。 圖2-1 執行結果 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

82 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 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

83 藉由強迫型態轉換後，可避免程式發生錯誤；
強迫型態轉換範例說明 【範例說明】 第5行：x=x+(double)y; 藉由強迫型態轉換後，可避免程式發生錯誤； 但請注意將儲 存空間大的資料，轉成空間小者，可能導致資料內容值被捨 去而產生無徵兆的錯誤結果，所以應避免將較高精確度的資 料型態轉換成較低精確度的資料型態(如將浮點數轉成整數) 。 2-4、 運算式、運算子和運算元 [ Java2語言實務 ]

84 1.若有任一運算元為倍精數時，則結果為倍精數。 2.若不是項目 1 的情形，有任一運算元為浮點數，則結果為浮點數。
型態轉換原則 1.若有任一運算元為倍精數時，則結果為倍精數。 2.若不是項目 1 的情形，有任一運算元為浮點數，則結果為浮點數。 3.若非項目 1、2 的情形，有任一運算元為長整數時，則結果為長整數。 4.若不是以上 3 種狀況，結果為整數。 [ Java2語言實務 ]

85 表2-14 型態轉換表 byte short int long char floot double Int [ Java2語言實務 ]

86 [本章摘要] 本章首先介紹了Java程式語言的基本概念，如程式的架構及資料與流程的關係等。基本上，流程是用來描述資料處理的步驟與順序，而資料則是指流程中各步驟所要處理的資料項目。在Java中，各資料項目都必需要事先宣告才可以使用。“資料項目”的名稱又稱為變數名稱(簡稱變數)，而“資料項目”所代表的值則稱為變數值，變數值的類型則稱為變數型態或資料型態(Data Types)。Java語言有八種基本資料型態，程式設計者應依照處理需求決定所需使用的資料型態。 本章也介紹了各種運算子(設定運算子、算數運算子、比較運算子及邏輯運算子)及運算子的優先順序。由於運算元的資料型態要配合運算子的規定才可以正常運作，因此程式設計人員在必要時必需在程式中強迫轉換運算元的資料型態，但應避免將較高精確度的資料型態轉換成較低精確度的資料型態，以防產生無法預期的執行結果。 [ Java2語言實務 ]

87 [第二章習題] 1.修改範例2-3，程式執行後列印出資料型態的最小值並指出程式中變數有哪些？
2.參考範例2-10，設計一程式，給定四個整數分別印出最大值與最小值。 3.假設天然瓦斯計費標準如下:若度數<20，瓦斯費為150元;若度數<=20，瓦斯費為(度數-20)*4+100。設計一Java程式運算式來表示應收的費用。 [ Java2語言實務 ]