- 零基礎(chǔ)學(xué)Java（第4版）
- 常建功 陳浩 黃淼等編著
- 191字
- 2019-01-01 00:49:59
第3章 Java語言中的數(shù)據(jù)類型與運(yùn)算符
本章主要介紹編程語言中最基礎(chǔ)的部分：數(shù)據(jù)類型和運(yùn)算符。這是所有編程語言都必須掌握的基礎(chǔ)知識，也是整個(gè)程序代碼不可缺少的重要部分。本章將通過大量的程序代碼，來講述如何操作這些數(shù)據(jù)類型和運(yùn)算符。熟練地掌握此章對于Java開發(fā)有著非常重要的作用，并且還對以后學(xué)習(xí)其他開發(fā)語言有著重要的幫助。
本章重點(diǎn)：
□ Java語言中的數(shù)制。
□ 數(shù)據(jù)類型。
□ 變量和常量。
□ 各種常見運(yùn)算符。
3.1 數(shù)制
在介紹數(shù)據(jù)之前，先了解數(shù)制的概念。數(shù)制可以說是純粹數(shù)學(xué)上的內(nèi)容，在計(jì)算機(jī)語言開發(fā)中使用得比較頻繁，下面將詳細(xì)講述數(shù)制的有關(guān)知識。
3.1.1 基本概念
在使用計(jì)算機(jī)時(shí)，會遇到數(shù)值、文字、圖像、聲音等信息，計(jì)算機(jī)如何識別這些數(shù)據(jù)信息呢？ 首先，這取決于計(jì)算機(jī)底層硬件是如何識別數(shù)據(jù)的。計(jì)算機(jī)底層硬件只能識別“0”和“1”，這種只有“0”和“1”兩個(gè)數(shù)字符號的組合被稱為二進(jìn)制。例如計(jì)算機(jī)要處理數(shù)字“128”，那么計(jì)算機(jī)會將其轉(zhuǎn)化成二進(jìn)制“10000000”。一個(gè)這么簡單的數(shù)字，要用這么長的數(shù)字符號來代替，在現(xiàn)實(shí)生活中稍顯麻煩，所以后來又引進(jìn)了十六進(jìn)制和八進(jìn)制。實(shí)際開發(fā)中使用最多的是十進(jìn)制，后面會介紹各個(gè)數(shù)制的特征和使用。
3.1.2 Java語言中的數(shù)制表現(xiàn)形式
數(shù)制一般包括二進(jìn)制、八進(jìn)制、十六進(jìn)制和十進(jìn)制。
1.二進(jìn)制
二進(jìn)制的特征：
□ 由兩個(gè)數(shù)字組成：“0”和“1”。
□ 運(yùn)算時(shí)逢二進(jìn)一。
例如：1100110011和10000001。
2.八進(jìn)制
八進(jìn)制的特征：
□ 由8個(gè)數(shù)字組成：“0”、“1”、“2”、“3”、“4”、“5”、“6”、“7”。
□ 運(yùn)算時(shí)逢八進(jìn)一。
例如：014、0726。
注意
八進(jìn)制數(shù)據(jù)以0為前綴。它經(jīng)常會與二進(jìn)制產(chǎn)生混淆，所以在Java程序設(shè)計(jì)中，建議盡量不要使用八進(jìn)制。
3.十六進(jìn)制
十六進(jìn)制的特征：
□ 由16個(gè)數(shù)字組成：“0”、“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”、“A”、“B”、“C”、“D”、“E”、“F”。
□ 運(yùn)算時(shí)逢十六進(jìn)一。
例如：0xB和0x12e。
注意
十六進(jìn)制用A、B、C、D、E、F這6個(gè)字母分別表示10～15。字母不區(qū)分大小寫。十六進(jìn)制數(shù)據(jù)以0x為前綴。
4.十進(jìn)制
十進(jìn)制的特征：
□ 由10個(gè)數(shù)字組成：“0”、“1”、“2”、“3”、“4” 、“5”、“6”、“7”、“8”、“9”。
□ 運(yùn)算時(shí)逢十進(jìn)一。
例如：89、92、168。
3.2 數(shù)據(jù)類型
Java語言是一個(gè)強(qiáng)調(diào)數(shù)據(jù)類型的語言，在聲明任何變量時(shí)，必須將該變量定義為一種數(shù)據(jù)類型。Java中的數(shù)據(jù)類型包括基本數(shù)據(jù)類型和對象類型（也稱為引用數(shù)據(jù)類型）。對象類型不屬于本章所講述的內(nèi)容，本章主要介紹數(shù)據(jù)的基本類型。Java程序中，總共有8大基本類型：其中包括4種整型、1種字符型、2種浮點(diǎn)型、1種布爾型。除了這幾種基本類型外，其他都屬于對象類型的數(shù)據(jù)。
3.2.1 整型
什么是整型呢？從字面上就可以知道，整型就是整數(shù)類型，也就是沒有小數(shù)點(diǎn)的數(shù)字，可以是正數(shù)也可以是負(fù)數(shù)。在Java中，整型主要有4種：字節(jié)型（byte）、整數(shù)型（int）、短整型（short）、長整型（long）。
1.字節(jié)型
【實(shí)例3-1】byte用一個(gè)字節(jié)來表示整數(shù)值，它的范圍介于-128～127之間。通常這種類型的整型數(shù)據(jù)擁有上節(jié)中提到的所有進(jìn)制。但無論采用哪種進(jìn)制，在輸出控制臺上，系統(tǒng)都會將其自動轉(zhuǎn)化為十進(jìn)制，從下列代碼段可以得到證實(shí)。
01 public class Byte {
02 public static void main(String[] args) {
03 byte x = 22; //x是十進(jìn)制數(shù)
04 byte y = 022; //y是八進(jìn)制數(shù)
05 byte z = 0x22; //z是十六進(jìn)制數(shù)
06 //輸出相應(yīng)十進(jìn)制的值
07 System.out.println("轉(zhuǎn)化成十進(jìn)制,x=" + x);
08 System.out.println("轉(zhuǎn)化成十進(jìn)制,y=" + y);
09 System.out.println("轉(zhuǎn)化成十進(jìn)制,z=" + z);
10 }
11 }
【代碼說明】第3～5行定義了3個(gè)byte型變量，分別代表不同的數(shù)制，第4行的變量值前綴是0，第5行的變量值前綴是0x。第7～9行并沒有使用類型轉(zhuǎn)換的函數(shù)，而是直接輸出這3個(gè)變量。
【運(yùn)行效果】在DOS窗口中，通過Javac編譯該源代碼，然后通過Java執(zhí)行編譯后的class文件。最終結(jié)果如下所示。
轉(zhuǎn)化成十進(jìn)制,x=22 轉(zhuǎn)化成十進(jìn)制,y=18 轉(zhuǎn)化成十進(jìn)制,z=34
2.短整型
【實(shí)例3-2】short用兩個(gè)字節(jié)表示整數(shù)值，其整數(shù)值介于-32768～32767之間。它有八進(jìn)制、十進(jìn)制和十六進(jìn)制3種表示方法，其表示方法與字節(jié)型是一樣的，從下面的程序段可以證實(shí)。
01 public class Short
02 {
03 public static void main(String[] args)
04 {
05 short x=22; //十進(jìn)制
06 short y=022; //八進(jìn)制
07 short z=0x22; //十六進(jìn)制
08 System.out.println("轉(zhuǎn)化成十進(jìn)制,x="+ x);
09 System.out.println("轉(zhuǎn)化成十進(jìn)制,y="+ y);
10 System.out.println("轉(zhuǎn)化成十進(jìn)制,z="+ z);
11 }
12 }
【代碼說明】第5～7行定義了3個(gè)short型變量，依然是用前綴0和0x代表八進(jìn)制和十六進(jìn)制。第8～10行沒有使用數(shù)據(jù)類型轉(zhuǎn)換的函數(shù)，直接輸出結(jié)果。
【運(yùn)行效果】
轉(zhuǎn)化成十進(jìn)制,x=22 轉(zhuǎn)化成十進(jìn)制,y=18 轉(zhuǎn)化成十進(jìn)制,z=34
可以看出，兩個(gè)程序段運(yùn)行結(jié)果都是一樣的。其實(shí)，在實(shí)際編程過程中，開發(fā)者最常用的整型是int型。
3.整數(shù)型
【實(shí)例3-3】整數(shù)型又稱作int型，用4個(gè)字節(jié)來表示整數(shù)值，其整數(shù)值介于-2147483648～2147483647之間。整數(shù)型擁有以上所說的各種進(jìn)制，其表示方法與字節(jié)型也相同，從下面的程序段同樣可以證實(shí)。
01 public class Int
02 {
03 public static void main(String[] args)
04 {
05 int x=22; //十進(jìn)制
06 int y=022; //八進(jìn)制
07 int z=0x22; //十六進(jìn)制
08 System.out.println("轉(zhuǎn)化成十進(jìn)制,x="+ x);
09 System.out.println("轉(zhuǎn)化成十進(jìn)制,y="+ y);
10 System.out.println("轉(zhuǎn)化成十進(jìn)制,z="+ z);
11 }
12 }
【代碼說明】第5～7行同樣定義了3種進(jìn)制的變量，通過前綴0和0x來區(qū)別進(jìn)制。第8～10行依然是直接輸出變量的值，而沒有顯式地進(jìn)行類型轉(zhuǎn)換。
【運(yùn)行效果】
轉(zhuǎn)化成十進(jìn)制,x=22 轉(zhuǎn)化成十進(jìn)制,y=18 轉(zhuǎn)化成十進(jìn)制,z=34
4.長整型
【實(shí)例3-4】長整型long用8個(gè)字節(jié)表示整數(shù)型，其數(shù)值介于-9223372036854775808～9223372036854775807之間。它的所有特性基本與前幾種整型一樣，唯一不同的是，長整型的數(shù)據(jù)后面有一個(gè)“L”字母，這個(gè)也是從表現(xiàn)形式上區(qū)別于其他整型的最大特征。可從下面的程序代碼段中了解長整型與其他整型的區(qū)別。
01 public class Long
02 {
03 public static void main(String[] args)
04 {
05 long x=22L; //十進(jìn)制
06 long y=022L; //八進(jìn)制
07 long z=0x22L; //十六進(jìn)制
08 System.out.println("轉(zhuǎn)化成十進(jìn)制,x="+ x);
09 System.out.println("轉(zhuǎn)化成十進(jìn)制,y="+ y);
10 System.out.println("轉(zhuǎn)化成十進(jìn)制,z="+ z);
11 }
12 }
【代碼說明】第5～7行定義了3個(gè)長整型變量，要注意的是結(jié)尾的標(biāo)識“L”。第8～10行直接輸出變量的值，會自動進(jìn)行類型轉(zhuǎn)換，輸出的結(jié)果都是用十進(jìn)制表示的。
【運(yùn)行效果】
轉(zhuǎn)化成十進(jìn)制,x=22 轉(zhuǎn)化成十進(jìn)制,y=18 轉(zhuǎn)化成十進(jìn)制,z=34
從以上程序代碼段中可以看出，4種不同的整型類型的數(shù)據(jù)，在程序段中所表現(xiàn)出來的運(yùn)行結(jié)果幾乎是一樣的。不同的是每個(gè)類型數(shù)據(jù)的取值范圍不一樣，隨著字節(jié)數(shù)增多，取值范圍增大。雖然長整型的數(shù)據(jù)可以表示很大的數(shù)據(jù)，但如果超過了長整型的數(shù)據(jù)取值范圍，該如何處理這些數(shù)據(jù)呢？在Java中，有一種大數(shù)值類型的數(shù)據(jù)，由于它屬于對象類型數(shù)據(jù)，所以此處不做介紹。
3.2.2 字符型
字符型數(shù)據(jù)是平時(shí)程序設(shè)計(jì)中使用比較頻繁的類型，其占兩個(gè)字節(jié)。特別注意的是，它必須以單引號表示，例如'A'表示一個(gè)字符，這個(gè)字符就是A。"A"表示一個(gè)字符串，雖然只有一個(gè)字符，但因?yàn)槭褂秒p引號，所以它仍然表示字符串，而不是字符。
總之，字符數(shù)據(jù)類型只能表示單個(gè)字符，任何超過一個(gè)字符的內(nèi)容，都不能被聲明為字符型。字符的聲明是用單引號，通過輸出控制臺，看到的是單引號內(nèi)的字符數(shù)據(jù)。
【實(shí)例3-5】通過下面的程序代碼，來看看字符型數(shù)據(jù)是如何輸出的。
01 //聲明了x,y,z,a 四個(gè)字符型數(shù)據(jù)變量
02 public class Char
03 {
04 public static void main(String[] args)
05 {
06 char x='美'; //聲明一個(gè)字符型變量
07 char y='國'; //聲明一個(gè)字符型變量
08 char z='人'; //聲明一個(gè)字符型變量
09 char a='民'; //聲明一個(gè)字符型變量
10 System.out.println("這些字符組合起來就是："+x+y+z+a);
11 }
12 }
【代碼說明】第6～9行定義了4個(gè)字符型變量，第10行輸出變量的內(nèi)容，將字符型數(shù)據(jù)連接在一起使用的運(yùn)算符也是“+”。
【運(yùn)行效果】
這些字符組合起來就是：美國人民
字符型數(shù)據(jù)和整型數(shù)據(jù)都是無小數(shù)點(diǎn)的數(shù)據(jù)，下面將要講述的類型則是帶小數(shù)點(diǎn)的數(shù)據(jù)，用專業(yè)術(shù)語來講就是浮點(diǎn)型。
3.2.3 浮點(diǎn)型
浮點(diǎn)型數(shù)據(jù)表示有小數(shù)部分的數(shù)字，總共有兩種類型：單精度浮點(diǎn)型（float）和雙精度浮點(diǎn)型（double）。
1.單精度浮點(diǎn)型
單精度浮點(diǎn)型占4個(gè)字節(jié)，有效數(shù)字最長為7位，有效數(shù)字長度包括了整數(shù)部分和小數(shù)部分。一個(gè)單精度浮點(diǎn)型的數(shù)據(jù)定義如下所示。
float x=223.56F
注意
在每個(gè)單精度浮點(diǎn)型數(shù)據(jù)后面，都有一個(gè)標(biāo)志性符號“F”或者“f”，有這個(gè)標(biāo)志就代表是單精度浮點(diǎn)型數(shù)據(jù)。
【實(shí)例3-6】下面演示單精度浮點(diǎn)型數(shù)據(jù)在程序代碼段中的使用情況。
01 //聲明了x,y,z三個(gè)浮點(diǎn)型變量
02 public class Float
03 {
04 public static void main(String[] args)
05 {
06 float x=22.2f; //聲明一個(gè)單精度類型變量
07 float y=42.2f; //聲明一個(gè)單精度類型變量
08 float z=x*y; //實(shí)現(xiàn)相乘
09 System.out.println("x＊y="+z);
10 }
11 }
【代碼說明】第6～7行定義了兩個(gè)浮點(diǎn)型數(shù)據(jù)，它們都以“f”標(biāo)識結(jié)尾。第8行定義了變量z，其值是前面定義的變量x和y的乘積。第9行輸出計(jì)算結(jié)果z。
【運(yùn)行效果】
x＊y=936.84
提示
如果在一個(gè)浮點(diǎn)數(shù)后面加上“F”或者“f”時(shí)，表示的就是單精度浮點(diǎn)型數(shù)據(jù)，否則，系統(tǒng)會認(rèn)為是雙精度浮點(diǎn)型數(shù)據(jù)。
2.雙精度浮點(diǎn)型
雙精度浮點(diǎn)型數(shù)據(jù)占據(jù)8個(gè)字節(jié)，有效數(shù)字最長為15位，后面帶有標(biāo)志性符號 “D”或“d”。系統(tǒng)默認(rèn)不帶標(biāo)志性符號的浮點(diǎn)型數(shù)據(jù)是雙精度浮點(diǎn)型數(shù)據(jù)。雙精度浮點(diǎn)型數(shù)據(jù)的定義如下所示。
double x=33.5D
【實(shí)例3-7】下面是一個(gè)簡單的程序代碼段。
01 public class Double
02 {
03 public static void main(String[] args)
04 {
05 float x=23f; //聲明一個(gè)單精度類型變量
06 double y=44; //聲明一個(gè)雙精度類型變量
07 System.out.println("x="+x);
08 System.out.println("y="+y);
09 }
10 }
【代碼說明】第5行定義了一個(gè)單精度浮點(diǎn)型變量x，但沒有帶小數(shù)位。第6行定義了一個(gè)雙精度浮點(diǎn)型變量y，也沒有帶小數(shù)位，也沒有加標(biāo)識“D”。第7～8行分別在控制臺輸出兩個(gè)變量，注意輸出的結(jié)果。
【運(yùn)行效果】
x=23.0 y=44.0
從這段程序代碼中可以看出，即使浮點(diǎn)型數(shù)據(jù)是一個(gè)只有整數(shù)位沒有小數(shù)位的數(shù)據(jù)，在輸出控制臺上，其仍然是帶小數(shù)點(diǎn)的浮點(diǎn)數(shù)據(jù)，系統(tǒng)會自動加上小數(shù)點(diǎn)，并且小數(shù)位全部置0。
3.2.4 布爾型
布爾型數(shù)據(jù)其實(shí)很簡單，例如，如果有人問：去不去麥當(dāng)勞？可以說“不去”。如果有人問：去不去看電影？可以說“去”。這里就隱藏著布爾型數(shù)據(jù)，布爾型數(shù)據(jù)就是“是”與“否”。在程序中使用“真”和“假”來代替“是”與“否”，即“true”和“false”。布爾類型的默認(rèn)值是false，即如果定義了一個(gè)布爾變量但沒有賦初值，默認(rèn)該布爾變量值是false。
【實(shí)例3-8】仔細(xì)觀察下面的程序代碼。
01 public class Boolean {
02 public static void main(String[] args) {
03 int a = 30; //聲明一個(gè)整型變量a
04 int b = 59; //聲明一個(gè)整型變量b
05 boolean x, y, z; //聲明三個(gè)布爾型變量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 }
【代碼說明】
□ 當(dāng)執(zhí)行第6行代碼“a>b”時(shí)，不等式不成立，所以x的結(jié)果是假。
□ 當(dāng)執(zhí)行第7行代碼“a<b”時(shí)，不等式成立，所以y的結(jié)果是真。
□ 當(dāng)執(zhí)行第8行代碼“a+b==50”時(shí)，結(jié)果不成立，所以z的結(jié)果是假。
說明
布爾型數(shù)據(jù)在只有兩種選擇，不可能出現(xiàn)第三種選擇的情況下使用。
【運(yùn)行效果】
x=false y=true z=false
在程序設(shè)計(jì)的過程中，如果一個(gè)參數(shù)只有正和反兩方面，就可以將其設(shè)置為布爾型類型。
3.3 變量
在上一節(jié)詳細(xì)介紹了Java語言中的數(shù)據(jù)類型及其功能。在具體實(shí)例代碼中我們定義了很多變量，那么變量究竟是什么呢？本節(jié)將介紹變量的基本概念，以及如何操作變量。
3.3.1 變量的聲明
變量就是在程序的運(yùn)行中可以變化的量，變量是程序設(shè)計(jì)中一個(gè)非常重要和關(guān)鍵的概念。在Java程序設(shè)計(jì)中，每個(gè)聲明過的變量都必須分配一個(gè)類型。聲明一個(gè)變量時(shí)，應(yīng)該先聲明變量的類型，隨后再聲明變量的名字。下面演示了變量的聲明方式。
01 //salary,age,op都是變量名字 02 //double,int,boolean則是變量的類型 03 double salary; 04 int age; 05 boolean op;
每一行的第一項(xiàng)是變量類型，第二項(xiàng)是變量名。行尾的分號是必需的，這是Java語句的結(jié)束符號。如果沒有這個(gè)分號，程序不會認(rèn)為這是一句完整的Java語句。
同一類型的不同變量，可以聲明在一行，也可以聲明在不同行，如果在同一行中聲明，不同的變量之間用逗號分隔，如下面的例子。
int studentNumber,people;
3.3.2 變量的含義
在程序設(shè)計(jì)中，經(jīng)常會聽到變量這個(gè)名詞，到底什么是變量呢？它又有什么意義呢？
在程序運(yùn)行過程中，空間內(nèi)的值是變化的，這個(gè)內(nèi)存空間就稱為變量。為了操作方便，給這個(gè)空間取名，稱為變量名，內(nèi)存空間內(nèi)的值就是變量值。所以，申請了內(nèi)存空間，變量不一定有值，要想變量有值，就必須要放入值。
例如：代碼“int x”，定義了變量但沒有賦值，即申請了內(nèi)存空間，但沒有放入值。如果“int x=5”，說明不但申請了內(nèi)存空間而且還放入了值，值為5。
3.3.3 變量的分類
變量的分類方式多種多樣，不可能單純地將變量劃分為幾類，下面將以不同的分類方式來討論變量的分類問題。
1.根據(jù)作用范圍劃分
根據(jù)作用范圍來分，一般將變量分為全局變量和局部變量。從字面上理解很簡單，全局變量就是在程序范圍之內(nèi)都有效的變量，而局部變量就是在程序中的部分區(qū)域有效的變量。
【實(shí)例3-9】從專業(yè)的角度來解釋，全局變量就是在類的整個(gè)范圍之內(nèi)都有效的變量。而局部變量就是在類中某個(gè)方法函數(shù)或某個(gè)子類內(nèi)有效的變量，下面將從實(shí)際程序代碼中慢慢地體會。
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("這個(gè)是全局變量a="+ v.a);
11 v.print();
12 }
13 void print()
14 {
15 int c=20; //定義局部變量c
16 System.out.println("這個(gè)是局部變量c="+ c);
17 }
18 }
【代碼說明】第5～6行定義了兩個(gè)變量，它們在main()方法外。第15行在print()方法內(nèi)定義了變量c，第16行在當(dāng)前方法內(nèi)輸出此變量。
【運(yùn)行效果】
這個(gè)是全局變量a=10 這個(gè)是局部變量c=20
【實(shí)例3-10】如果在main()方法中同樣輸出c的值，會出現(xiàn)什么樣的結(jié)果呢？下面從實(shí)際代碼段中仔細(xì)體會。
01 public class Math1
02 {
03 public static void main(String[] args)
04 {
05 Math1 v=new Math1();
06 System.out.println("這個(gè)是局部變量c="+ v.c); //輸出全局變量c
07 }
08 void print()
09 {
10 int c=20; //定義局部變量c
11 }
12 }
【運(yùn)行效果】以上代碼在編譯時(shí)，會出現(xiàn)錯(cuò)誤，即找不到變量c。這說明變量c只在方法print()中起作用，在方法外就無法再調(diào)用。
【代碼說明】從上述代碼中可以看出，如果一個(gè)變量在類中定義，那么這個(gè)變量就是全局變量，例如下面的代碼段。
01 public class var
02 {
03 int a=10; //定義全局變量a
04 int b=21; //定義全局變量b
05 }
這里的變量a、b都是全局變量，而在類的方法、函數(shù)中定義的變量就是局部變量，例如下面的代碼段。
01 public class var
02 {
03 void print()
04 {
05 int c=20; //定義局部變量c
06 }
07 }
這里的變量c就是局部變量。因?yàn)樗皇窃陬愔兄苯佣x的，而是在類的方法中定義的。
2.根據(jù)類型劃分
如果根據(jù)類型劃分，可以將變量分為基本類型變量和對象類型變量，而基本類型變量就是前面說的8種基本數(shù)據(jù)類型的變量，如整型、浮點(diǎn)型、字符型、布爾型等。
說明
對象類型將在后面的章節(jié)中介紹，這里暫時(shí)不做具體的說明。
3.根據(jù)所屬范圍劃分
如果按所屬范圍來分，可以將變量分為類變量和成員變量，類變量就是用關(guān)鍵字“static”聲明的全局變量，它是屬于類的。而成員變量就是不用“static”聲明的其他實(shí)例變量，它是屬于對象本身的。
其實(shí)類變量就是在類中直接定義的，并且不隨類產(chǎn)生的對象變化而變化。當(dāng)在一個(gè)類中聲明了一個(gè)類變量時(shí)，無論創(chuàng)造出多少個(gè)對象，使用對象引用這個(gè)變量，都不會發(fā)生變化。成員變量就不同了，它隨著對象不同而變化。即針對同一個(gè)類，新創(chuàng)建一個(gè)對象，使用此對象引用這個(gè)變量，每次引用的值都不一樣。
3.4 變量如何初始化
在C、C++、C#等語言中，都會提到變量的初始化，有關(guān)對象類型變量的初始化將在后面的章節(jié)詳細(xì)講述，這里將把基本類型變量的初始化作為本節(jié)的主要內(nèi)容。
【實(shí)例3-11】基本類型變量的初始化工作，就是給變量賦值。為了能夠更加清晰地看到變量如何初始化，以及初始化時(shí)需要注意的知識點(diǎn)，下面通過實(shí)例來演示。
01 //通過不同類型的數(shù)據(jù)的輸出來查看變量如何初始化
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(); //創(chuàng)建對象m
16 System.out.println(" 打印數(shù)據(jù)x="+m.x);
17 System.out.println(" 打印數(shù)據(jù)y="+m.y);
18 System.out.println(" 打印數(shù)據(jù)z="+m.z);
19 System.out.println(" 打印數(shù)據(jù)a="+m.a);
20 System.out.println(" 打印數(shù)據(jù)b="+m.b);
21 System.out.println(" 打印數(shù)據(jù)c="+m.c);
22 System.out.println(" 打印數(shù)據(jù)d="+m.d);
23 System.out.println(" 打印數(shù)據(jù)e="+m.e);
24 }
25 }
【代碼說明】第5～12行定義了8個(gè)變量，它們分別對應(yīng)8種數(shù)據(jù)類型。我們并沒有為其設(shè)置初始值，第13～23行直接在控制臺輸出這些變量，讀者可以在下面的運(yùn)行效果中發(fā)現(xiàn)有的變量具備默認(rèn)值，但有的變量什么也不輸出。
【運(yùn)行效果】
打印數(shù)據(jù)x=0 打印數(shù)據(jù)y=0 打印數(shù)據(jù)z=0 打印數(shù)據(jù)a=0 打印數(shù)據(jù)b=0.0 打印數(shù)據(jù)c=0.0 打印數(shù)據(jù)d= 打印數(shù)據(jù)e=false
【實(shí)例3-12】從以上例子可以看出，作為全局變量，無須初始化，系統(tǒng)自動給變量賦值。除了字符型數(shù)據(jù)被賦值為空，布爾型數(shù)據(jù)被賦值為false，其他一律賦值為0，下面再看一段程序代碼。
01 //通過不同類型的數(shù)據(jù)的輸出來查看變量如何初始化
02 //所有的變量都是局部變量
03 public class var1
04 {
05 void printnumber() //定義了一個(gè)名為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(); //創(chuàng)建對象m
19 System.out.println(" 打印數(shù)據(jù)x="+m.x);
20 System.out.println(" 打印數(shù)據(jù)y="+m.y);
21 System.out.println(" 打印數(shù)據(jù)z="+m.z);
22 System.out.println(" 打印數(shù)據(jù)a="+m.a);
23 System.out.println(" 打印數(shù)據(jù)b="+m.b);
24 System.out.println(" 打印數(shù)據(jù)c="+m.c);
25 System.out.println(" 打印數(shù)據(jù)d="+m.d);
26 System.out.println(" 打印數(shù)據(jù)e="+m.e);
27 }
28 )
【代碼說明】第7～14行定義了8個(gè)變量，但其被定義在printnumber()方法中，屬于局部變量。第19～26行在沒有初始化這些變量的時(shí)候，在控制臺輸出這些變量，其實(shí)是不正確的。
【運(yùn)行效果】這個(gè)程序段編譯時(shí)就會報(bào)錯(cuò)，原因是所有局部變量都沒有初始化。
從以上兩段程序代碼得出一個(gè)結(jié)果：全局變量可以不用進(jìn)行初始化賦值工作，而局部變量必須要進(jìn)行初始化賦值工作。
3.5 常量
前兩節(jié)詳細(xì)介紹了關(guān)于Java語言中變量的定義和初始化功能，通過學(xué)習(xí)我們了解到變量主要用來存儲數(shù)值，該數(shù)值可以變化，即變量在程序運(yùn)行期間是可以變化的。從程序開始運(yùn)行到結(jié)束為止，肯定有保持不變的量，它們由誰來存儲呢？這就涉及Java語言中的常量。
在Java程序設(shè)計(jì)中，使用關(guān)鍵字“final”來聲明一個(gè)常量。常量表示在程序開始運(yùn)行到結(jié)束期間都不變的量。
【實(shí)例3-13】例如下面的程序代碼。
01 //這里的X是一個(gè)常量，由于是不在某個(gè)方法內(nèi)的常量，也可以稱為成員常量（作者給它取的名字）
02 public class var2
03 {
04 final int X=20; //定義了一個(gè)常量X
05 public static void main(String[] args)
06 {
07 var2 m=new var2();
08 System.out.println(" 打印數(shù)據(jù)X="+m.X); //輸出常量X的值
09 }
10 }
【代碼說明】第4行通過關(guān)鍵字final定義了一個(gè)常量X。第8行輸出這個(gè)常量的值。
注意
常量名一般都定義為大寫字母。
【運(yùn)行效果】
打印數(shù)據(jù)X=20
【實(shí)例3-14】如果要聲明一個(gè)類常量，就需要使用關(guān)鍵字static和final的組合，例如下面的例子。
01 //這里的X是類常量，所以無論是哪個(gè)對象的引用，它的值始終不變
02 public class var3
03 {
04 static final int X=20; //定義了一個(gè)類常量X
05 public static void main(String[] args)
06 {
07 System.out.println(" 打印數(shù)據(jù)X="+X); //輸出類常量X的值
08 }
09 }
【代碼說明】第4行使用關(guān)鍵字static和final的組合，定義了類常量X。第7行在沒有實(shí)例化對象的情況下，直接在控制臺輸出X的值。
【運(yùn)行效果】
打印數(shù)據(jù)X=20
從上面的例子可以看出，如果這個(gè)常量是類常量，那么無須再構(gòu)造對象，可以直接引用這個(gè)常量。前一個(gè)例子聲明的常量是一般常量，不是類常量，所以一定要構(gòu)造對象，通過對象來引用這個(gè)常量，所以切記類常量和一般常量的區(qū)別所在。
3.6 運(yùn)算符
運(yùn)算符就是在用變量或常量進(jìn)行運(yùn)算時(shí)，經(jīng)常需要用到的運(yùn)算符號，目前常用的總共有10種：算術(shù)運(yùn)算符、關(guān)系運(yùn)算符、邏輯運(yùn)算符、位運(yùn)算符、移位運(yùn)算符、賦值運(yùn)算符、三元運(yùn)算符、逗號運(yùn)算符、字符串運(yùn)算符（將在第6章介紹）、轉(zhuǎn)型運(yùn)算符。下面將會對每種運(yùn)算符結(jié)合實(shí)例進(jìn)行詳細(xì)的講解。
3.6.1 算術(shù)運(yùn)算符
在小學(xué)階段就學(xué)過“加”、“減”、“乘”、“除”、“余”，其實(shí)這也是Java中的算術(shù)運(yùn)算符（也被稱為數(shù)學(xué)運(yùn)算符）。下面來看一種情況，當(dāng)一個(gè)浮點(diǎn)型數(shù)據(jù)加上一個(gè)整型數(shù)據(jù)，其結(jié)果是什么類型的數(shù)據(jù)呢？這涉及數(shù)字精度問題，在不同類型的數(shù)據(jù)之間進(jìn)行運(yùn)算時(shí)，為了使結(jié)果更加精確，系統(tǒng)會將結(jié)果自動轉(zhuǎn)化為精度更高的數(shù)據(jù)類型。
【實(shí)例3-15】以上所述的定義有點(diǎn)復(fù)雜，通過下面的例子進(jìn)行說明。
01 public class var4
02 {
03 public static void main(String[] args)
04 {
05 int a=10; //這里的a是一個(gè)整型數(shù)據(jù)
06 float b=10f; //這里的b是一個(gè)浮點(diǎn)型數(shù)據(jù)
07 System.out.println("a+b="+(a+b)); //相加后為一個(gè)浮點(diǎn)型數(shù)據(jù)
08 }
09 }
【代碼說明】第5行定義了整型變量a。第6行定義了浮點(diǎn)型變量b。第7行在控制臺輸出兩個(gè)變量進(jìn)行“加”運(yùn)算后的結(jié)果。
【運(yùn)行效果】
a+b=20.0
以上的程序代碼中，變量a是整型，變量b是單精度浮點(diǎn)型，運(yùn)算的結(jié)果是單精度浮點(diǎn)型。以上的實(shí)例說明了一點(diǎn)：為了保證經(jīng)過算術(shù)運(yùn)算后結(jié)果的數(shù)據(jù)精度，盡量讓結(jié)果與運(yùn)算數(shù)據(jù)中精度較高的類型相同。這個(gè)例子就是讓結(jié)果與a、b中精度較高的單精度浮點(diǎn)型b變量的數(shù)據(jù)類型相同，所以結(jié)果類型就是單精度浮點(diǎn)數(shù)據(jù)類型。
如何將結(jié)果進(jìn)行轉(zhuǎn)換？轉(zhuǎn)化有什么規(guī)律嗎？筆者根據(jù)經(jīng)驗(yàn)總結(jié)了以下幾點(diǎn)。
□ 當(dāng)使用運(yùn)算符把兩個(gè)操作數(shù)結(jié)合到一起時(shí)，首先會將兩個(gè)操作數(shù)轉(zhuǎn)化成相同類型的數(shù)據(jù)。
□ 兩個(gè)操作數(shù)中如有一個(gè)是double型，那么另一個(gè)操作數(shù)一定先轉(zhuǎn)化成double型，再進(jìn)行運(yùn)算。
□ 兩個(gè)操作數(shù)中如有一個(gè)是float型，那么另一個(gè)操作數(shù)一定先轉(zhuǎn)化成float型，再進(jìn)行運(yùn)算。
□ 兩個(gè)操作數(shù)中如有一個(gè)是long型，那么另一個(gè)操作數(shù)一定會先轉(zhuǎn)化成long型，再進(jìn)行運(yùn)算。
□ 其他任何兩個(gè)基本類型數(shù)據(jù)操作，兩個(gè)操作數(shù)都會自動轉(zhuǎn)化成int型。
明白了數(shù)據(jù)精度的問題，再回到算術(shù)運(yùn)算符的應(yīng)用。算術(shù)運(yùn)算符的使用可參考表3-1。
表3-1 算術(shù)運(yùn)算符
說明
表3-1中的++、--運(yùn)算符的作用說明中的“=”是賦值運(yùn)算符，把右邊的值賦予左邊的變量，左邊原來的變量值被覆蓋。
【實(shí)例3-16】下面通過程序段來熟悉這些運(yùn)算符的用法。
01 //兩個(gè)整型變量a、b通過算術(shù)運(yùn)算符得出的結(jié)果
02 public class data1
03 {
04 public static void main(String[] args)
05 {
06 int a=10; //這里的a是一個(gè)整型數(shù)據(jù)
07 int b=3; //這里的b是一個(gè)整型數(shù)據(jù)
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行先定義兩個(gè)整型變量。然后通過第8～12行的加、減、乘、除和求余運(yùn)算，在控制臺輸出計(jì)算結(jié)果。
【運(yùn)行效果】
a+b=13 a-b=7 a＊b=30 a/b=3 a%b=1
下面重點(diǎn)討論自加和自減運(yùn)算符的用法，它可以使一個(gè)變量自動加1和自動減1，得到的值再賦給這個(gè)變量。自加運(yùn)算符又分為兩種：一種是前自加，一種是后自加。
【實(shí)例3-17】下面通過一個(gè)程序段看看什么是前自加和后自加。
01 public class data2
02 {
03 public static void main(String[] args)
04 {
05 int a=10;
06 System.out.println("a="+(a++)); //輸出整型變量a后自加結(jié)果
07 }
08 }
【代碼說明】上面的程序段介紹了后自加，其意義就是：先把a(bǔ)的值賦給a，然后，將a的值加1，存儲到內(nèi)存空間。于是，a輸出的值就是10，而存儲在內(nèi)存中的a的值為11。
【運(yùn)行效果】
a=10
【實(shí)例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前自加結(jié)果
07 }
08 }
【代碼說明】上面的程序段演示了前自加，其意義就是：先讓a的值加1，然后再將這個(gè)加之后的值賦給a。于是，a的輸出值當(dāng)然就是11。
【運(yùn)行效果】
a=11
【實(shí)例3-19】下面來看一個(gè)綜合的實(shí)例。
01 public class data4
02 {
03 public static void main(String[] args)
04 {
05 int a=10; //這里的a是一個(gè)整型數(shù)據(jù)
06 System.out.println("a="+(a++)); //輸出整型變量a后自加結(jié)果
07 System.out.println("a="+(++a)); //輸出整型變量a前自加結(jié)果
08 }
09 }
【代碼說明】這個(gè)程序段首先將a的值賦值給a，然后再將a加1放到內(nèi)存中，內(nèi)存中的值為11，那么第一個(gè)打印語句的結(jié)果就是a=10，接下來，將內(nèi)存中a的值加1再賦給a，那么a的值為12。
【運(yùn)行效果】
a=10 a=12
同樣自減運(yùn)算符也有兩種：一種是前自減，一種是后自減。
【實(shí)例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前自減結(jié)果
07 }
08 }
【代碼說明】這個(gè)程序段介紹的是前自減，其意義是：先將a的值減1，然后賦值給a，于是a的結(jié)果就是9。
【運(yùn)行效果】
a=9
【實(shí)例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后自減結(jié)果
07 }
08 }
【代碼說明】這個(gè)程序段介紹的是后自減，其意義是：將a的值賦給a后，再將a的值自動減1，于是輸出a是10。
【運(yùn)行效果】
a=10
【實(shí)例3-22】下面再看一個(gè)綜合實(shí)例。
01 public class data7
02 {
03 public static void main(String[] args)
04 {
05 int a=10; //這里的a是一個(gè)整型數(shù)據(jù)
06 System.out.println("a="+(a--)); //輸出整型變量a后自減結(jié)果
07 System.out.println("a="+(--a)); //輸出整型變量a前自減結(jié)果
08 }
09 }
【代碼說明】這個(gè)程序段首先將a的值賦值給a，然后再將a減1放到內(nèi)存中，內(nèi)存中的值為9。那么第一個(gè)打印語句的結(jié)果就是a=10。接下來，將內(nèi)存中a的值減1再賦給a，那么a的值為8。
【運(yùn)行效果】
a=10 a=8
【實(shí)例3-23】在現(xiàn)實(shí)的編程中，可能會遇到更加復(fù)雜的程序段，下面繼續(xù)看一個(gè)綜合實(shí)例。
01 public class data8
02 {
03 public static void main(String[] args)
04 {
05 int a=10; //這里的a是一個(gè)整型數(shù)據(jù)
06 System.out.println("a="+(a--)); //輸出整型變量a后自減結(jié)果
07 System.out.println("a="+(--a)); //輸出整型變量a前自減結(jié)果
08 System.out.println("a="+(a++)); //輸出整型變量a后自加結(jié)果
09 System.out.println("a="+(++a)); //輸出整型變量a前自加結(jié)果
10 }
11 }
【代碼說明】首先將a的值賦給a，然后將a自動減1放到內(nèi)存中，此時(shí)內(nèi)存中值為9，所以第一個(gè)打印語句輸出的值為10。接著，將內(nèi)存的值先減1再賦給a，a就為8。隨后，將a的值先賦給a，再將a的值加1放到內(nèi)存中，所以內(nèi)存中a為9。最后將內(nèi)存中的值加1再賦給a，a的值為10。
【運(yùn)行效果】
a=10 a=8 a=8 a=10
為了能方便地記憶自加和自減運(yùn)算符的用法，總結(jié)如下：
□ ++x：因?yàn)?+在前，所以可以記憶為先加后用。
□ x++：因?yàn)?+在后，所以可以記憶為先用后加。
□--x：因?yàn)?-在前，所以可以記憶為先減后用。
□ x--：因?yàn)?-在后，所以可以記憶為先用后減。
3.6.2 關(guān)系運(yùn)算符
關(guān)系運(yùn)算符就是指兩個(gè)操作數(shù)之間的關(guān)系，它包括了“>”、“<”等。算術(shù)運(yùn)算符的結(jié)果都是數(shù)字，而關(guān)系運(yùn)算符的結(jié)果則是布爾型數(shù)據(jù)，這一點(diǎn)一定要注意。關(guān)系運(yùn)算符的使用可參考表3-2。
表3-2 關(guān)系運(yùn)算符
注意
1）區(qū)別關(guān)系運(yùn)算符“= =”和賦值運(yùn)算符“=”，前者是比較符號左右兩邊的數(shù)據(jù)是否相等，而后者是把符號右邊的數(shù)據(jù)賦予左邊的變量。
2）“= =”、“！=”可以用于對象的比較，而對象的比較通常不是很簡單的通過對象名字比較或?qū)ο箢愋捅容^，而是有自己的equal()函數(shù)，有些情況下兩個(gè)對象是否相等的函數(shù)需要程序員自己編寫，這里讀者需要知道該知識點(diǎn)，在深入學(xué)習(xí)了面向?qū)ο蠹夹g(shù)后會有切身的理解。
在實(shí)際開發(fā)中，經(jīng)常使用關(guān)系運(yùn)算符來作為判斷的條件：如果條件是真，會如何處理；如果條件是假，又該如何處理。
【實(shí)例3-24】下面看一個(gè)簡單的例子，看看關(guān)系運(yùn)算符的輸出是什么樣子。
01 //關(guān)系運(yùn)算符的應(yīng)用
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)); //>運(yùn)算符使用
09 System.out.println("說a>=b,對嗎？"+(a>=b)); //>=運(yùn)算符使用
10 System.out.println("說a<b,對嗎？"+(a<b)); //<運(yùn)算符使用
11 System.out.println("說a<=b,對嗎？"+(a<=b)); //<=運(yùn)算符使用
12 System.out.println("說a==b,對嗎？"+(a==b)); //==運(yùn)算符使用
13 System.out.println("說a!=b,對嗎？"+(a!=b)); //!=運(yùn)算符使用
14 }
15 }
【代碼說明】第6～7行首先定義了兩個(gè)變量a和b。第8～13行通過比較兩個(gè)變量的大小，來輸出關(guān)系運(yùn)算的結(jié)果。
【運(yùn)行效果】
說a>b,對嗎？false 說a>=b,對嗎？false 說a<b,對嗎？true 說a<=b,對嗎？true 說a==b,對嗎？false 說a!=b,對嗎？true
說明
從以上的程序段可以看出，關(guān)系運(yùn)算符的結(jié)果是布爾型數(shù)據(jù)。
3.6.3 邏輯運(yùn)算符
常用的邏輯運(yùn)算符有3種：“非”、“和”、“或”。邏輯運(yùn)算符一般與關(guān)系運(yùn)算符結(jié)合起來使用，下面將詳細(xì)地介紹這3個(gè)邏輯運(yùn)算符。
1.NOT運(yùn)算符
NOT運(yùn)算符就是一個(gè)否定的意思，因?yàn)橛⑽闹小癗OT”就是“不”的意思，在Java中，NOT用符號“！”表示。
【實(shí)例3-25】下面看一個(gè)簡單的例子。
01 //非邏輯運(yùn)算符的應(yīng)用
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)); //!運(yùn)算符使用
09 }
10 }
【代碼說明】在程序中，“a>b”是假的，即“false”，但是前面有個(gè)“!”否定運(yùn)算符，將“false”變成了“true”。
【運(yùn)行效果】
說a>b,對嗎？true
2.AND運(yùn)算符
根據(jù)英文“AND”的意思，就知道此運(yùn)算符是“與”的意思。使用它必須要滿足AND前后兩個(gè)條件。AND運(yùn)算符在Java中用符號“&&”表示。
【實(shí)例3-26】下面看一個(gè)簡單的實(shí)例。
01 //與邏輯運(yùn)算符的應(yīng)用
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("認(rèn)為既a>b又a<b,對嗎？"+((a>b)&&(a<b))); //&&運(yùn)算符使用
09 }
10 }
【代碼說明】“a<b”這個(gè)關(guān)系運(yùn)算得出的結(jié)果是“true”，而“a>b”這個(gè)關(guān)系運(yùn)算得出的結(jié)果是“false”。兩者用AND這個(gè)邏輯運(yùn)算符連接后，得出的結(jié)果是“false”。
【運(yùn)行效果】
認(rèn)為既a>b又a<b,對嗎？false
為什么會這樣呢？下面是AND運(yùn)算符的原理：兩個(gè)操作數(shù)只要有一個(gè)是“false”，那么結(jié)果就是“false”，如果兩個(gè)操作數(shù)都是“true”，那么結(jié)果才是“true”。
3.OR運(yùn)算符
根據(jù)英文“OR”的意思，就知道此運(yùn)算符是“或”的意思，使用它只要滿足OR前后兩個(gè)條件中任意一個(gè)條件。OR運(yùn)算符在Java中用符號“||”表示，其原理如下：
兩個(gè)操作數(shù)只要有一個(gè)是“true”，那么結(jié)果就是“true”，否則結(jié)果就是“false”。
【實(shí)例3-27】下面看一個(gè)簡單的例子。
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("認(rèn)為既a>b又a<b,對嗎？"+((a>=b)||(a==b))); //||運(yùn)算符使用
09 System.out.println("認(rèn)為既a>b又a=c,對嗎？"+((a<b)||(a==c))); //||運(yùn)算符使用
10 }
11 }
【代碼說明】上面的程序段中，“a>=b”和“a==b”兩個(gè)操作數(shù)的結(jié)果都是“false”，所以“或”的結(jié)果就是“false”；而“a<b”的結(jié)果是“true”，“a==c”的結(jié)果是“true”，所以結(jié)果就是“true”。
【運(yùn)行效果】
認(rèn)為既a>b又a<b,對嗎？false 認(rèn)為既a>b又a=c,對嗎？true
邏輯運(yùn)算符主要用于判斷條件，例如后面要講解的判斷語句、循環(huán)語句的條件判斷等。
表3-3給出了所有邏輯運(yùn)算符。
表3-3 邏輯運(yùn)算符
說明
讀者或許發(fā)現(xiàn)“&&”與“&”，“|”與“||”的計(jì)算結(jié)果相同，但是二者之間還是有區(qū)別的，對于“&&”和“||”只要計(jì)算完左邊的值可以確定整個(gè)表達(dá)式的值，則不必再進(jìn)行計(jì)算，但是對于“&”和“|”必須把左右兩邊的結(jié)果都計(jì)算完后才可以計(jì)算結(jié)果值。
3.6.4 位運(yùn)算符
位運(yùn)算符主要針對二進(jìn)制進(jìn)行運(yùn)算，它包括了“與”、“非”、“或”、“異或”。從表面上看似乎有點(diǎn)像邏輯運(yùn)算符，但邏輯運(yùn)算符是針對兩個(gè)關(guān)系表達(dá)式來進(jìn)行邏輯運(yùn)算，而位運(yùn)算符主要針對兩個(gè)二進(jìn)制數(shù)的位進(jìn)行運(yùn)算。下面詳細(xì)介紹每個(gè)位運(yùn)算符。
1.與運(yùn)算符
與運(yùn)算符用符號“&”表示，其使用規(guī)律如下：兩個(gè)操作數(shù)中位都為1的情況下，結(jié)果才為1，否則結(jié)果為0。
【實(shí)例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與的結(jié)果是："+(a&b)); //&運(yùn)算符使用
08 }
09 }
【代碼說明】a的值是129，轉(zhuǎn)換成二進(jìn)制就是10000001，而b的值是128，轉(zhuǎn)換成二進(jìn)制就是10000000。根據(jù)與運(yùn)算符的運(yùn)算規(guī)律，只有兩個(gè)位都是1，結(jié)果才是1，可以知道上述結(jié)果就是10000000，即128。
【運(yùn)行效果】
a和b與的結(jié)果是：128
2.或運(yùn)算符
或運(yùn)算符用符號“|”表示，其運(yùn)算規(guī)律如下：兩個(gè)位只要有一個(gè)為1，那么結(jié)果就是1，否則就為0。
【實(shí)例3-29】下面看一個(gè)簡單的例子。
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或的結(jié)果是："+(a|b)); //|運(yùn)算符使用
08 }
09 }
【代碼說明】a的值是129，轉(zhuǎn)換成二進(jìn)制就是10000001，而b的值是128，轉(zhuǎn)換成二進(jìn)制就是10000000，根據(jù)或運(yùn)算符的運(yùn)算規(guī)律，兩個(gè)位中有一個(gè)是1，結(jié)果就是1，可以知道上述結(jié)果就是10000001，即129。
【運(yùn)行效果】
a和b或的結(jié)果是：129
3.非運(yùn)算符
非運(yùn)算符用符號“～”表示，其運(yùn)算規(guī)律如下：如果位為0，結(jié)果是1；如果位為1，結(jié)果是0。
【實(shí)例3-30】下面看一個(gè)簡單例子。
01 public class data15
02 {
03 public static void main(String[] args)
04 {
05 int a=2;
06 System.out.println("a非的結(jié)果是："+(～a)); //～運(yùn)算符使用
07 }
08 }
【代碼說明】a的值是2，轉(zhuǎn)換成二進(jìn)制就是0010，因?yàn)榉沁\(yùn)算就是取相反的位值，而且取反是針對二進(jìn)制的所有位而言，因?yàn)槎M(jìn)制中最高位是1表示負(fù)數(shù)，所以最終轉(zhuǎn)換為十進(jìn)制就是-3。
注意
本章中所計(jì)算的一些二進(jìn)制，計(jì)算方法都沒有那么復(fù)雜，如int類型占4字節(jié)，每個(gè)字節(jié)是8位，則對于數(shù)值2來說，標(biāo)準(zhǔn)的二進(jìn)制應(yīng)該是00000000000000000000000000000010，一共是32位。但為了簡化說法，我們并不把多余的零寫出來。上述二進(jìn)制進(jìn)行非運(yùn)算后是11111111111111111111111111111101。對于計(jì)算機(jī)基礎(chǔ)學(xué)得好的讀者，可能還會知道負(fù)數(shù)的二進(jìn)制，其實(shí)是它絕對值的二進(jìn)制取反再加1。上述非運(yùn)算后的結(jié)果是00000000000000000000000000000011這個(gè)二進(jìn)制取反加1的結(jié)果，而這個(gè)值轉(zhuǎn)換為十進(jìn)制就是3，因?yàn)樽罡呶皇?表示負(fù)數(shù)，所以結(jié)果為-3。如果讀者還不明白這些內(nèi)容，可以參考一些數(shù)據(jù)結(jié)構(gòu)和匯編語言的專業(yè)書籍。
【運(yùn)行效果】
a非的結(jié)果是：-3
4.異或運(yùn)算符
異或運(yùn)算符是用符號“^”表示的，其運(yùn)算規(guī)律是：兩個(gè)操作數(shù)的位中，相同則結(jié)果為0，不同則結(jié)果為1。
【實(shí)例3-31】下面看一個(gè)簡單的例子。
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異或的結(jié)果是："+(a^b)); //^運(yùn)算符使用
08 }
09 }
【代碼說明】a的值是15，轉(zhuǎn)換成二進(jìn)制為1111，而b的值是2，轉(zhuǎn)換成二進(jìn)制為0010，根據(jù)異或的運(yùn)算規(guī)律，可以得出其結(jié)果為1101，即13。
【運(yùn)行效果】
a與 b異或的結(jié)果是：13
3.6.5 移位運(yùn)算符
移位運(yùn)算符也是針對二進(jìn)制的“位”，它主要包括：左移運(yùn)算符（<<）、右移運(yùn)算符（>>）、無符號右移運(yùn)算符（>>>）。
1.左移運(yùn)算符
左移運(yùn)算符用“<<”表示，是將運(yùn)算符左邊的對象向左移動運(yùn)算符右邊指定的位數(shù)，并且在低位補(bǔ)0。其實(shí)，向左移n位，就相當(dāng)于乘上2的n次方。
【實(shí)例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移位的結(jié)果是："+(a<<b)); //<<運(yùn)算符使用
08 }
09 }
【代碼說明】首先從本質(zhì)上分析，2的二進(jìn)制是00000010，它向左移動2位，就變成了00001000，即8。如果從另一個(gè)角度來分析，它向左移動2位，其實(shí)就是乘上2的2次方，結(jié)果還是8。
【運(yùn)行效果】
a移位的結(jié)果是：8
2.帶符號右移運(yùn)算符
帶符號右移運(yùn)算符用符號“>>”表示，是將運(yùn)算符左邊的運(yùn)算對象向右移動運(yùn)算符右邊指定的位數(shù)。如果是正數(shù)，在高位補(bǔ)0，如果是負(fù)數(shù)，則在高位補(bǔ)1。
【實(shí)例3-33】先看下面一個(gè)簡單的例子。
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的移位結(jié)果："+(a>>b)); //>>運(yùn)算符使用
10 System.out.println("c的移位結(jié)果："+(c>>d)); //>>運(yùn)算符使用
11 }
12 }
【代碼說明】a的值是16，轉(zhuǎn)換成二進(jìn)制是00010000，讓它右移兩位就變成00000100，即4。c的值是-16，轉(zhuǎn)換成二進(jìn)制是11101111，讓它右移一位是11111011，即-4。
【運(yùn)行效果】
a的移位結(jié)果：4 c的移位結(jié)果：-4
3.無符號右移運(yùn)算符
無符號右移運(yùn)算符用符號“>>>”表示，是將運(yùn)算符左邊的對象向右移動運(yùn)算符右邊指定的位數(shù)，并且在高位補(bǔ)0。其實(shí)右移n位，就相當(dāng)于除上2的n次方。
【實(shí)例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移位的結(jié)果是："+(a>>>b)); //>>>運(yùn)算符使用
08 }
09 }
【代碼說明】從本質(zhì)上來分析，16的二進(jìn)制是00010000，它向右移動2位，就變成了00000100，即4。如果從另一個(gè)角度來分析，它向右移動2位，其實(shí)就是除以2的2次方，結(jié)果還是4。
【運(yùn)行效果】
a移位的結(jié)果是：4
現(xiàn)在再來總結(jié)一下移位運(yùn)算符的運(yùn)算規(guī)則：首先把運(yùn)算對象轉(zhuǎn)化成二進(jìn)制位，如把20轉(zhuǎn)換為二進(jìn)制則表達(dá)為00010100。
1）左移運(yùn)算規(guī)則：把數(shù)據(jù)對象的二進(jìn)制位依次左移n位，右邊空出的位置補(bǔ)0，如20<<2 ，計(jì)算結(jié)果為01010000，十進(jìn)制值為80。
2）無符號右移運(yùn)算規(guī)則：把數(shù)據(jù)對象的二進(jìn)制位依次向右移動n位左邊空出的位置補(bǔ)0，如20>>>2，計(jì)算結(jié)果為00000101，十進(jìn)制為5。
3）帶符號右移運(yùn)算規(guī)則：把數(shù)據(jù)對象的二進(jìn)制位依次右移n位，移出的數(shù)補(bǔ)到左邊。如20>>2，計(jì)算結(jié)果為00000101，十進(jìn)制為5。這里恰巧和無符號右移運(yùn)算結(jié)果相同。再舉例如15>>2，15的二進(jìn)制位表達(dá)為00001111，15>>2的計(jì)算結(jié)果為11000011，十進(jìn)制為195；而15>>>2的計(jì)算結(jié)果為00000011，十進(jìn)制為3 。顯然帶符號右移與無符號右移有明顯區(qū)別。
注意
如果讀者仔細(xì)分析可以看出左移n位運(yùn)算相當(dāng)于把十進(jìn)制數(shù)乘以2的n次方，無符號右移n位運(yùn)算相當(dāng)于把十進(jìn)制數(shù)除以2的n次方。如前面計(jì)算規(guī)則中的例子，20<<2 = 20×22 = 80，20>>>2 = 20/22= 5。
表3-4描述了移位運(yùn)算符的用法。
表3-4 移位運(yùn)算符
3.6.6 賦值運(yùn)算符
賦值就是將數(shù)值賦給變量，而賦值運(yùn)算符就充當(dāng)了這個(gè)賦值的任務(wù)，其實(shí)最簡單的賦值運(yùn)算符就是“=”。
當(dāng)然除了“=”外，還有很多其他賦值運(yùn)算符，有“+=”、“-=”、“*=”、“/=”、“%=”、“>>=”、“>>>=”、“<<=”、“&=”、“|=”、“^=”。
【實(shí)例3-35】下面給出一個(gè)簡單的例子。
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)); //+=運(yùn)算符使用
08 System.out.println("a-=b的值："+(a-=b)); //-=運(yùn)算符使用
09 System.out.println("a*=b的值："+(a*=b)); //＊=運(yùn)算符使用
10 System.out.println("a/=b的值："+(a/=b)); ///=運(yùn)算符使用
11 System.out.println("a%=b的值："+(a%=b)); //%=運(yùn)算符使用
12 System.out.println("a>>=b的值："+(a>>=b)); //>>=運(yùn)算符使用
13 System.out.println("a>>>=b的值："+(a>>>=b)); //>>>=運(yùn)算符使用
14 System.out.println("a<<=b的值："+(a<<=b)); //<<=運(yùn)算符使用
15 System.out.println("a&=b的值："+(a&=b)); //&=運(yùn)算符使用
16 System.out.println("a|=b的值："+(a|=b)); //|=運(yùn)算符使用
17 System.out.println("a^=b的值："+(a^=b)); //^=運(yùn)算符使用
18 }
19 }
【代碼說明】第7行的“a+=b”就是a=a+b。第8行的“a-=b”就是a=a-b。第17行的“a^=b”就是a=a^b。
【運(yùn)行效果】
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 三元運(yùn)算符
三元運(yùn)算符一般用得很少，因?yàn)樗诔绦蚨沃械目勺x性很差，所以不建議經(jīng)常使用三元運(yùn)算符，但 很少使用并不代表不使用，所以還是要掌握它的用法。三元運(yùn)算符的表達(dá)形式如下：
布爾表達(dá)式？值0:值1
它的運(yùn)算過程是：如果布爾表達(dá)式的結(jié)果是true，就返回值0；如果布爾表達(dá)式的結(jié)果是false，就返回值1。
【實(shí)例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("此三元運(yùn)算式結(jié)果是："+((a>b)?'A':'B')); //三元運(yùn)算符應(yīng)用
08 }
09 }
【代碼說明】因?yàn)椤癮”小于“b”，所以“a>b”這個(gè)關(guān)系運(yùn)算符的結(jié)果是“false”，既然是“false”，那么選擇值1，即這個(gè)三元運(yùn)算符的結(jié)果是“B”。
【運(yùn)行效果】
此三元運(yùn)算式結(jié)果是：B
3.6.8 逗號運(yùn)算符
在Java程序設(shè)計(jì)中，逗號運(yùn)算符一般是用來將幾個(gè)數(shù)值彼此分開，例如數(shù)組中的每個(gè)元素都是使用逗號與其他元素分開的。這個(gè)運(yùn)算符太簡單了，這里不再給出實(shí)例。
3.6.9 轉(zhuǎn)型運(yùn)算符
轉(zhuǎn)型運(yùn)算符的用處是將一種類型的對象或數(shù)據(jù)，經(jīng)過強(qiáng)制轉(zhuǎn)換而轉(zhuǎn)變?yōu)榱硪环N類型的數(shù)據(jù)。它的格式是在需要轉(zhuǎn)型的數(shù)據(jù)前加上“()”，然后在括號內(nèi)加入需要轉(zhuǎn)化的數(shù)據(jù)類型。
【實(shí)例3-37】有的數(shù)據(jù)經(jīng)過轉(zhuǎn)型運(yùn)算后，精度會丟失，而有的會更加精確，下面的例子可以說明這個(gè)問題。
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; //強(qiáng)制轉(zhuǎn)換
08 y=(double)x+(double)11; //強(qiáng)制轉(zhuǎn)換
09 System.out.println("x="+x);
10 System.out.println("y="+y);
11 }
12 }
【代碼說明】第7行中，由于在34.56前有一個(gè)int的強(qiáng)制類型轉(zhuǎn)化，所以34.56就變成了34。同樣，11.2就變成了11，所以x的結(jié)果就是45。第8行中，在x前有一個(gè)double類型的強(qiáng)制轉(zhuǎn)換，所以x的值變?yōu)?5.0，而數(shù)值11也被強(qiáng)制轉(zhuǎn)換成double類型，所以也變成11.0，所以最后y的值變?yōu)?6.0。
【運(yùn)行效果】
x=45 y=56.0
3.6.10 運(yùn)算符的優(yōu)先級別
當(dāng)多個(gè)運(yùn)算符出現(xiàn)在一個(gè)表達(dá)式中，誰先誰后呢？這就涉及運(yùn)算符的優(yōu)先級別。在一個(gè)多運(yùn)算符的表達(dá)式中，運(yùn)算符優(yōu)先級不同會導(dǎo)致最后的結(jié)果差別甚大，例如(1+3)+(3+2)*2，這個(gè)表達(dá)式如果按加號最優(yōu)先計(jì)算，答案就是18，如果按照乘號最優(yōu)先計(jì)算，答案則是14。
下面將詳細(xì)介紹在Java程序設(shè)計(jì)中，各個(gè)運(yùn)算符的優(yōu)先級別，如表3-5所示。
如表3-5 運(yùn)算符的優(yōu)先級別
3.7 常見疑難解答
3.7.1 如何將十進(jìn)制轉(zhuǎn)換成二進(jìn)制
如何將十進(jìn)制轉(zhuǎn)換成二進(jìn)制？作者有一個(gè)方法就是先熟練記憶2的n次方的結(jié)果，一般來說記到2的7次方就可以了。
下面將舉例講解這個(gè)方法：首先記住20=1、21=2、22=4、23=8、24=16、25=32、26=64、27=128。現(xiàn)在要把十進(jìn)制155轉(zhuǎn)換成二進(jìn)制，因?yàn)?55是大于128的，所以第8位上肯定是1。用155-128=27，因?yàn)?7是大于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 轉(zhuǎn)型運(yùn)算符會引起精度問題，為什么還要使用它
其實(shí)不僅基本類型數(shù)據(jù)會使用轉(zhuǎn)型運(yùn)算符，對象類型的數(shù)據(jù)也要使用轉(zhuǎn)型運(yùn)算符。在使用基本數(shù)據(jù)轉(zhuǎn)型時(shí)，一般都要從低精度往高精度轉(zhuǎn)，但是在某些特定的情況下，或者說在用戶特殊要求下，會從高精度轉(zhuǎn)向低精度。例如有的數(shù)字希望能夠去掉小數(shù)位，那么就只能從高精度往低精度轉(zhuǎn)型。
3.8 小結(jié)
本章是Java程序設(shè)計(jì)的基礎(chǔ)，程序中的數(shù)據(jù)離不開變量和常量，而程序的運(yùn)算離不開這些數(shù)據(jù)類型和運(yùn)算符。本章給出了37個(gè)小實(shí)例，主要是希望讀者能自己動手多加練習(xí)，并找到一些運(yùn)算的技巧和原理。
3.9 習(xí)題
一、填空題
1.整型主要有4種：__________、__________、__________和__________。
2.Java中的數(shù)據(jù)類型包括__________ 和__________兩種。
3.Java語句的結(jié)束符號是__________。
4.在Java程序設(shè)計(jì)中，使用關(guān)鍵字__________來聲明一個(gè)常量，常量表示在程序開始運(yùn)行到結(jié)束期間都不變的量。
二、上機(jī)實(shí)踐
1.創(chuàng)建一個(gè)實(shí)現(xiàn)輸出數(shù)值的各位值的類，即定義一個(gè)整型變量，然后通過算術(shù)運(yùn)算符輸出該變量每位的值。
【提示】關(guān)鍵代碼如下：
int num = 8461;
int gewei = num % 10;
int shiwei = num / 10 % 10;
int baiwei = num / 100 % 10;
int qianwei = num / 1000;
2.創(chuàng)建一個(gè)實(shí)現(xiàn)大小寫字母轉(zhuǎn)換的類，即定義一個(gè)字符變量，然后通過算術(shù)運(yùn)算符輸出該變量轉(zhuǎn)換后的字母。
【提示】關(guān)鍵代碼如下：
char a = 'a';
char b = (char)(a-32);
- Java多線程編程實(shí)戰(zhàn)指南：設(shè)計(jì)模式篇（第2版）
- Node.js 10實(shí)戰(zhàn)
- OpenCV for Secret Agents
- HTML5從入門到精通 （第2版）
- WordPress 4.0 Site Blueprints（Second Edition）
- 持續(xù)輕量級Java EE開發(fā)：編寫可測試的代碼
- Laravel Application Development Blueprints
- 從程序員角度學(xué)習(xí)數(shù)據(jù)庫技術(shù)（藍(lán)橋杯軟件大賽培訓(xùn)教材-Java方向）
- 軟件測試技術(shù)
- Java設(shè)計(jì)模式深入研究
- 零基礎(chǔ)學(xué)SQL（升級版）
- SQL Server on Linux
- C語言程序設(shè)計(jì)教程
- Python應(yīng)用開發(fā)技術(shù)
- MongoDB Administrator’s Guide