手机验证领28彩金捕鱼

書名：零基礎學Java（第4版）
作者名：常建功陳浩黃淼等編著
本章字數： 725字
更新時間： 2019-01-01 00:49:59

第3章 Java語言中的數據類型與運算符

本章主要介紹編程語言中最基礎的部分：數據類型和運算符。這是所有編程語言都必須掌握的基礎知識，也是整個程序代碼不可缺少的重要部分。本章將通過大量的程序代碼，來講述如何操作這些數據類型和運算符。熟練地掌握此章對于Java開發有著非常重要的作用，并且還對以后學習其他開發語言有著重要的幫助。

本章重點：

□ Java語言中的數制。

□ 數據類型。

□ 變量和常量。

□ 各種常見運算符。

3.1 數制

在介紹數據之前，先了解數制的概念。數制可以說是純粹數學上的內容，在計算機語言開發中使用得比較頻繁，下面將詳細講述數制的有關知識。

3.1.1 基本概念

在使用計算機時，會遇到數值、文字、圖像、聲音等信息，計算機如何識別這些數據信息呢？首先，這取決于計算機底層硬件是如何識別數據的。計算機底層硬件只能識別“0”和“1”，這種只有“0”和“1”兩個數字符號的組合被稱為二進制。例如計算機要處理數字“128”，那么計算機會將其轉化成二進制“10000000”。一個這么簡單的數字，要用這么長的數字符號來代替，在現實生活中稍顯麻煩，所以后來又引進了十六進制和八進制。實際開發中使用最多的是十進制，后面會介紹各個數制的特征和使用。

3.1.2 Java語言中的數制表現形式

數制一般包括二進制、八進制、十六進制和十進制。

1.二進制

二進制的特征：

□ 由兩個數字組成：“0”和“1”。

□ 運算時逢二進一。

例如：1100110011和10000001。

2.八進制

八進制的特征：

□ 由8個數字組成：“0”、“1”、“2”、“3”、“4”、“5”、“6”、“7”。

□ 運算時逢八進一。

例如：014、0726。

注意

八進制數據以0為前綴。它經常會與二進制產生混淆，所以在Java程序設計中，建議盡量不要使用八進制。

3.十六進制

十六進制的特征：

□ 由16個數字組成：“0”、“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”、“A”、“B”、“C”、“D”、“E”、“F”。

□ 運算時逢十六進一。

例如：0xB和0x12e。

注意

十六進制用A、B、C、D、E、F這6個字母分別表示10～15。字母不區分大小寫。十六進制數據以0x為前綴。

4.十進制

十進制的特征：

□ 由10個數字組成：“0”、“1”、“2”、“3”、“4” 、“5”、“6”、“7”、“8”、“9”。

□ 運算時逢十進一。

例如：89、92、168。

3.2 數據類型

Java語言是一個強調數據類型的語言，在聲明任何變量時，必須將該變量定義為一種數據類型。Java中的數據類型包括基本數據類型和對象類型（也稱為引用數據類型）。對象類型不屬于本章所講述的內容，本章主要介紹數據的基本類型。Java程序中，總共有8大基本類型：其中包括4種整型、1種字符型、2種浮點型、1種布爾型。除了這幾種基本類型外，其他都屬于對象類型的數據。

3.2.1 整型

什么是整型呢？從字面上就可以知道，整型就是整數類型，也就是沒有小數點的數字，可以是正數也可以是負數。在Java中，整型主要有4種：字節型（byte）、整數型（int）、短整型（short）、長整型（long）。

1.字節型

【實例3-1】byte用一個字節來表示整數值，它的范圍介于-128～127之間。通常這種類型的整型數據擁有上節中提到的所有進制。但無論采用哪種進制，在輸出控制臺上，系統都會將其自動轉化為十進制，從下列代碼段可以得到證實。

01  public class Byte {
02       public static void main(String[] args) {
03            byte x = 22;                               //x是十進制數
04            byte y = 022;                              //y是八進制數
05            byte z = 0x22;                             //z是十六進制數
06            //輸出相應十進制的值
07            System.out.println("轉化成十進制,x=" + x);
08            System.out.println("轉化成十進制,y=" + y);
09            System.out.println("轉化成十進制,z=" + z);
10       }
11  }

【代碼說明】第3～5行定義了3個byte型變量，分別代表不同的數制，第4行的變量值前綴是0，第5行的變量值前綴是0x。第7～9行并沒有使用類型轉換的函數，而是直接輸出這3個變量。

【運行效果】在DOS窗口中，通過Javac編譯該源代碼，然后通過Java執行編譯后的class文件。最終結果如下所示。

轉化成十進制,x=22
轉化成十進制,y=18
轉化成十進制,z=34

2.短整型

【實例3-2】short用兩個字節表示整數值，其整數值介于-32768～32767之間。它有八進制、十進制和十六進制3種表示方法，其表示方法與字節型是一樣的，從下面的程序段可以證實。

01  public class Short
02  {
03      public static void main(String[] args)
04      {
05          short  x=22;                                  //十進制
06          short  y=022;                                 //八進制
07          short  z=0x22;                                //十六進制
08          System.out.println("轉化成十進制,x="+ x);
09          System.out.println("轉化成十進制,y="+ y);
10          System.out.println("轉化成十進制,z="+ z);
11      }
12  }

【代碼說明】第5～7行定義了3個short型變量，依然是用前綴0和0x代表八進制和十六進制。第8～10行沒有使用數據類型轉換的函數，直接輸出結果。

【運行效果】

轉化成十進制,x=22
轉化成十進制,y=18
轉化成十進制,z=34

可以看出，兩個程序段運行結果都是一樣的。其實，在實際編程過程中，開發者最常用的整型是int型。

3.整數型

【實例3-3】整數型又稱作int型，用4個字節來表示整數值，其整數值介于-2147483648～2147483647之間。整數型擁有以上所說的各種進制，其表示方法與字節型也相同，從下面的程序段同樣可以證實。

01  public class Int
02  {
03      public static void main(String[] args)
04      {
05          int  x=22;                                //十進制
06          int  y=022;                               //八進制
07          int  z=0x22;                              //十六進制
08          System.out.println("轉化成十進制,x="+ x);
09          System.out.println("轉化成十進制,y="+ y);
10          System.out.println("轉化成十進制,z="+ z);
11      }
12  }

【代碼說明】第5～7行同樣定義了3種進制的變量，通過前綴0和0x來區別進制。第8～10行依然是直接輸出變量的值，而沒有顯式地進行類型轉換。

【運行效果】

轉化成十進制,x=22
轉化成十進制,y=18
轉化成十進制,z=34

4.長整型

【實例3-4】長整型long用8個字節表示整數型，其數值介于-9223372036854775808～9223372036854775807之間。它的所有特性基本與前幾種整型一樣，唯一不同的是，長整型的數據后面有一個“L”字母，這個也是從表現形式上區別于其他整型的最大特征。可從下面的程序代碼段中了解長整型與其他整型的區別。

01  public class Long
02  {
03      public static void main(String[] args)
04      {
05          long  x=22L;                      //十進制
06          long  y=022L;                     //八進制
07          long  z=0x22L;                    //十六進制
08          System.out.println("轉化成十進制,x="+ x);
09          System.out.println("轉化成十進制,y="+ y);
10          System.out.println("轉化成十進制,z="+ z);
11      }
12  }

【代碼說明】第5～7行定義了3個長整型變量，要注意的是結尾的標識“L”。第8～10行直接輸出變量的值，會自動進行類型轉換，輸出的結果都是用十進制表示的。

【運行效果】

轉化成十進制,x=22
轉化成十進制,y=18
轉化成十進制,z=34

從以上程序代碼段中可以看出，4種不同的整型類型的數據，在程序段中所表現出來的運行結果幾乎是一樣的。不同的是每個類型數據的取值范圍不一樣，隨著字節數增多，取值范圍增大。雖然長整型的數據可以表示很大的數據，但如果超過了長整型的數據取值范圍，該如何處理這些數據呢？在Java中，有一種大數值類型的數據，由于它屬于對象類型數據，所以此處不做介紹。

3.2.2 字符型

字符型數據是平時程序設計中使用比較頻繁的類型，其占兩個字節。特別注意的是，它必須以單引號表示，例如'A'表示一個字符，這個字符就是A。"A"表示一個字符串，雖然只有一個字符，但因為使用雙引號，所以它仍然表示字符串，而不是字符。

總之，字符數據類型只能表示單個字符，任何超過一個字符的內容，都不能被聲明為字符型。字符的聲明是用單引號，通過輸出控制臺，看到的是單引號內的字符數據。

【實例3-5】通過下面的程序代碼，來看看字符型數據是如何輸出的。

01  //聲明了x,y,z,a 四個字符型數據變量
02  public class Char
03  {
04      public static void main(String[] args)
05      {
06          char x='美';                       //聲明一個字符型變量
07          char y='國';                       //聲明一個字符型變量
08          char z='人';                       //聲明一個字符型變量
09          char a='民';                       //聲明一個字符型變量
10          System.out.println("這些字符組合起來就是："+x+y+z+a);
11      }
12  }

【代碼說明】第6～9行定義了4個字符型變量，第10行輸出變量的內容，將字符型數據連接在一起使用的運算符也是“+”。

【運行效果】

這些字符組合起來就是：美國人民

字符型數據和整型數據都是無小數點的數據，下面將要講述的類型則是帶小數點的數據，用專業術語來講就是浮點型。

3.2.3 浮點型

浮點型數據表示有小數部分的數字，總共有兩種類型：單精度浮點型（float）和雙精度浮點型（double）。

1.單精度浮點型

單精度浮點型占4個字節，有效數字最長為7位，有效數字長度包括了整數部分和小數部分。一個單精度浮點型的數據定義如下所示。

float x=223.56F

注意

在每個單精度浮點型數據后面，都有一個標志性符號“F”或者“f”，有這個標志就代表是單精度浮點型數據。

【實例3-6】下面演示單精度浮點型數據在程序代碼段中的使用情況。

01  //聲明了x,y,z三個浮點型變量
02  public class Float
03  {
04      public static void main(String[] args)
05      {
06          float x=22.2f;                     //聲明一個單精度類型變量
07          float y=42.2f;                     //聲明一個單精度類型變量
08          float z=x*y;                       //實現相乘
09          System.out.println("x＊y="+z);
10      }
11  }

【代碼說明】第6～7行定義了兩個浮點型數據，它們都以“f”標識結尾。第8行定義了變量z，其值是前面定義的變量x和y的乘積。第9行輸出計算結果z。

【運行效果】

x＊y=936.84

提示

如果在一個浮點數后面加上“F”或者“f”時，表示的就是單精度浮點型數據，否則，系統會認為是雙精度浮點型數據。

2.雙精度浮點型

雙精度浮點型數據占據8個字節，有效數字最長為15位，后面帶有標志性符號 “D”或“d”。系統默認不帶標志性符號的浮點型數據是雙精度浮點型數據。雙精度浮點型數據的定義如下所示。

double x=33.5D

【實例3-7】下面是一個簡單的程序代碼段。

01  public class Double
02  {
03      public static void main(String[] args)
04      {
05          float x=23f;                             //聲明一個單精度類型變量
06          double y=44;                             //聲明一個雙精度類型變量
07          System.out.println("x="+x);
08          System.out.println("y="+y);
09      }
10  }

【代碼說明】第5行定義了一個單精度浮點型變量x，但沒有帶小數位。第6行定義了一個雙精度浮點型變量y，也沒有帶小數位，也沒有加標識“D”。第7～8行分別在控制臺輸出兩個變量，注意輸出的結果。

【運行效果】

x=23.0
y=44.0

從這段程序代碼中可以看出，即使浮點型數據是一個只有整數位沒有小數位的數據，在輸出控制臺上，其仍然是帶小數點的浮點數據，系統會自動加上小數點，并且小數位全部置0。

3.2.4 布爾型

布爾型數據其實很簡單，例如，如果有人問：去不去麥當勞？可以說“不去”。如果有人問：去不去看電影？可以說“去”。這里就隱藏著布爾型數據，布爾型數據就是“是”與“否”。在程序中使用“真”和“假”來代替“是”與“否”，即“true”和“false”。布爾類型的默認值是false，即如果定義了一個布爾變量但沒有賦初值，默認該布爾變量值是false。

【實例3-8】仔細觀察下面的程序代碼。

01  public class Boolean {
02       public static void main(String[] args) {
03            int a = 30;                                   //聲明一個整型變量a
04            int b = 59;                                   //聲明一個整型變量b
05            boolean x, y, z;                              //聲明三個布爾型變量x、y、z
06            x = (a > b);                                  //為變量x賦值
07            y = (a < b);                                  //為變量y賦值
08            z = ((a + b) == 50);                          //為變量z賦值
09            System.out.println("x=" + x);
10            System.out.println("y=" + y);
11            System.out.println("z=" + z);
12       }
13  }

【代碼說明】

□ 當執行第6行代碼“a>b”時，不等式不成立，所以x的結果是假。

□ 當執行第7行代碼“a<b”時，不等式成立，所以y的結果是真。

□ 當執行第8行代碼“a+b==50”時，結果不成立，所以z的結果是假。

說明

布爾型數據在只有兩種選擇，不可能出現第三種選擇的情況下使用。

【運行效果】

x=false
y=true
z=false

在程序設計的過程中，如果一個參數只有正和反兩方面，就可以將其設置為布爾型類型。

3.3 變量

在上一節詳細介紹了Java語言中的數據類型及其功能。在具體實例代碼中我們定義了很多變量，那么變量究竟是什么呢？本節將介紹變量的基本概念，以及如何操作變量。

3.3.1 變量的聲明

變量就是在程序的運行中可以變化的量，變量是程序設計中一個非常重要和關鍵的概念。在Java程序設計中，每個聲明過的變量都必須分配一個類型。聲明一個變量時，應該先聲明變量的類型，隨后再聲明變量的名字。下面演示了變量的聲明方式。

01  //salary,age,op都是變量名字
02  //double,int,boolean則是變量的類型
03  double salary;
04  int age;
05  boolean op;

每一行的第一項是變量類型，第二項是變量名。行尾的分號是必需的，這是Java語句的結束符號。如果沒有這個分號，程序不會認為這是一句完整的Java語句。

同一類型的不同變量，可以聲明在一行，也可以聲明在不同行，如果在同一行中聲明，不同的變量之間用逗號分隔，如下面的例子。

int studentNumber,people;

3.3.2 變量的含義

在程序設計中，經常會聽到變量這個名詞，到底什么是變量呢？它又有什么意義呢？

在程序運行過程中，空間內的值是變化的，這個內存空間就稱為變量。為了操作方便，給這個空間取名，稱為變量名，內存空間內的值就是變量值。所以，申請了內存空間，變量不一定有值，要想變量有值，就必須要放入值。

例如：代碼“int x”，定義了變量但沒有賦值，即申請了內存空間，但沒有放入值。如果“int x=5”，說明不但申請了內存空間而且還放入了值，值為5。

3.3.3 變量的分類

變量的分類方式多種多樣，不可能單純地將變量劃分為幾類，下面將以不同的分類方式來討論變量的分類問題。

1.根據作用范圍劃分

根據作用范圍來分，一般將變量分為全局變量和局部變量。從字面上理解很簡單，全局變量就是在程序范圍之內都有效的變量，而局部變量就是在程序中的部分區域有效的變量。

【實例3-9】從專業的角度來解釋，全局變量就是在類的整個范圍之內都有效的變量。而局部變量就是在類中某個方法函數或某個子類內有效的變量，下面將從實際程序代碼中慢慢地體會。

01  //a,b都是全局變量
02  //c是局部變量
03  public class var
04  {
05      int a=10;                                               //定義全局變量a
06      int b=21;                                               //定義全局變量b
07      public static void main(String[] args)
08      {
09          var v=new var();
10          System.out.println("這個是全局變量a="+ v.a);
11          v.print();
12      }
13      void print()
14      {
15          int c=20;                                          //定義局部變量c
16          System.out.println("這個是局部變量c="+ c);
17      }
18  }

【代碼說明】第5～6行定義了兩個變量，它們在main()方法外。第15行在print()方法內定義了變量c，第16行在當前方法內輸出此變量。

【運行效果】

這個是全局變量a=10
這個是局部變量c=20

【實例3-10】如果在main()方法中同樣輸出c的值，會出現什么樣的結果呢？下面從實際代碼段中仔細體會。

01  public class Math1
02  {
03      public static void main(String[] args)
04      {
05          Math1 v=new Math1();
06          System.out.println("這個是局部變量c="+ v.c);               //輸出全局變量c
07      }
08      void print()
09      {
10          int c=20;                                                //定義局部變量c
11      }
12  }

【運行效果】以上代碼在編譯時，會出現錯誤，即找不到變量c。這說明變量c只在方法print()中起作用，在方法外就無法再調用。

【代碼說明】從上述代碼中可以看出，如果一個變量在類中定義，那么這個變量就是全局變量，例如下面的代碼段。

01  public class var
02  {
03      int a=10;                                                          //定義全局變量a
04      int b=21;                                                          //定義全局變量b
05  }

這里的變量a、b都是全局變量，而在類的方法、函數中定義的變量就是局部變量，例如下面的代碼段。

01  public class var
02  {
03      void print()
04      {
05          int c=20;                                                      //定義局部變量c
06      }
07  }

這里的變量c就是局部變量。因為它不是在類中直接定義的，而是在類的方法中定義的。

2.根據類型劃分

如果根據類型劃分，可以將變量分為基本類型變量和對象類型變量，而基本類型變量就是前面說的8種基本數據類型的變量，如整型、浮點型、字符型、布爾型等。

說明

對象類型將在后面的章節中介紹，這里暫時不做具體的說明。

3.根據所屬范圍劃分

如果按所屬范圍來分，可以將變量分為類變量和成員變量，類變量就是用關鍵字“static”聲明的全局變量，它是屬于類的。而成員變量就是不用“static”聲明的其他實例變量，它是屬于對象本身的。

其實類變量就是在類中直接定義的，并且不隨類產生的對象變化而變化。當在一個類中聲明了一個類變量時，無論創造出多少個對象，使用對象引用這個變量，都不會發生變化。成員變量就不同了，它隨著對象不同而變化。即針對同一個類，新創建一個對象，使用此對象引用這個變量，每次引用的值都不一樣。

3.4 變量如何初始化

在C、C++、C#等語言中，都會提到變量的初始化，有關對象類型變量的初始化將在后面的章節詳細講述，這里將把基本類型變量的初始化作為本節的主要內容。

【實例3-11】基本類型變量的初始化工作，就是給變量賦值。為了能夠更加清晰地看到變量如何初始化，以及初始化時需要注意的知識點，下面通過實例來演示。

01  //通過不同類型的數據的輸出來查看變量如何初始化
02  //所有的變量都是全局變量
03  public class var0
04  {
05      byte x;                                           //定義全局變量x
06      short y;                                          //定義全局變量y
07      int z;                                            //定義全局變量z
08      long a;                                           //定義全局變量a
09      float b;                                          //定義全局變量b
10      double c;                                         //定義全局變量c
11      char d;                                           //定義全局變量d
12      boolean e;                                        //定義全局變量e
13      public static void main(String[] args)
14      {
15          var0 m=new var0();                            //創建對象m
16          System.out.println(" 打印數據x="+m.x);
17          System.out.println(" 打印數據y="+m.y);
18          System.out.println(" 打印數據z="+m.z);
19          System.out.println(" 打印數據a="+m.a);
20          System.out.println(" 打印數據b="+m.b);
21          System.out.println(" 打印數據c="+m.c);
22          System.out.println(" 打印數據d="+m.d);
23          System.out.println(" 打印數據e="+m.e);
24      }
25  }

【代碼說明】第5～12行定義了8個變量，它們分別對應8種數據類型。我們并沒有為其設置初始值，第13～23行直接在控制臺輸出這些變量，讀者可以在下面的運行效果中發現有的變量具備默認值，但有的變量什么也不輸出。

【運行效果】

打印數據x=0
打印數據y=0
打印數據z=0
打印數據a=0
打印數據b=0.0
打印數據c=0.0
打印數據d=
打印數據e=false

【實例3-12】從以上例子可以看出，作為全局變量，無須初始化，系統自動給變量賦值。除了字符型數據被賦值為空，布爾型數據被賦值為false，其他一律賦值為0，下面再看一段程序代碼。

01  //通過不同類型的數據的輸出來查看變量如何初始化
02  //所有的變量都是局部變量
03  public class var1
04  {
05      void printnumber()                               //定義了一個名為printnumber的方法
06      {
07          byte x;                                      //定義局部變量x
08          short y;                                     //定義局部變量y
09          int z;                                       //定義局部變量z
10          long a;                                      //定義局部變量a
11          float b;                                     //定義局部變量b
12          double c;                                    //定義局部變量c
13          char d;                                      //定義局部變量d
14          boolean e;                                   //定義局部變量e
15      }
16      public static void main(String[] args)
17      {
18          var1 m=new var1();                           //創建對象m
19          System.out.println(" 打印數據x="+m.x);
20          System.out.println(" 打印數據y="+m.y);
21          System.out.println(" 打印數據z="+m.z);
22          System.out.println(" 打印數據a="+m.a);
23          System.out.println(" 打印數據b="+m.b);
24          System.out.println(" 打印數據c="+m.c);
25          System.out.println(" 打印數據d="+m.d);
26          System.out.println(" 打印數據e="+m.e);
27      }
28  )

【代碼說明】第7～14行定義了8個變量，但其被定義在printnumber()方法中，屬于局部變量。第19～26行在沒有初始化這些變量的時候，在控制臺輸出這些變量，其實是不正確的。

【運行效果】這個程序段編譯時就會報錯，原因是所有局部變量都沒有初始化。

從以上兩段程序代碼得出一個結果：全局變量可以不用進行初始化賦值工作，而局部變量必須要進行初始化賦值工作。

3.5 常量

前兩節詳細介紹了關于Java語言中變量的定義和初始化功能，通過學習我們了解到變量主要用來存儲數值，該數值可以變化，即變量在程序運行期間是可以變化的。從程序開始運行到結束為止，肯定有保持不變的量，它們由誰來存儲呢？這就涉及Java語言中的常量。

在Java程序設計中，使用關鍵字“final”來聲明一個常量。常量表示在程序開始運行到結束期間都不變的量。

【實例3-13】例如下面的程序代碼。

01  //這里的X是一個常量，由于是不在某個方法內的常量，也可以稱為成員常量（作者給它取的名字）
02  public class var2
03  {
04      final int X=20;                                             //定義了一個常量X
05      public static void main(String[] args)
06      {
07          var2 m=new var2();
08          System.out.println(" 打印數據X="+m.X);                  //輸出常量X的值
09      }
10  }

【代碼說明】第4行通過關鍵字final定義了一個常量X。第8行輸出這個常量的值。

注意

常量名一般都定義為大寫字母。

【運行效果】

打印數據X=20

【實例3-14】如果要聲明一個類常量，就需要使用關鍵字static和final的組合，例如下面的例子。

01  //這里的X是類常量，所以無論是哪個對象的引用，它的值始終不變
02  public class var3
03  {
04      static final int X=20;                                    //定義了一個類常量X
05      public static void main(String[] args)
06      {
07          System.out.println(" 打印數據X="+X);                 //輸出類常量X的值
08      }
09  }

【代碼說明】第4行使用關鍵字static和final的組合，定義了類常量X。第7行在沒有實例化對象的情況下，直接在控制臺輸出X的值。

【運行效果】

打印數據X=20

從上面的例子可以看出，如果這個常量是類常量，那么無須再構造對象，可以直接引用這個常量。前一個例子聲明的常量是一般常量，不是類常量，所以一定要構造對象，通過對象來引用這個常量，所以切記類常量和一般常量的區別所在。

3.6 運算符

運算符就是在用變量或常量進行運算時，經常需要用到的運算符號，目前常用的總共有10種：算術運算符、關系運算符、邏輯運算符、位運算符、移位運算符、賦值運算符、三元運算符、逗號運算符、字符串運算符（將在第6章介紹）、轉型運算符。下面將會對每種運算符結合實例進行詳細的講解。

3.6.1 算術運算符

在小學階段就學過“加”、“減”、“乘”、“除”、“余”，其實這也是Java中的算術運算符（也被稱為數學運算符）。下面來看一種情況，當一個浮點型數據加上一個整型數據，其結果是什么類型的數據呢？這涉及數字精度問題，在不同類型的數據之間進行運算時，為了使結果更加精確，系統會將結果自動轉化為精度更高的數據類型。

【實例3-15】以上所述的定義有點復雜，通過下面的例子進行說明。

01  public class var4
02  {
03      public static void main(String[] args)
04      {
05          int a=10;                                           //這里的a是一個整型數據
06          float b=10f;                                        //這里的b是一個浮點型數據
07          System.out.println("a+b="+(a+b));                   //相加后為一個浮點型數據
08      }
09  }

【代碼說明】第5行定義了整型變量a。第6行定義了浮點型變量b。第7行在控制臺輸出兩個變量進行“加”運算后的結果。

【運行效果】

a+b=20.0

以上的程序代碼中，變量a是整型，變量b是單精度浮點型，運算的結果是單精度浮點型。以上的實例說明了一點：為了保證經過算術運算后結果的數據精度，盡量讓結果與運算數據中精度較高的類型相同。這個例子就是讓結果與a、b中精度較高的單精度浮點型b變量的數據類型相同，所以結果類型就是單精度浮點數據類型。

如何將結果進行轉換？轉化有什么規律嗎？筆者根據經驗總結了以下幾點。

□ 當使用運算符把兩個操作數結合到一起時，首先會將兩個操作數轉化成相同類型的數據。

□ 兩個操作數中如有一個是double型，那么另一個操作數一定先轉化成double型，再進行運算。

□ 兩個操作數中如有一個是float型，那么另一個操作數一定先轉化成float型，再進行運算。

□ 兩個操作數中如有一個是long型，那么另一個操作數一定會先轉化成long型，再進行運算。

□ 其他任何兩個基本類型數據操作，兩個操作數都會自動轉化成int型。

明白了數據精度的問題，再回到算術運算符的應用。算術運算符的使用可參考表3-1。

表3-1　算術運算符

說明

表3-1中的++、--運算符的作用說明中的“=”是賦值運算符，把右邊的值賦予左邊的變量，左邊原來的變量值被覆蓋。

【實例3-16】下面通過程序段來熟悉這些運算符的用法。

01  //兩個整型變量a、b通過算術運算符得出的結果
02  public class data1
03  {
04      public static void main(String[] args)
05      {
06          int a=10;                                      //這里的a是一個整型數據
07          int b=3;                                      //這里的b是一個整型數據
08          System.out.println("a+b="+(a+b));
09          System.out.println("a-b="+(a-b));
10          System.out.println("a＊b="+(a＊b));
11          System.out.println("a/b="+(a/b));
12          System.out.println("a%b="+(a%b));
13      }
14  }

【代碼說明】第6～7行先定義兩個整型變量。然后通過第8～12行的加、減、乘、除和求余運算，在控制臺輸出計算結果。

【運行效果】

a+b=13
a-b=7
a＊b=30
a/b=3
a%b=1

下面重點討論自加和自減運算符的用法，它可以使一個變量自動加1和自動減1，得到的值再賦給這個變量。自加運算符又分為兩種：一種是前自加，一種是后自加。

【實例3-17】下面通過一個程序段看看什么是前自加和后自加。

01  public class data2
02  {
03      public static void main(String[] args)
04      {
05          int a=10;
06          System.out.println("a="+(a++));            //輸出整型變量a后自加結果
07      }
08  }

【代碼說明】上面的程序段介紹了后自加，其意義就是：先把a的值賦給a，然后，將a的值加1，存儲到內存空間。于是，a輸出的值就是10，而存儲在內存中的a的值為11。

【運行效果】

a=10

【實例3-18】下面的程序代碼演示了前自加功能。

01  public class data3
02  {
03      public static void main(String[] args)
04      {
05          int a=10;
06          System.out.println("a="+(++a));            //輸出整型變量a前自加結果
07      }
08  }

【代碼說明】上面的程序段演示了前自加，其意義就是：先讓a的值加1，然后再將這個加之后的值賦給a。于是，a的輸出值當然就是11。

【運行效果】

a=11

【實例3-19】下面來看一個綜合的實例。

01  public class data4
02  {
03      public static void main(String[] args)
04      {
05          int a=10;                                      //這里的a是一個整型數據
06          System.out.println("a="+(a++));                //輸出整型變量a后自加結果
07          System.out.println("a="+(++a));                //輸出整型變量a前自加結果
08      }
09  }

【代碼說明】這個程序段首先將a的值賦值給a，然后再將a加1放到內存中，內存中的值為11，那么第一個打印語句的結果就是a=10，接下來，將內存中a的值加1再賦給a，那么a的值為12。

【運行效果】

a=10
a=12

同樣自減運算符也有兩種：一種是前自減，一種是后自減。

【實例3-20】先看下面的程序段。

01  public class data5
02  {
03      public static void main(String[] args)
04      {
05          int a=10;
06          System.out.println("a="+(--a));            //輸出整型變量a前自減結果
07      }
08  }

【代碼說明】這個程序段介紹的是前自減，其意義是：先將a的值減1，然后賦值給a，于是a的結果就是9。

【運行效果】

a=9

【實例3-21】再來看看下面的程序段。

01  public class data6
02  {
03      public static void main(String[] args)
04      {
05          int a=10;
06          System.out.println("a="+(a--));            //輸出整型變量a后自減結果
07      }
08  }

【代碼說明】這個程序段介紹的是后自減，其意義是：將a的值賦給a后，再將a的值自動減1，于是輸出a是10。

【運行效果】

a=10

【實例3-22】下面再看一個綜合實例。

01  public class data7
02  {
03      public static void main(String[] args)
04      {
05          int a=10;                                           //這里的a是一個整型數據
06          System.out.println("a="+(a--));                     //輸出整型變量a后自減結果
07          System.out.println("a="+(--a));                     //輸出整型變量a前自減結果
08      }
09  }

【代碼說明】這個程序段首先將a的值賦值給a，然后再將a減1放到內存中，內存中的值為9。那么第一個打印語句的結果就是a=10。接下來，將內存中a的值減1再賦給a，那么a的值為8。

【運行效果】

a=10
a=8

【實例3-23】在現實的編程中，可能會遇到更加復雜的程序段，下面繼續看一個綜合實例。

01  public class data8
02  {
03      public static void main(String[] args)
04      {
05          int a=10;                                            //這里的a是一個整型數據
06          System.out.println("a="+(a--));                      //輸出整型變量a后自減結果
07          System.out.println("a="+(--a));                      //輸出整型變量a前自減結果
08          System.out.println("a="+(a++));                      //輸出整型變量a后自加結果
09          System.out.println("a="+(++a));                      //輸出整型變量a前自加結果
10      }
11  }

【代碼說明】首先將a的值賦給a，然后將a自動減1放到內存中，此時內存中值為9，所以第一個打印語句輸出的值為10。接著，將內存的值先減1再賦給a，a就為8。隨后，將a的值先賦給a，再將a的值加1放到內存中，所以內存中a為9。最后將內存中的值加1再賦給a，a的值為10。

【運行效果】

a=10
a=8
a=8
a=10

為了能方便地記憶自加和自減運算符的用法，總結如下：

□ ++x：因為++在前，所以可以記憶為先加后用。

□ x++：因為++在后，所以可以記憶為先用后加。

□--x：因為--在前，所以可以記憶為先減后用。

□ x--：因為--在后，所以可以記憶為先用后減。

3.6.2 關系運算符

關系運算符就是指兩個操作數之間的關系，它包括了“>”、“<”等。算術運算符的結果都是數字，而關系運算符的結果則是布爾型數據，這一點一定要注意。關系運算符的使用可參考表3-2。

表3-2　關系運算符

注意

1）區別關系運算符“= =”和賦值運算符“=”，前者是比較符號左右兩邊的數據是否相等，而后者是把符號右邊的數據賦予左邊的變量。

2）“= =”、“！=”可以用于對象的比較，而對象的比較通常不是很簡單的通過對象名字比較或對象類型比較，而是有自己的equal()函數，有些情況下兩個對象是否相等的函數需要程序員自己編寫，這里讀者需要知道該知識點，在深入學習了面向對象技術后會有切身的理解。

在實際開發中，經常使用關系運算符來作為判斷的條件：如果條件是真，會如何處理；如果條件是假，又該如何處理。

【實例3-24】下面看一個簡單的例子，看看關系運算符的輸出是什么樣子。

01  //關系運算符的應用
02  public class data9
03  {
04      public static void main(String[] args)
05      {
06          int a=10;
07          int b=21;
08          System.out.println("說a>b,對嗎？"+(a>b));                  //>運算符使用
09          System.out.println("說a>=b,對嗎？"+(a>=b));                //>=運算符使用
10          System.out.println("說a<b,對嗎？"+(a<b));                  //<運算符使用
11          System.out.println("說a<=b,對嗎？"+(a<=b));                //<=運算符使用
12          System.out.println("說a==b,對嗎？"+(a==b));                //==運算符使用
13          System.out.println("說a!=b,對嗎？"+(a!=b));                //!=運算符使用
14      }
15  }

【代碼說明】第6～7行首先定義了兩個變量a和b。第8～13行通過比較兩個變量的大小，來輸出關系運算的結果。

【運行效果】

說a>b,對嗎？false
說a>=b,對嗎？false
說a<b,對嗎？true
說a<=b,對嗎？true
說a==b,對嗎？false
說a!=b,對嗎？true

說明

從以上的程序段可以看出，關系運算符的結果是布爾型數據。

3.6.3 邏輯運算符

常用的邏輯運算符有3種：“非”、“和”、“或”。邏輯運算符一般與關系運算符結合起來使用，下面將詳細地介紹這3個邏輯運算符。

1.NOT運算符

NOT運算符就是一個否定的意思，因為英文中“NOT”就是“不”的意思，在Java中，NOT用符號“！”表示。

【實例3-25】下面看一個簡單的例子。

01  //非邏輯運算符的應用
02  public class data10
03  {
04      public static void main(String[] args)
05      {
06          int a=10;
07          int b=21;
08          System.out.println("說a>b,對嗎？"+!(a>b));                  //!運算符使用
09      }

10 }

【代碼說明】在程序中，“a>b”是假的，即“false”，但是前面有個“!”否定運算符，將“false”變成了“true”。

【運行效果】

說a>b,對嗎？true

2.AND運算符

根據英文“AND”的意思，就知道此運算符是“與”的意思。使用它必須要滿足AND前后兩個條件。AND運算符在Java中用符號“&&”表示。

【實例3-26】下面看一個簡單的實例。

01  //與邏輯運算符的應用
02  public class data11
03  {
04      public static void main(String[] args)
05      {
06          int a=10;
07          int b=21;
08          System.out.println("認為既a>b又a<b,對嗎？"+((a>b)&&(a<b)));  //&&運算符使用
09      }
10  }

【代碼說明】“a<b”這個關系運算得出的結果是“true”，而“a>b”這個關系運算得出的結果是“false”。兩者用AND這個邏輯運算符連接后，得出的結果是“false”。

【運行效果】

認為既a>b又a<b,對嗎？false

為什么會這樣呢？下面是AND運算符的原理：兩個操作數只要有一個是“false”，那么結果就是“false”，如果兩個操作數都是“true”，那么結果才是“true”。

3.OR運算符

根據英文“OR”的意思，就知道此運算符是“或”的意思，使用它只要滿足OR前后兩個條件中任意一個條件。OR運算符在Java中用符號“||”表示，其原理如下：

兩個操作數只要有一個是“true”，那么結果就是“true”，否則結果就是“false”。

【實例3-27】下面看一個簡單的例子。

01  public class data12
02  {
03      public static void main(String[] args)
04      {
05          int a=10;
06          int b=21;
07          int c=10;
08          System.out.println("認為既a>b又a<b,對嗎？"+((a>=b)||(a==b)));  //||運算符使用
09          System.out.println("認為既a>b又a=c,對嗎？"+((a<b)||(a==c)));   //||運算符使用
10      }
11  }

【代碼說明】上面的程序段中，“a>=b”和“a==b”兩個操作數的結果都是“false”，所以“或”的結果就是“false”；而“a<b”的結果是“true”，“a==c”的結果是“true”，所以結果就是“true”。

【運行效果】

認為既a>b又a<b,對嗎？false
認為既a>b又a=c,對嗎？true

邏輯運算符主要用于判斷條件，例如后面要講解的判斷語句、循環語句的條件判斷等。

表3-3給出了所有邏輯運算符。

表3-3　邏輯運算符

說明

讀者或許發現“&&”與“&”，“|”與“||”的計算結果相同，但是二者之間還是有區別的，對于“&&”和“||”只要計算完左邊的值可以確定整個表達式的值，則不必再進行計算，但是對于“&”和“|”必須把左右兩邊的結果都計算完后才可以計算結果值。

3.6.4 位運算符

位運算符主要針對二進制進行運算，它包括了“與”、“非”、“或”、“異或”。從表面上看似乎有點像邏輯運算符，但邏輯運算符是針對兩個關系表達式來進行邏輯運算，而位運算符主要針對兩個二進制數的位進行運算。下面詳細介紹每個位運算符。

1.與運算符

與運算符用符號“&”表示，其使用規律如下：兩個操作數中位都為1的情況下，結果才為1，否則結果為0。

【實例3-28】例如下面的程序段。

01  public class data13
02  {
03      public static void main(String[] args)
04      {
05          int a=129;
06          int b=128;
07          System.out.println("a和b與的結果是："+(a&b));        //&運算符使用
08      }
09  }

【代碼說明】a的值是129，轉換成二進制就是10000001，而b的值是128，轉換成二進制就是10000000。根據與運算符的運算規律，只有兩個位都是1，結果才是1，可以知道上述結果就是10000000，即128。

【運行效果】

a和b與的結果是：128

2.或運算符

或運算符用符號“|”表示，其運算規律如下：兩個位只要有一個為1，那么結果就是1，否則就為0。

【實例3-29】下面看一個簡單的例子。

01  public class data14
02  {
03      public static void main(String[] args)
04      {
05          int a=129;
06          int b=128;
07          System.out.println("a和b或的結果是："+(a|b));             //|運算符使用
08      }
09  }

【代碼說明】a的值是129，轉換成二進制就是10000001，而b的值是128，轉換成二進制就是10000000，根據或運算符的運算規律，兩個位中有一個是1，結果就是1，可以知道上述結果就是10000001，即129。

【運行效果】

a和b或的結果是：129

3.非運算符

非運算符用符號“～”表示，其運算規律如下：如果位為0，結果是1；如果位為1，結果是0。

【實例3-30】下面看一個簡單例子。

01  public class data15
02  {
03      public static void main(String[] args)
04      {
05          int a=2;
06          System.out.println("a非的結果是："+(～a));                  //～運算符使用
07      }
08  }

【代碼說明】a的值是2，轉換成二進制就是0010，因為非運算就是取相反的位值，而且取反是針對二進制的所有位而言，因為二進制中最高位是1表示負數，所以最終轉換為十進制就是-3。

注意

本章中所計算的一些二進制，計算方法都沒有那么復雜，如int類型占4字節，每個字節是8位，則對于數值2來說，標準的二進制應該是00000000000000000000000000000010，一共是32位。但為了簡化說法，我們并不把多余的零寫出來。上述二進制進行非運算后是11111111111111111111111111111101。對于計算機基礎學得好的讀者，可能還會知道負數的二進制，其實是它絕對值的二進制取反再加1。上述非運算后的結果是00000000000000000000000000000011這個二進制取反加1的結果，而這個值轉換為十進制就是3，因為最高位是1表示負數，所以結果為-3。如果讀者還不明白這些內容，可以參考一些數據結構和匯編語言的專業書籍。

【運行效果】

a非的結果是：-3

4.異或運算符

異或運算符是用符號“^”表示的，其運算規律是：兩個操作數的位中，相同則結果為0，不同則結果為1。

【實例3-31】下面看一個簡單的例子。

01  public class data16
02  {
03      public static void main(String[] args)
04      {
05          int a=15;
06          int b=2;
07          System.out.println("a與 b異或的結果是："+(a^b));              //^運算符使用
08      }
09  }

【代碼說明】a的值是15，轉換成二進制為1111，而b的值是2，轉換成二進制為0010，根據異或的運算規律，可以得出其結果為1101，即13。

【運行效果】

a與 b異或的結果是：13

3.6.5 移位運算符

移位運算符也是針對二進制的“位”，它主要包括：左移運算符（<<）、右移運算符（>>）、無符號右移運算符（>>>）。

1.左移運算符

左移運算符用“<<”表示，是將運算符左邊的對象向左移動運算符右邊指定的位數，并且在低位補0。其實，向左移n位，就相當于乘上2的n次方。

【實例3-32】例如下面的例子。

01  public class data17
02  {
03      public static void main(String[] args)
04      {
05      int a=2;
06      int b=2;
07      System.out.println("a移位的結果是："+(a<<b));              //<<運算符使用
08      }
09  }

【代碼說明】首先從本質上分析，2的二進制是00000010，它向左移動2位，就變成了00001000，即8。如果從另一個角度來分析，它向左移動2位，其實就是乘上2的2次方，結果還是8。

【運行效果】

a移位的結果是：8

2.帶符號右移運算符

帶符號右移運算符用符號“>>”表示，是將運算符左邊的運算對象向右移動運算符右邊指定的位數。如果是正數，在高位補0，如果是負數，則在高位補1。

【實例3-33】先看下面一個簡單的例子。

01  public class data19
02  {
03      public static void main(String[] args)
04      {
05          int a=16;
06          int c=-16;
07          int b=2;
08          int d=2;
09          System.out.println("a的移位結果："+(a>>b));                //>>運算符使用
10          System.out.println("c的移位結果："+(c>>d));                //>>運算符使用
11      }
12  }

【代碼說明】a的值是16，轉換成二進制是00010000，讓它右移兩位就變成00000100，即4。c的值是-16，轉換成二進制是11101111，讓它右移一位是11111011，即-4。

【運行效果】

a的移位結果：4
c的移位結果：-4

3.無符號右移運算符

無符號右移運算符用符號“>>>”表示，是將運算符左邊的對象向右移動運算符右邊指定的位數，并且在高位補0。其實右移n位，就相當于除上2的n次方。

【實例3-34】來看下面的例子。

01  public class data18
02  {
03      public static void main(String[] args)
04      {
05          int a=16;
06          int b=2;
07          System.out.println("a移位的結果是："+(a>>>b));        //>>>運算符使用
08      }
09  }

【代碼說明】從本質上來分析，16的二進制是00010000，它向右移動2位，就變成了00000100，即4。如果從另一個角度來分析，它向右移動2位，其實就是除以2的2次方，結果還是4。

【運行效果】

a移位的結果是：4

現在再來總結一下移位運算符的運算規則：首先把運算對象轉化成二進制位，如把20轉換為二進制則表達為00010100。

1）左移運算規則：把數據對象的二進制位依次左移n位，右邊空出的位置補0，如20<<2 ，計算結果為01010000，十進制值為80。

2）無符號右移運算規則：把數據對象的二進制位依次向右移動n位左邊空出的位置補0，如20>>>2，計算結果為00000101，十進制為5。

3）帶符號右移運算規則：把數據對象的二進制位依次右移n位，移出的數補到左邊。如20>>2，計算結果為00000101，十進制為5。這里恰巧和無符號右移運算結果相同。再舉例如15>>2，15的二進制位表達為00001111，15>>2的計算結果為11000011，十進制為195；而15>>>2的計算結果為00000011，十進制為3 。顯然帶符號右移與無符號右移有明顯區別。

注意

如果讀者仔細分析可以看出左移n位運算相當于把十進制數乘以2的n次方，無符號右移n位運算相當于把十進制數除以2的n次方。如前面計算規則中的例子，20<<2 = 20×22 = 80，20>>>2 = 20/22= 5。

表3-4描述了移位運算符的用法。

表3-4　移位運算符

3.6.6 賦值運算符

賦值就是將數值賦給變量，而賦值運算符就充當了這個賦值的任務，其實最簡單的賦值運算符就是“=”。

當然除了“=”外，還有很多其他賦值運算符，有“+=”、“-=”、“*=”、“/=”、“%=”、“>>=”、“>>>=”、“<<=”、“&=”、“|=”、“^=”。

【實例3-35】下面給出一個簡單的例子。

01  public class data20
02  {
03      public static void main(String[] args)
04      {
05          int a=5;
06          int b=2;
07          System.out.println("a+=b的值："+(a+=b));            //+=運算符使用
08          System.out.println("a-=b的值："+(a-=b));            //-=運算符使用
09          System.out.println("a*=b的值："+(a*=b));            //＊=運算符使用
10          System.out.println("a/=b的值："+(a/=b));            ///=運算符使用
11          System.out.println("a%=b的值："+(a%=b));            //%=運算符使用
12          System.out.println("a>>=b的值："+(a>>=b));          //>>=運算符使用
13          System.out.println("a>>>=b的值："+(a>>>=b));        //>>>=運算符使用
14          System.out.println("a<<=b的值："+(a<<=b));          //<<=運算符使用
15          System.out.println("a&=b的值："+(a&=b));            //&=運算符使用
16          System.out.println("a|=b的值："+(a|=b));            //|=運算符使用
17          System.out.println("a^=b的值："+(a^=b));            //^=運算符使用
18      }
19  }

【代碼說明】第7行的“a+=b”就是a=a+b。第8行的“a-=b”就是a=a-b。第17行的“a^=b”就是a=a^b。

【運行效果】

a+=b的值：7
a-=b的值：5
a＊=b的值：10
a/=b的值：5
a%=b的值：1
a>>=b的值：0
a>>>=b的值：0
a<<=b的值：0
a&=b的值：0
a|=b的值：2
a^=b的值：0

3.6.7 三元運算符

三元運算符一般用得很少，因為它在程序段中的可讀性很差，所以不建議經常使用三元運算符，但很少使用并不代表不使用，所以還是要掌握它的用法。三元運算符的表達形式如下：

布爾表達式？值0:值1

它的運算過程是：如果布爾表達式的結果是true，就返回值0；如果布爾表達式的結果是false，就返回值1。

【實例3-36】例如下面的程序段。

01  public class data21
02  {
03      public static void main(String[] args)
04      {
05          int a=10;
06          int b=20;
07          System.out.println("此三元運算式結果是："+((a>b)?'A':'B'));  //三元運算符應用
08      }
09  }

【代碼說明】因為“a”小于“b”，所以“a>b”這個關系運算符的結果是“false”，既然是“false”，那么選擇值1，即這個三元運算符的結果是“B”。

【運行效果】

此三元運算式結果是：B

3.6.8 逗號運算符

在Java程序設計中，逗號運算符一般是用來將幾個數值彼此分開，例如數組中的每個元素都是使用逗號與其他元素分開的。這個運算符太簡單了，這里不再給出實例。

3.6.9 轉型運算符

轉型運算符的用處是將一種類型的對象或數據，經過強制轉換而轉變為另一種類型的數據。它的格式是在需要轉型的數據前加上“()”，然后在括號內加入需要轉化的數據類型。

【實例3-37】有的數據經過轉型運算后，精度會丟失，而有的會更加精確，下面的例子可以說明這個問題。

01  public class data22
02  {
03      public static void main(String[] args)
04      {
05          int x;
06          double y;
07          x=(int)34.56+(int)11.2;                                //強制轉換
08          y=(double)x+(double)11;                                //強制轉換
09          System.out.println("x="+x);
10          System.out.println("y="+y);
11      }
12  }

【代碼說明】第7行中，由于在34.56前有一個int的強制類型轉化，所以34.56就變成了34。同樣，11.2就變成了11，所以x的結果就是45。第8行中，在x前有一個double類型的強制轉換，所以x的值變為45.0，而數值11也被強制轉換成double類型，所以也變成11.0，所以最后y的值變為56.0。

【運行效果】

x=45
y=56.0

3.6.10 運算符的優先級別

當多個運算符出現在一個表達式中，誰先誰后呢？這就涉及運算符的優先級別。在一個多運算符的表達式中，運算符優先級不同會導致最后的結果差別甚大，例如(1+3)+(3+2)*2，這個表達式如果按加號最優先計算，答案就是18，如果按照乘號最優先計算，答案則是14。

下面將詳細介紹在Java程序設計中，各個運算符的優先級別，如表3-5所示。

如表3-5　運算符的優先級別

3.7 常見疑難解答

3.7.1 如何將十進制轉換成二進制

如何將十進制轉換成二進制？作者有一個方法就是先熟練記憶2的n次方的結果，一般來說記到2的7次方就可以了。

下面將舉例講解這個方法：首先記住20=1、21=2、22=4、23=8、24=16、25=32、26=64、27=128。現在要把十進制155轉換成二進制，因為155是大于128的，所以第8位上肯定是1。用155-128=27，因為27是大于16小于32的，所以第7位、第6位都為0，而第5位就是1。再用27-16=11，11大于8，所以第4位是1。再用11-8=3，3小于4，所以第3位為0。由于3大于2，所以第2位為1，而3-2=1正好等于第1位，所以第1位為1，綜合起來就是：10011011。

3.7.2 轉型運算符會引起精度問題，為什么還要使用它

其實不僅基本類型數據會使用轉型運算符，對象類型的數據也要使用轉型運算符。在使用基本數據轉型時，一般都要從低精度往高精度轉，但是在某些特定的情況下，或者說在用戶特殊要求下，會從高精度轉向低精度。例如有的數字希望能夠去掉小數位，那么就只能從高精度往低精度轉型。

3.8 小結

本章是Java程序設計的基礎，程序中的數據離不開變量和常量，而程序的運算離不開這些數據類型和運算符。本章給出了37個小實例，主要是希望讀者能自己動手多加練習，并找到一些運算的技巧和原理。

3.9 習題

一、填空題

1.整型主要有4種：__________、__________、__________和__________。

2.Java中的數據類型包括__________ 和__________兩種。

3.Java語句的結束符號是__________。

4.在Java程序設計中，使用關鍵字__________來聲明一個常量，常量表示在程序開始運行到結束期間都不變的量。

二、上機實踐

1.創建一個實現輸出數值的各位值的類，即定義一個整型變量，然后通過算術運算符輸出該變量每位的值。

【提示】關鍵代碼如下：

     int num = 8461;
     int gewei = num % 10;
     int shiwei = num / 10 % 10;
     int baiwei = num / 100 % 10;
     int qianwei = num / 1000;

2.創建一個實現大小寫字母轉換的類，即定義一個字符變量，然后通過算術運算符輸出該變量轉換后的字母。

【提示】關鍵代碼如下：

     char a = 'a';
     char b = (char)(a-32);

官术网_书友最值得收藏!

零基礎學Java（第4版）

第3章 Java語言中的數據類型與運算符

3.1 數制

3.1.1 基本概念

3.1.2 Java語言中的數制表現形式

3.2 數據類型

3.2.1 整型

3.2.2 字符型

3.2.3 浮點型

3.2.4 布爾型

3.3 變量

3.3.1 變量的聲明

3.3.2 變量的含義

3.3.3 變量的分類

3.4 變量如何初始化

3.5 常量

3.6 運算符

3.6.1 算術運算符

3.6.2 關系運算符

3.6.3 邏輯運算符

3.6.4 位運算符

3.6.5 移位運算符

3.6.6 賦值運算符

3.6.7 三元運算符

3.6.8 逗號運算符

3.6.9 轉型運算符

3.6.10 運算符的優先級別

3.7 常見疑難解答

3.7.1 如何將十進制轉換成二進制

3.7.2 轉型運算符會引起精度問題，為什么還要使用它

3.8 小結

3.9 習題