@@ -239,7 +239,7 @@ public class ScannerDemo2 {
239
239
}
240
240
```
241
241
242
- nextInt() 會將試著取得的字串轉換為int型態的整數 ,關於資料型態(Data type)我待會就會介紹,先來看看執行結果:
242
+ nextInt() 會將試著取得的字串轉換為 int 型態的整數 ,關於資料型態(Data type)我待會就會介紹,先來看看執行結果:
243
243
244
244
請輸入一個數字: 100
245
245
您輸入了 100 !
@@ -434,4 +434,277 @@ public class TigerNumberDemo {
434
434
3.3 資料、運算
435
435
--------------
436
436
437
+ 電腦的原文是「Computer」,電腦的基本作用其實就是運算,要運算就要給它資料,要告訴電腦您給了它哪些資料?是整數還是小數?是文字還是字元?這就是程式語言術語中所謂的「指定變數與資料型態」!在給定了資料之後,接著您就可以叫電腦開始進行各種算術、邏輯、比較、遞增、遞減等等的運算。
438
+
439
+ ## 3.3.1 資料型態 ##
440
+
441
+ 程式在執行的過程中,需要運算許多的資訊,也需要儲存許多的資訊,這些資訊可能是由使用者輸入、從檔案中取得,甚至是由網路上得到,在程式運行的過程中,這些資訊透過「變數」(Variable)加以儲存,以便程式隨時取用。
442
+
443
+ 一個變數代表一個記憶體空間,資料就是儲存在這個空間中,使用變數名稱來取得資料相信會比使用記憶體位置來得方便;然而由於資料在儲存時所需要的容量各不相同,不同的資料必須要配給不同大小的記憶體空間來儲存,在 Java 中對不同的資料區分有幾種不同的「資料型態」(Data type)。
444
+
445
+ 在 Java 中基本的資料型態(Primitive type)主要區分為「整數」、「位元」、「浮點數」、「字元」與「布林數」,而這幾種還可以細分,如下所示:
446
+
447
+ - 整數
448
+
449
+ 只儲存整數數值,可細分為短整數(short)(佔 2 個位元組)、整數(int)(佔4個位元組)與長整數(long)(佔 8 個位元組),長整數所佔的記憶體比整數來得多,可表示的數值範圍也就較大,同樣的,整數(int)可表示的整數數值範圍也比短整數來得大。
450
+
451
+ - 位元
452
+
453
+ Java 提供有位元(byte)資料型態,可專門儲存位元資料,例如影像的位元資料,一個位元資料型態佔一個位元組,而必要的話,byte 資料型態也可以用於儲存整數數值。
454
+
455
+ - 浮點數
456
+
457
+ 主要用來儲存小數數值,也可以用來儲存範圍更大的整數,可分為浮點數(float)(佔 4 個位元組)與倍精度浮點數(double)(佔 8 個位元組),倍精度浮點數所使用的記憶體空間比浮點數來得多,可表示的數值範圍與精確度也比較大。
458
+
459
+ - 字元
460
+
461
+ 用來儲存字元,Java 的字元採 Unicode 編碼,其中前 128 個字元編碼與 ASCII 編碼相容;每個字元資料型態佔兩個位元組,可儲存的字元範圍由 '\u0000'到'\uFFFF',由於 Java 的字元採用 Unicode 編碼,一個中文字與一個英文字母在 Java 中同樣都是用一個字元來表示。
462
+
463
+ - 布林數
464
+
465
+ 佔記憶體 2 個位元組,可儲存 true 與 false 兩個數值,分別表示邏輯的「真」與「假」。
466
+ 因為每種資料型態所佔有的記憶體大小不同,因而可以儲存的數值範圍也就不同,例如整數(int)的記憶體空間是 4 個位元組,所以它可以儲存的整數範圍為 -2147483648 至 2147483647,如果儲存值超出這個範圍的話稱之為「溢值」(Overflow),會造成程式不可預期的結果,您可以使用範例 3.12 來獲得數值的儲存範圍。
467
+
468
+ #### ** 範例 3.12 DataRange.java**
469
+ ``` java
470
+ public class DataRange {
471
+ public static void main (String [] args ) {
472
+ System . out. printf(" short \t 數值範圍:%d ~ %d\n " ,
473
+ Short . MAX_VALUE , Short . MIN_VALUE );
474
+ System . out. printf(" int \t 數值範圍:%d ~ %d\n " ,
475
+ Integer . MAX_VALUE , Integer . MIN_VALUE );
476
+ System . out. printf(" long \t 數值範圍:%d ~ %d\n " ,
477
+ Long . MAX_VALUE , Long . MIN_VALUE );
478
+ System . out. printf(" byte \t 數值範圍:%d ~ %d\n " ,
479
+ Byte . MAX_VALUE , Byte . MIN_VALUE );
480
+ System . out. printf(" float \t 數值範圍:%e ~ %e\n " ,
481
+ Float . MAX_VALUE , Float . MIN_VALUE );
482
+ System . out. printf(" double \t 數值範圍:%e ~ %e\n " ,
483
+ Double . MAX_VALUE , Double . MIN_VALUE );
484
+ }
485
+ }
486
+ ```
487
+
488
+ 其中 Byte、Integer、Long、Float、Double 都是 java.lang 套件下的類別名稱,而 MAX_VALUE 與 MIN_VALUE 則是各類別中所定義的靜態常數成員,分別表示該資料型態可儲存的數值最大與最小範圍,'%e' 表示用科學記號顯示,範例的執行結果如下所示:
489
+
490
+ short 數值範圍:32767 ~ -32768
491
+ int 數值範圍:2147483647 ~ -2147483648
492
+ long 數值範圍:9223372036854775807 ~ -9223372036854775808
493
+ byte 數值範圍:127 ~ -128
494
+ float 數值範圍:3.402823e+38 ~ 1.401298e-45
495
+ double 數值範圍:1.797693e+308 ~ 4.900000e-324
496
+
497
+ 其中浮點數所取得是正數的最大與最小範圍,加上負號即為負數可表示的最大與最小範圍。
498
+
499
+ ## 3.3.2 變數、常數 ##
500
+
501
+
502
+ 資料是儲存在記憶體中的一塊空間中,為了取得資料,您必須知道這塊記憶體空間的位置,然而若使用記憶體位址編號的話相當的不方便,所以使用一個明確的名稱,變數(Variable)是一個資料儲存空間的表示,您將資料指定給變數,就是將資料儲存至對應的記憶體空間,您呼叫變數時,就是將對應的記憶體空間的資料取出供您使用。
503
+
504
+ 在 Java 中要使用變數,必須先宣告變數名稱與資料型態,例如:
505
+
506
+ int age; // 宣告一個整數變數
507
+ double scope; // 宣告一個倍精度浮點數變數
508
+
509
+ 就如上面所舉的例子,您使用 int、float、double、char 等關鍵字(Keyword)來宣告變數名稱並指定其資料型態,變數在命名時有一些規則,它不可以使用數字作為開頭,也不可以使用一些特殊字元,像是 * &^% 之類的字元,而變數名稱不可以與 Java 內定的關鍵字同名,例如 int、float、class 等。
510
+
511
+ 變數的命名有幾個風格,主要以清楚易懂為主,初學者為了方便,常使用一些簡單的字母來作為變數名稱,這會造成日後程式維護的困難,命名變數時發生同名的情況也會增加。在過去曾流行過匈牙利命名法,也就是在變數名稱前加上變數的資料型態名稱縮寫,例如 intNum 用來表示這個變數是int整數資料型態,fltNum 表示一個 float 資料型態,然而隨著現在程式的發展規模越來越大,這種命名方式已經不被鼓勵。
512
+
513
+ 現在比較鼓勵用清楚的名稱來表明變數的作用,通常會以小寫字母作為開始,並在每個單字開始時第一個字母使用大寫,例如:
514
+
515
+ int ageOfStudent;
516
+ int ageOfTeacher;
517
+
518
+ 像這樣的名稱可以讓人一眼就看出這個變數的作用,在 Java 程式設計領域中是比較常看到的變數命名方式。變數名稱可以使用底線作為開始,通常使用底線作為開始的變數名稱,表示它是私用的(Private),只在程式的某個範圍使用,外界並不需要知道有這個變數的存在,通常這樣的變數名稱常用於物件導向程式設計中類別的私有成員(Private member),這樣的命名方式偶而也會看到,一個宣告的例子如下:
519
+
520
+ double _window_center_x;
521
+ double _window_center_y;
522
+
523
+ 當您在Java中宣告一個變數,就會配置一塊記憶體空間給它,這塊空間中原先可能就有資料,也因此變數在宣告後的值是不可預期的,Java 對於安全性的要求極高,您不可以宣告變數後,而在未指定任何值給它之前就使用它,編譯器在編譯時會回報這個錯誤,例如若宣告變數 var 卻沒有指定值給它,則會顯示以下訊息:
524
+
525
+ variable var might not have been initialized
526
+
527
+ 可以的話,儘量在變數宣告後初始其值,您可以使用「指定運算子」(Assignment operator)'='來指定變數的值,例如:
528
+
529
+ int ageOfStudent = 0;
530
+ double scoreOfStudent = 0.0;
531
+ char levelOfStudent = 'A';
532
+
533
+ 上面這段程式在宣告變數的時候,同時指定變數的儲存值,而您也看到如何指定字元給字元變數,字元在指定時需使用引號 ' ' 來包括;在指定浮點數時,會習慣使用小數的方式來指定,如 0.0,在J ava 中寫下 0.0 這麼一個常數的話,其預設為 double 資料型態。
534
+
535
+ 在宣告變數之後,就可以呼叫變數名稱來取得其所儲存的值,範例 3.13是個簡單的示範:
536
+
537
+ #### ** 範例 3.13 VariableDemo.java**
538
+ ``` java
539
+ public class VariableDemo {
540
+ public static void main (String [] args ) {
541
+ int ageOfStudent = 5 ;
542
+ double scoreOfStudent = 80.0 ;
543
+ char levelOfStudent = ' B' ;
544
+
545
+ System . out. println(" 年級\t 得分\t 等級" );
546
+ System . out. printf(" %4d\t %4.1f\t %4c" ,
547
+ ageOfStudent, scoreOfStudent, levelOfStudent);
548
+ }
549
+ }
550
+ ```
551
+
552
+ 以下為執行結果:
553
+
554
+ 年級 得分 等級
555
+ 5 80.0 B
556
+
557
+ 在 Java 中寫下一個數值,這個數就稱之為字面常數(Literal constant),它會存在記憶體的某個位置,您無法改變它的值;而在使用變數的時候,您也會使用一種叫「常數」的變數,嚴格來說它並不是常數,只不過在指定數值給這個變數之後,就不可再改變其值,有人為了區分其與常數的差別,還給了它一個奇怪的名稱:「常數變數」。
558
+
559
+ 先不要管「常數變數」這個怪怪的名稱,其實它終究是個變數而已,您在宣告變數名稱的同時,加上 "final" 關鍵字來限定,只不過這個變數一但指定了值,就不可以再改變它的值,如果程式中有其它程式碼試圖改變這個變數,編譯器會先檢查出這個錯誤,例如:
560
+
561
+ final int maxNum = 10;
562
+ maxNum = 20;
563
+
564
+ 這一段程式碼中的 maxNum 變數您使用了 "final" 關鍵字來限定,所以它在指定為 10 之後,就不可以再指定值給它,所以第二次的值指定會被編譯器指出錯誤:
565
+
566
+ cannot assign a value to final variable maxNum
567
+
568
+ 使用 "final" 來限定的變數,目的通常就是不希望其它的程式碼來變動它的值,例如用於迴圈計數次數的指定(迴圈之後就會學到),或是像圓周率 PI 常數的指定。
569
+
570
+ ## 3.3.3 算術運算 ##
571
+
572
+ 程式的目的簡單的說就是運算,除了運算還是運算,所以加減乘除這類的操作是少不得的,在 Java 中提供運算功能的就是運算子 (Operator),例如與算術相關的有加(+)、減(-)、乘(* )、除(/)這類的運算子,另外還有一個也很常用的餘除運算子(%),這類以數學運算為主的運算子稱之為「算術運算子」(Arithmetic operator)
573
+
574
+ 算術運算子的使用基本上與您學過的加減乘除一樣,也是先乘除後加減,必要時加上括號表示運算的先後順序,例如這個程式碼會在文字模式下顯示 7:
575
+
576
+ System.out.println(1 + 2 * 3);
577
+
578
+ 編譯器在讀取程式碼時是由左往右讀取的,而初學者往往會犯一個錯誤,例如 (1+2+3) / 4,由於在數學運算上習慣將分子寫在上面,而分母寫在下面的方式,使得初學者往往將之寫成了:
579
+
580
+ System.out.println(1+2+3 / 4);
581
+
582
+ 這個程式事實上會是這樣運算的:1+2+(3/4);為了避免這樣的錯誤,在必要的時候為運算式加上括號才是最保險的,例如:
583
+
584
+ System.out.println((double)(1+2+3) / 4);
585
+
586
+ 注意在上面的程式碼中使用了 double 限定型態轉換,如果不加上這個限定的話,程式的輸出會是 1 而不是 1.5,這是因為在這個 Java 程式中,1、2、3、4 這四個數值都是整數,當程式運算 (1+2+3) 後的結果還是整數型態,若此時除以整數 4,會自動去除小數點之後的數字再進行輸出,而您加上 double 限定,表示要 (1+2+3) 運算後的值轉換為 double 資料型態,如此再除以 4,小數點之後的數字才不會被去除。
587
+
588
+ 同樣的,您看看這段程式會印出什麼結果?
589
+
590
+ int testNumber = 10;
591
+ System.out.println(testNumber / 3);
592
+
593
+ 答案不是 3.3333 而是 3,小數點之後的部份被自動消去了,這是因為您的 testNumber 是整數,而除數3也是整數,運算出來的程式被自動轉換為整數了,為了解決這個問題,您可以使用下面的方法:
594
+
595
+ int testNumber = 10;
596
+ System.out.println(testNumber / 3.0);
597
+ System.out.println((double) testNumber / 3);
598
+
599
+ 上面這個程式片段示範了兩種解決方式:如果運算式中有一個浮點數,則程式就會先轉換使用浮點數來運算,這是第一段陳述句所使用的方式;第二個方式稱之為「限定型態轉換」,您使用 double 告訴程式先將 testNumber 的值轉換為 double,然後再進行除法運算,所以得到的結果會是正確的 3.3333;型態轉換的限定關鍵字就是宣告變數時所使用的 int、float 等關鍵字。
600
+
601
+ 當您將精確度小的資料型態(例如int)指定給精確度大的資料型態之變數時(例如 double),這樣的指定在精確度並不會失去,所以這樣的指定是可行的,由於 Java 對於程式的安全性要求極高,型態轉換在某些情況一定要明確指定,就是在使用指定運算子 '=' 時,將精確度大的值指定給精確度小的變數時,由於在精確度上會有遺失,編譯器會認定這是一個錯誤,例如:
602
+
603
+ int testInteger = 0;
604
+ double testDouble = 3.14;
605
+ testInteger = testDouble;
606
+ System.out.println(testInteger);
607
+
608
+ 這段程式在編譯時會出現以下的錯誤訊息:
609
+
610
+ possible loss of precision
611
+ found : double
612
+ required: int
613
+ testInteger = testDouble
614
+ ^
615
+ 1 error
616
+
617
+ 如果您確定要轉換數值為較小的精度,您必須明確加上轉換的限定字,編譯器才不會回報錯誤。
618
+
619
+ testInteger = (int) testDouble;
620
+
621
+ '%' 運算子是餘除運算子,它計算所得到的結果是除法後的餘數,例如 (10 % 3) 會得到餘數 1;一個使用 '%' 的例子是數字循環,假設有一個立方體要進行360度旋轉,每次要在角度上加 1,而 360 度後必須復歸為 0,然後重新計數,這時您可以這麼撰寫:
622
+
623
+ count = (count + 1) % 360;
624
+
625
+ ## 3.3.4 比較、條件運算 ##
626
+
627
+ 數學上有比較的運算,像是大於、等於、小於等運算,Java 中也提供了這些運算子,這些運算子稱之為「比較運算子」(Comparison operator),它們有大於(>)、不小於(>=)、小於(<)、不大於(<=)、等於(==)以及不等於(!=)。
628
+
629
+ 在 Java 中,比較的條件成立時以 true 表示,比較的條件不成立時以 false 表示,範例 3.14 示範了幾個比較運算的使用。
630
+
631
+ #### ** 範例 3.14 ComparisonOperator.java**
632
+ ``` java
633
+ public class ComparisonOperator {
634
+ public static void main (String [] args ) {
635
+ System . out. println(" 10 > 5 結果 " + (10 > 5 ));
636
+ System . out. println(" 10 >= 5 結果 " + (10 >= 5 ));
637
+ System . out. println(" 10 < 5 結果 " + (10 < 5 ));
638
+ System . out. println(" 10 <= 5 結果 " + (10 <= 5 ));
639
+ System . out. println(" 10 == 5 結果 " + (10 == 5 ));
640
+ System . out. println(" 10 != 5 結果 " + (10 != 5 ));
641
+ }
642
+ }
643
+ ```
644
+
645
+ 程式的執行如下所示:
646
+
647
+ 10 > 5 結果 true
648
+ 10 >= 5 結果 true
649
+ 10 < 5 結果 false
650
+ 10 <= 5 結果 false
651
+ 10 == 5 結果 false
652
+ 10 != 5 結果 true
653
+
654
+ 比較運算在使用時有個即使是程式設計老手也可能犯的錯誤,且不容易發現,也就是等於運算子 '==',注意它是兩個連續的等號 '=' 所組成,而不是一個等號,一個等號是指定運算,這點必須特別注意,例如若有兩個變數x與y要比較是否相等,應該是寫成 x == y,而不是寫成 x = y,後者的作用是將y的值指定給 x,而不是比較運算 x 與 y 是否相等。
655
+
656
+ 另一個使用 '==' 運算時要注意的是,對於物件來說,兩個物件參考之間使用 '==' 作比較時,是比較其名稱是否參考至同一物件,而不是比較其內容,在之後的章節介紹 Integer 等包裹(Wrapper)物件或字串時會再詳細介紹。
657
+
658
+ 既然談到了條件式的問題,來介紹 Java 中的「條件運算子」(conditional operator),它的使用方式如下:
659
+
660
+ 條件式 ? 成立傳回值 : 失敗傳回值
661
+
662
+ 條件運算子的傳回值依條件式的結果而定,如果條件式的結果為 true,則傳回冒號 ':' 前的值,若為 false,則傳回冒號後的值,範例 3.15 可以作個簡單的示範:
663
+
664
+ #### ** 範例3.15 ConditionalOperator.java**
665
+ ``` java
666
+ import java.util.Scanner ;
667
+
668
+ public class ConditionalOperator {
669
+ public static void main (String [] args ) {
670
+ Scanner scanner = new Scanner (System . in);
671
+
672
+ System . out. print(" 請輸入學生分數: " );
673
+ int scoreOfStudent = scanner. nextInt();
674
+ System . out. println(" 該生是否及格? " +
675
+ (scoreOfStudent >= 60 ? ' 是' : ' 否' ));
676
+ }
677
+ }
678
+ ```
679
+
680
+ 這個程式會依您所輸入的分數來判斷學生成績是否不小於 60 分,以決定其是否及格,如果是則傳回字元 '是' ,否則傳回字元 '否',執行結果如下:
681
+
682
+ 請輸入學生分數: 88
683
+ 該生是否及格? 是
684
+
685
+ 條件運算子(?:)使用得當的話可以少寫幾句程式碼,例如範例 3.16 可以判斷使用者輸入是否為奇數。
686
+
687
+ #### ** 範例3.16 OddDecider.java**
688
+ ``` java
689
+ import java.util.Scanner ;
690
+
691
+ public class OddDecider {
692
+ public static void main (String [] args ) {
693
+ Scanner scanner = new Scanner (System . in);
694
+
695
+ System . out. print(" 請輸入數字: " );
696
+ int number = scanner. nextInt();
697
+ System . out. println(" 是否為奇數? " +
698
+ (number% 2 != 0 ? ' 是' : ' 否' ));
699
+ }
700
+ }
701
+ ```
702
+
703
+ 當您輸入的數為奇數時,就不能被2整除,所以餘數一定不是 0,在條件式中判斷為 true,因而傳回字元 '是',若數值為偶數,則 2 整除,所以餘數為 0,在條件式中判斷為 false,所以傳回字元 '否',一個執行的例子如下:
704
+
705
+ 請輸入數字: 87
706
+ 是否為奇數? 是
707
+
708
+ ## 3.3.5 邏輯、位元運算 ##
709
+
437
710
待續 ...
0 commit comments