第02章_變量與運算符

本章專題與脈絡(luò)

1. 關(guān)鍵字（keyword）

• 定義：被Java語言賦予了特殊含義，用做專門用途的字符串（或單詞）
  • HelloWorld案例中，出現(xiàn)的關(guān)鍵字有 class、public 、 static 、 void 等，這些單詞已經(jīng)被Java定義好了。
• 特點：全部關(guān)鍵字都是小寫字母。
• 關(guān)鍵字比較多，不需要死記硬背，學到哪里記到哪里即可。
• 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

說明：

1. 關(guān)鍵字一共50個，其中const和goto是保留字(reserved word)。
2. true，false，null不在其中，它們看起來像關(guān)鍵字，其實是字面量，表示特殊的布爾值和空值。

2. 標識符( identifier)

Java中變量、方法、類等要素命名時使用的字符序列，稱為標識符。

技巧：凡是自己可以起名字的地方都叫標識符。

標識符的命名規(guī)則（必須遵守的硬性規(guī)定）：

> 由26個英文字母大小寫，0-9 ，_或 $ 組成  
> 數(shù)字不可以開頭。
> 不可以使用關(guān)鍵字和保留字，但能包含關(guān)鍵字和保留字。
> Java中嚴格區(qū)分大小寫，長度無限制。
> 標識符不能包含空格。

練習：miles、Test、a++、 --a、4#R、$4、 #44、apps、class、public、int、x、y、radius

標識符的命名規(guī)范（建議遵守的軟性要求，否則工作時容易被鄙視）:

> 包名：多單詞組成時所有字母都小寫：xxxyyyzzz。
  例如：java.lang、com.atguigu.bean
  
> 類名、接口名：多單詞組成時，所有單詞的首字母大寫：XxxYyyZzz
  例如：HelloWorld，String，System等
  
> 變量名、方法名：多單詞組成時，第一個單詞首字母小寫，第二個單詞開始每個單詞首字母大寫：xxxYyyZzz
  例如：age,name,bookName,main,binarySearch,getName
  
> 常量名：所有字母都大寫。多單詞時每個單詞用下劃線連接：XXX_YYY_ZZZ
  例如：MAX_VALUE,PI,DEFAULT_CAPACITY

注意：在起名字時，為了提高閱讀性，要盡量有意義，“見名知意”。

更多細節(jié)詳見《代碼整潔之道_關(guān)于標識符.txt》《阿里巴巴Java開發(fā)手冊-1.7.1-黃山版》

3. 變量

3.1 為什么需要變量

一花一世界，如果把一個程序看做一個世界或一個社會的話，那么變量就是程序世界的花花草草、萬事萬物。即，變量是程序中不可或缺的組成單位，最基本的存儲單元。

3.2 初識變量

• 變量的概念：

  • 內(nèi)存中的一個存儲區(qū)域，該區(qū)域的數(shù)據(jù)可以在同一類型范圍內(nèi)不斷變化

  • 變量的構(gòu)成包含三個要素：數(shù)據(jù)類型、變量名、存儲的值

  • Java中變量聲明的格式：數(shù)據(jù)類型 變量名 = 變量值

    

• 變量的作用：用于在內(nèi)存中保存數(shù)據(jù)。

• 使用變量注意：

  • Java中每個變量必須先聲明，后使用。
  • 使用變量名來訪問這塊區(qū)域的數(shù)據(jù)。
  • 變量的作用域：其定義所在的一對{ }內(nèi)。
  • 變量只有在其作用域內(nèi)才有效。出了作用域，變量不可以再被調(diào)用。
  • 同一個作用域內(nèi)，不能定義重名的變量。

3.3 Java中變量的數(shù)據(jù)類型

Java中變量的數(shù)據(jù)類型分為兩大類：

• 基本數(shù)據(jù)類型：包括 整數(shù)類型、浮點數(shù)類型、字符類型、布爾類型。

• 引用數(shù)據(jù)類型：包括數(shù)組、 類、接口、枚舉、注解、記錄。

  

3.4 變量的使用

3.4.1 步驟1：變量的聲明

格式：數(shù)據(jù)類型  變量名;

//例如：
//存儲一個整數(shù)類型的年齡
int age; 

//存儲一個小數(shù)類型的體重
double weight;

//存儲一個單字符類型的性別 
char gender;

//存儲一個布爾類型的婚姻狀態(tài)
boolean marry;

//存儲一個字符串類型的姓名
String name;

//聲明多個同類型的變量
int a,b,c; //表示a,b,c三個變量都是int類型。

注意：變量的數(shù)據(jù)類型可以是基本數(shù)據(jù)類型，也可以是引用數(shù)據(jù)類型。

3.4.2 步驟2：變量的賦值

給變量賦值，就是把“值”存到該變量代表的內(nèi)存空間中。同時，給變量賦的值類型必須與變量聲明的類型一致或兼容。

變量賦值的語法格式：

變量名 = 值;

舉例1：可以使用合適類型的常量值給已經(jīng)聲明的變量賦值

age = 18;
weight = 109;
gender = '女';

舉例2：可以使用其他變量或者表達式給變量賦值

int m = 1;
int n = m;
        
int x = 1;
int y = 2;
int z = 2 * x + y;

3：變量可以反復賦值

//先聲明，后初始化
char gender;
gender = '女';

//給變量重新賦值，修改gender變量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男

舉例4：也可以將變量的聲明和賦值一并執(zhí)行

boolean isBeauty = true;
String name = "迪麗熱巴";

內(nèi)存結(jié)構(gòu)如圖：

4. 基本數(shù)據(jù)類型介紹

4.1 整數(shù)類型：byte、short、int、long

• Java各整數(shù)類型有固定的表數(shù)范圍和字段長度，不受具體操作系統(tǒng)的影響，以保證Java程序的可移植性。

• 定義long類型的變量，賦值時需要以"l"或"L"作為后綴。

• Java程序中變量通常聲明為int型，除非不足以表示較大的數(shù)，才使用long。

• Java的整型常量默認為 int 型。

4.1.1 補充：計算機存儲單位

• **字節(jié)（Byte）：**是計算機用于計量存儲容量的基本單位，一個字節(jié)等于8 bit。

• **位（bit）：**是數(shù)據(jù)存儲的最小單位。二進制數(shù)系統(tǒng)中，每個0或1就是一個位，叫做bit（比特），其中8 bit 就稱為一個字節(jié)(Byte)。

• 轉(zhuǎn)換關(guān)系：

  • 8 bit = 1 Byte
  • 1024 Byte = 1 KB
  • 1024 KB = 1 MB
  • 1024 MB = 1 GB
  • 1024 GB = 1 TB

4.2 浮點類型：float、double

• 與整數(shù)類型類似，Java 浮點類型也有固定的表數(shù)范圍和字段長度，不受具體操作系統(tǒng)的影響。

• 浮點型常量有兩種表示形式：
  • 十進制數(shù)形式。如：5.12 512.0f .512 (必須有小數(shù)點）
  • 科學計數(shù)法形式。如：5.12e2 512E2 100E-2
• float：單精度，尾數(shù)可以精確到7位有效數(shù)字。很多情況下，精度很難滿足需求。
• double：雙精度，精度是float的兩倍。通常采用此類型。
• 定義float類型的變量，賦值時需要以"f"或"F"作為后綴。
• Java 的浮點型常量默認為double型。

4.2.1 關(guān)于浮點型精度的說明

• 并不是所有的小數(shù)都能可以精確的用二進制浮點數(shù)表示。二進制浮點數(shù)不能精確的表示0.1、0.01、0.001這樣10的負次冪。

• 浮點類型float、double的數(shù)據(jù)不適合在不容許舍入誤差的金融計算領(lǐng)域。如果需要精確數(shù)字計算或保留指定位數(shù)的精度，需要使用BigDecimal類。

• 測試用例：

//測試1：（解釋見章末企業(yè)真題：為什么0.1 + 0.2不等于0.3）
System.out.println(0.1 + 0.2);//0.30000000000000004

//測試2：
float ff1 = 123123123f;
float ff2 = ff1 + 1;
System.out.println(ff1);
System.out.println(ff2);
System.out.println(ff1 == ff2);

4.2.2 應(yīng)用舉例

案例1：定義圓周率并賦值為3.14，現(xiàn)有3個圓的半徑分別為1.2、2.5、6，求它們的面積。

/**
 * @author 尚硅谷-宋紅康
 * @create 12:36
 */
public class Exercise1 {
    public static void main(String[] args) {
        double PI = 3.14; //圓周率

        double radius1 = 1.2;
        double radius2 = 2.5;
        int radius3 = 6;

        System.out.println("第1個圓的面積：" + PI * radius1 * radius1);
        System.out.println("第2個圓的面積：" + PI * radius2 * radius2);
        System.out.println("第3個圓的面積：" + PI * radius3 * radius3);
    }
}

案例2：小明要到美國旅游，可是那里的溫度是以華氏度為單位記錄的。
它需要一個程序?qū)⑷A氏溫度（80度）轉(zhuǎn)換為攝氏度，并以華氏度和攝氏度為單位分別顯示該溫度。

℃ = (℉ - 32) / 1.8

/**
 * @author 尚硅谷-宋紅康
 * @create 12:51
 */
public class Exercise2 {
    public static void main(String[] args) {
        double hua = 80;
        double she = (hua-32)/1.8;
        System.out.println("華氏度" + hua+"℉轉(zhuǎn)為攝氏度是" +she+"℃");
    }
}

4.3 字符類型：char

• char 型數(shù)據(jù)用來表示通常意義上“字符”（占2字節(jié)）

• Java中的所有字符都使用Unicode編碼，故一個字符可以存儲一個字母，一個漢字，或其他書面語的一個字符。

• 字符型變量的三種表現(xiàn)形式：

  • **形式1：**使用單引號(’ ')括起來的單個字符。

    例如：char c1 = ‘a(chǎn)’; char c2 = ‘中’; char c3 = ‘9’;

  • **形式2：**直接使用 Unicode值來表示字符型常量：‘\uXXXX’。其中，XXXX代表一個十六進制整數(shù)。

    例如：\u0023 表示 ‘#’。

  • **形式3：**Java中還允許使用轉(zhuǎn)義字符‘\’來將其后的字符轉(zhuǎn)變?yōu)樘厥庾址统Ａ俊?/p>

    例如：char c3 = ‘\n’; // '\n’表示換行符

    轉(zhuǎn)義字符	說明	Unicode表示方式
    \n	換行符	\u000a
    \t	制表符	\u0009
    \"	雙引號	\u0022
    \'	單引號	\u0027
    \\	反斜線	\u005c
    \b	退格符	\u0008
    \r	回車符	\u000d

• char類型是可以進行運算的。因為它都對應(yīng)有Unicode碼，可以看做是一個數(shù)值。

4.4 布爾類型：boolean

• boolean 類型用來判斷邏輯條件，一般用于流程控制語句中：

  • if條件控制語句；
  • while循環(huán)控制語句；
  • for循環(huán)控制語句；
  • do-while循環(huán)控制語句；

• boolean類型數(shù)據(jù)只有兩個值：true、false，無其它。

  • 不可以使用0或非 0 的整數(shù)替代false和true，這點和C語言不同。
  • 拓展：Java虛擬機中沒有任何供boolean值專用的字節(jié)碼指令，Java語言表達所操作的boolean值，在編譯之后都使用java虛擬機中的int數(shù)據(jù)類型來代替：true用1表示，false用0表示。——《java虛擬機規(guī)范 8版》

• 舉例：

boolean isFlag = true;

if(isFlag){
    //true分支
}else{  
    //false分支
}

經(jīng)驗之談：

Less is More！建議不要這樣寫：if ( isFlag = = true )，只有新手才如此。關(guān)鍵也很容易寫錯成if(isFlag = true)，這樣就變成賦值isFlag為true而不是判斷！老鳥的寫法是if (isFlag)或者if ( !isFlag)。

5. 基本數(shù)據(jù)類型變量間運算規(guī)則

在Java程序中，不同的基本數(shù)據(jù)類型（只有7種，不包含boolean類型）變量的值經(jīng)常需要進行相互轉(zhuǎn)換。

轉(zhuǎn)換的方式有兩種：自動類型提升和強制類型轉(zhuǎn)換。

5.1 自動類型提升

規(guī)則：將取值范圍小（或容量?。┑念愋妥詣犹嵘秊槿≈捣秶螅ɑ蛉萘看螅┑念愋?。

基本數(shù)據(jù)類型的轉(zhuǎn)換規(guī)則如圖所示：

（1）當把存儲范圍小的值（常量值、變量的值、表達式計算的結(jié)果值）賦值給了存儲范圍大的變量時

int i = 'A';//char自動升級為int，其實就是把字符的編碼值賦值給i變量了
double d = 10;//int自動升級為double
long num = 1234567; //右邊的整數(shù)常量值如果在int范圍呢，編譯和運行都可以通過，這里涉及到數(shù)據(jù)類型轉(zhuǎn)換

//byte bigB = 130;//錯誤，右邊的整數(shù)常量值超過byte范圍
long bigNum = 12345678912L;//右邊的整數(shù)常量值如果超過int范圍，必須加L，顯式表示long類型。否則編譯不通過

（2）當存儲范圍小的數(shù)據(jù)類型與存儲范圍大的數(shù)據(jù)類型變量一起混合運算時，會按照其中最大的類型運算。

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合運算，升級為double

（3）當byte,short,char數(shù)據(jù)類型的變量進行算術(shù)運算時，按照int類型處理。

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//編譯報錯，b1 + b2自動升級為int

char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int類型來接收
System.out.println(c1 + c2);//113 

練習：

設(shè) x 為float型變量，y為double型變量，a為int型變量，b為long型變量，c為char型變量，則表達式
x + y * a / x + b / y + c的值類型為：

A. int   B. long  C. double  D. char

5.2 強制類型轉(zhuǎn)換

將3.14 賦值到int 類型變量會發(fā)生什么？產(chǎn)生編譯失敗，肯定無法賦值。

int i = 3.14; // 編譯報錯

想要賦值成功，只有通過強制類型轉(zhuǎn)換，將double 類型強制轉(zhuǎn)換成int 類型才能賦值。

規(guī)則：將取值范圍大（或容量大）的類型強制轉(zhuǎn)換成取值范圍小（或容量?。┑念愋?。

自動類型提升是Java自動執(zhí)行的，而強制類型轉(zhuǎn)換是自動類型提升的逆運算，需要我們自己手動執(zhí)行。

轉(zhuǎn)換格式：

數(shù)據(jù)類型1 變量名 = (數(shù)據(jù)類型1)被強轉(zhuǎn)數(shù)據(jù)值;  //()中的數(shù)據(jù)類型必須<=變量值的數(shù)據(jù)類型

（1）當把存儲范圍大的值（常量值、變量的值、表達式計算的結(jié)果值）強制轉(zhuǎn)換為存儲范圍小的變量時，可能會損失精度或溢出。

int i = (int)3.14;//損失精度

double d = 1.2;
int num = (int)d;//損失精度

int i = 200;
byte b = (byte)i;//溢出

（2）當某個值想要提升數(shù)據(jù)類型時，也可以使用強制類型轉(zhuǎn)換。這種情況的強制類型轉(zhuǎn)換是沒有風險的，通常省略。

int i = 1;
int j = 2;
double bigger = (double)(i/j);

（3）聲明long類型變量時，可以出現(xiàn)省略后綴的情況。float則不同。

long l1 = 123L;
long l2 = 123;//如何理解呢？ 此時可以看做是int類型的123自動類型提升為long類型

//long l3 = 123123123123; //報錯，因為123123123123超出了int的范圍。
long l4 = 123123123123L;


//float f1 = 12.3; //報錯，因為12.3看做是double，不能自動轉(zhuǎn)換為float類型
float f2 = 12.3F;
float f3 = (float)12.3;

練習：判斷是否能通過編譯

1）short  s = 5;
   s = s-2;                     //判斷：no
2） byte b = 3;
    b = b + 4;                  //判斷：no
    b = (byte)(b+4);            //判斷：yes
3）char c = ‘a(chǎn)’;
   int  i = 5;
   float d = .314F;
   double result = c+i+d;       //判斷：yes
4） byte b = 5;
    short s = 3;
    short t = s + b;            //判斷：no

問答：為什么標識符的聲明規(guī)則里要求不能數(shù)字開頭？

//如果允許數(shù)字開頭，則如下的聲明編譯就可以通過：
int 123L = 12;
//進而，如下的聲明中l(wèi)的值到底是123？還是變量123L對應(yīng)的取值12呢？ 出現(xiàn)歧義了。
long l = 123L;

5.3 基本數(shù)據(jù)類型與String的運算

5.3.1 字符串類型：String

• String不是基本數(shù)據(jù)類型，屬于引用數(shù)據(jù)類型
• 使用一對""來表示一個字符串，內(nèi)部可以包含0個、1個或多個字符。
• 聲明方式與基本數(shù)據(jù)類型類似。例如：String str = “尚硅谷”;

5.3.2 運算規(guī)則

1、任意八種基本數(shù)據(jù)類型的數(shù)據(jù)與String類型只能進行連接“+”運算，且結(jié)果一定也是String類型

System.out.println("" + 1 + 2);//12

int num = 10;
boolean b1 = true;
String s1 = "abc";

String s2 = s1 + num + b1;
System.out.println(s2);//abc10true

//String s3 = num + b1 + s1;//編譯不通過，因為int類型不能與boolean運算
String s4 = num + (b1 + s1);//編譯通過

2、String類型不能通過強制類型()轉(zhuǎn)換，轉(zhuǎn)為其他的類型

String str = "123";
int num = (int)str;//錯誤的

int num = Integer.parseInt(str);//正確的，后面才能講到，借助包裝類的方法才能轉(zhuǎn)

5.3.3 案例與練習

案例：公安局身份登記

要求填寫自己的姓名、年齡、性別、體重、婚姻狀況（已婚用true表示，單身用false表示）、聯(lián)系方式等等。

/**
 * @author 尚硅谷-宋紅康
 * @create 12:34
 */
public class Info {
    public static void main(String[] args) {
        String name = "康師傅";
        int age = 37;
        char gender = '男';
        double weight = 145.6;
        boolean isMarried = true;
        String phoneNumber = "13112341234";

        System.out.println("姓名：" + name);
        System.out.println("年齡：" + age);
        System.out.println("性別：" + gender);
        System.out.println("體重：" + weight);
        System.out.println("婚否：" + isMarried);
        System.out.println("電話：" + phoneNumber);
		//或者
        System.out.println("name = " + name + ",age = " + age + "，gender = " + 
                           gender + ",weight = " + weight + ",isMarried = " + isMarried +
                           ",phoneNumber = " + phoneNumber);
    }
}

練習：

練習1：

String str1 = 4;                       //判斷對錯：
String str2 = 3.5f + "";               //判斷str2對錯：
System.out.println(str2);              //輸出：
System.out .println(3+4+"Hello!");     //輸出：
System.out.println("Hello!"+3+4);      //輸出：
System.out.println('a'+1+"Hello!");    //輸出：
System.out.println("Hello"+'a'+1);     //輸出：

練習2：

System.out.println("*    *");				//輸出：
System.out.println("*\t*");					//輸出：
System.out.println("*" + "\t" + "*");		//輸出：
System.out.println('*' + "\t" + "*");		//輸出：
System.out.println('*' + '\t' + "*");		//輸出：
System.out.println('*' + "\t" + '*');		//輸出：
System.out.println("*" + '\t' + '*');		//輸出：
System.out.println('*' + '\t' + '*');		//輸出：

6. 計算機底層如何存儲數(shù)據(jù)

計算機世界中只有二進制，所以計算機中存儲和運算的所有數(shù)據(jù)都要轉(zhuǎn)為二進制。包括數(shù)字、字符、圖片、聲音、視頻等。

世界上有10種人 ，認識和不認識二進制的。

6.1 進制的分類

• 十進制（decimal）

  • 數(shù)字組成：0-9
  • 進位規(guī)則：滿十進一

• 二進制（binary）

  • 數(shù)字組成：0-1
  • 進位規(guī)則：滿二進一，以0b或0B開頭

• 八進制（octal）：很少使用

  • 數(shù)字組成：0-7
  • 進位規(guī)則：滿八進一，以數(shù)字0開頭表示

• 十六進制

  • 數(shù)字組成：0-9，a-f
  • 進位規(guī)則：滿十六進一，以0x或0X開頭表示。此處的 a-f 不區(qū)分大小寫

代碼演示：

class BinaryTest {
	public static void main(String[] args) {
		
		int num1 = 123;		//十進制
		int num2 = 0b101;	//二進制
		int num3 = 0127;	//八進制
		int num4 = 0x12aF;	//十六進制

		System.out.println(num1);
		System.out.println(num2);
		System.out.println(num3);
		System.out.println(num4);

	}
}

6.2 進制的換算舉例

6.3 二進制的由來

二進制，是計算技術(shù)中廣泛采用的一種數(shù)制，由德國數(shù)理哲學大師萊布尼茨于1679年發(fā)明。

二進制數(shù)據(jù)是用0和1兩個數(shù)碼來表示的數(shù)。它的基數(shù)為2，進位規(guī)則是“逢二進一”。

二進制廣泛應(yīng)用于我們生活的方方面面。比如，廣泛使用的摩爾斯電碼（Morse Code），它由兩種基本信號組成：短促的點信號“·”，讀“滴”；保持一定時間的長信號“—”，讀“嗒”。然后，組成了26個字母，從而拼寫出相應(yīng)的單詞。

記憶技巧：

我們偶爾會看到的：SOS，即為：

6.4 二進制轉(zhuǎn)十進制

二進制如何表示整數(shù)？

• 計算機數(shù)據(jù)的存儲使用二進制補碼形式存儲，并且最高位是符號位。

  • 正數(shù)：最高位是0
  • 負數(shù)：最高位是1

• 規(guī) 定

  • 正數(shù)的補碼與反碼、原碼一樣，稱為三碼合一
  • 負數(shù)的補碼與反碼、原碼不一樣：
    • 負數(shù)的原碼：把十進制轉(zhuǎn)為二進制，然后最高位設(shè)置為1
    • 負數(shù)的反碼：在原碼的基礎(chǔ)上，最高位不變，其余位取反（0變1,1變0）
    • 負數(shù)的補碼：反碼+1

二進制轉(zhuǎn)十進制：權(quán)相加法

針對于byte數(shù)據(jù)舉例來說：

• 例如：byte類型（1個字節(jié)，8位）

  25 ==> 原碼 0001 1001 ==> 反碼 0001 1001 -->補碼 0001 1001

  -25 ==>原碼 1001 1001 ==> 反碼1110 0110 ==>補碼 1110 0111

整數(shù)：
正數(shù)：25   00000000 00000000 000000000 00011001（原碼）
正數(shù)：25   00000000 00000000 000000000 00011001（反碼）
正數(shù)：25   00000000 00000000 000000000 00011001（補碼）

負數(shù)：-25  10000000 00000000 000000000 00011001（原碼）
負數(shù)：-25  11111111 11111111 111111111 11100110（反碼）
負數(shù)：-25  11111111 11111111 111111111 11100111（補碼）

一個字節(jié)可以存儲的整數(shù)范圍是多少？

//1個字節(jié)：8位

0000 0001  ~  0111 111 ==> 1~127

1000 0001 ~ 1111 1111 ==> -127 ~ -1

0000 0000 ==>0

1000 0000 ==> -128（特殊規(guī)定）=-127-1

6.5 十進制轉(zhuǎn)二進制

十進制轉(zhuǎn)二進制：除2取余的逆

6.6 二進制與八進制、十六進制間的轉(zhuǎn)換

二進制轉(zhuǎn)八進制

二進制轉(zhuǎn)十六進制

八進制、十六進制轉(zhuǎn)二進制

6.7 各進制間的轉(zhuǎn)換

練習：

1.將以下十進制數(shù)轉(zhuǎn)換為十六進制和二進制
123  256  87  62


2.將以下十六進制數(shù)轉(zhuǎn)換為十進制和二進制
0x123   0x25F  0x38  0x62

7. 運算符（Operator）（掌握）

運算符是一種特殊的符號，用以表示數(shù)據(jù)的運算、賦值和比較等。

運算符的分類：

• 按照功能分為：算術(shù)運算符、賦值運算符、比較(或關(guān)系)運算符、邏輯運算符、位運算符、條件運算符、Lambda運算符

• 按照操作數(shù)個數(shù)分為：一元運算符（單目運算符）、二元運算符（雙目運算符）、三元運算符 （三目運算符）

7.1 算術(shù)運算符

7.1.1 基本語法

舉例1：加減乘除模

public class ArithmeticTest1 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		
		System.out.println(a + b);// 7
		System.out.println(a - b);// -1
		System.out.println(a * b);// 12
		System.out.println(a / b);// 計算機結(jié)果是0，為什么不是0.75呢？
		System.out.println(a % b);// 3
        
        //結(jié)果與被模數(shù)符號相同
        System.out.println(5%2);//1
		System.out.println(5%-2);//1
		System.out.println(-5%2);//-1
		System.out.println(-5%-2);//-1		
		//商*除數(shù) + 余數(shù) = 被除數(shù)
		//5%-2  ==>商是-2，余數(shù)時1    (-2)*(-2)+1 = 5
		//-5%2  ==>商是-2，余數(shù)是-1   (-2)*2+(-1) = -4-1=-5
	}
}

舉例2：“+”號的兩種用法

• 第一種：對于+兩邊都是數(shù)值的話，+就是加法的意思
• 第二種：對于+兩邊至少有一邊是字符串的話，+就是拼接的意思

public class ArithmeticTest2 {
	public static void main(String[] args) {
		// 字符串類型的變量基本使用
		// 數(shù)據(jù)類型 變量名稱 = 數(shù)據(jù)值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 520); // Java520
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 5 + 20); // Java520
	}
}

舉例3：自加自減運算

理解：++ 運算，表示自增1。同理，-- 運算，表示自減1，用法與++ 一致。

1、單獨使用

• 變量在單獨運算的時候，變量前++和變量后++，是沒有區(qū)別的。
• 變量前++ ：例如 ++a 。
• 變量后++ ：例如 a++ 。

public class ArithmeticTest3 {
	public static void main(String[] args) {
		// 定義一個int類型的變量a
		int a = 3;
		//++a;
		a++;
        // 無論是變量前++還是變量后++，結(jié)果都是4
		System.out.println(a);
	}
}

2、復合使用

• 和其他變量放在一起使用或者和輸出語句放在一起使用，前++和后++就產(chǎn)生了不同。

• 變量前++ ：變量先自增1，然后再運算。
• 變量后++ ：變量先運算，然后再自增1。

public class ArithmeticTest4 {
	public static void main(String[] args) {
		// 其他變量放在一起使用
		int x = 3;
		//int y = ++x; // y的值是4，x的值是4，
		int y = x++; // y的值是3，x的值是4
		
		System.out.println(x);
		System.out.println(y);
		System.out.println("==========");
        
		// 和輸出語句一起
		int z = 5;
		//System.out.println(++z);// 輸出結(jié)果是6，z的值也是6
		System.out.println(z++);// 輸出結(jié)果是5，z的值是6
		System.out.println(z);
        
	} 
}

7.1.2 案例與練習

案例1：

隨意給出一個整數(shù)，打印顯示它的個位數(shù)，十位數(shù)，百位數(shù)的值。
格式如下：
數(shù)字xxx的情況如下：
個位數(shù)：
十位數(shù)：
百位數(shù)：

例如：
數(shù)字153的情況如下：
個位數(shù)：3
十位數(shù)：5
百位數(shù)：1

class ArithmeticExer1 {
	public static void main(String[] args) {
		
		int num = 187;
		
		int bai = num / 100;
		int shi = num % 100 / 10;//int shi = num / 10 % 10;
		int ge = num % 10;
		
		System.out.println("百位為：" + bai);
		System.out.println("十位為：" + shi);
		System.out.println("個位為：" + ge);

	}
}

拓展：獲取一個四位數(shù)的個位，十位，百位，千位

public class ArithmeticExer01 {
    public static void main (String [] args) {
        //1.定義一個變量，賦值為一個四位數(shù)整數(shù)，例如1234
        int num = 1234;

        //2.通過運算操作求出個位，十位，百位，千位
        int ge = num % 10;
        int shi = num /10 % 10;
        int bai = num /100 % 10;
        int qian = num / 1000 % 10;

        System.out.println("個位上的數(shù)字是：" + ge);
        System.out.println("十位上的數(shù)字是：" + shi);
        System.out.println("百位上的數(shù)字是：" + bai);
        System.out.println("千位上的數(shù)字是：" + qian);
    }
}

**案例2：**為抵抗洪水，戰(zhàn)士連續(xù)作戰(zhàn)89小時，編程計算共多少天零多少小時？

public class ArithmeticExer2 {
    public static void main(String[] args){
        int hours = 89;
        int day = hours / 24;
        int hour = hours % 24;
        System.out.println("為抵抗洪水，戰(zhàn)士連續(xù)作戰(zhàn)89小時：");
        System.out.println(hours + "是" + day + "天" + hour +"小時");
    }
}

練習1：算術(shù)運算符：自加、自減

public class ArithmeticExer3{
    public static void main(String[] args){
        int i1 = 10;
        int i2 = 20;
        int i = i1++;
        System.out.print("i="+i); //
        System.out.println("i1="+i1);//
        i = ++i1;
        System.out.print("i="+i);//
        System.out.println("i1="+i1);//
        i = i2--;
        System.out.print("i="+i);//
        System.out.println("i2="+i2);//
        i = --i2;
        System.out.print("i="+i);//
        System.out.println("i2="+i2);//
    }
}

練習2：

System.out.println("5+5=" + 5 + 5); //打印結(jié)果是？ 5+5=55 ?

練習3：

byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);//-128

練習4：

int i = 1;
int j = i++ + ++i * i++;
System.out.println("j = " + j);

練習5：（企業(yè)真題）寫出下列程序的輸出結(jié)果

int i = 2;
int j = i++;
System.out.println(j);

int m = 2;
m = m++; //(1)先取b的值“2”放操作數(shù)棧 (2)m再自增,m=3 (3)再把操作數(shù)棧中的"2"賦值給m,m=2
System.out.println(m);

7.2 賦值運算符

7.2.1 基本語法

• 符號：=

  • 當“=”兩側(cè)數(shù)據(jù)類型不一致時，可以使用自動類型轉(zhuǎn)換或使用強制類型轉(zhuǎn)換原則進行處理。
  • 支持連續(xù)賦值。

• 擴展賦值運算符： +=、 -=、*=、 /=、%=

  賦值運算符	符號解釋
  +=	將符號左邊的值和右邊的值進行相加操作，最后將結(jié)果賦值給左邊的變量
  -=	將符號左邊的值和右邊的值進行相減操作，最后將結(jié)果賦值給左邊的變量
  *=	將符號左邊的值和右邊的值進行相乘操作，最后將結(jié)果賦值給左邊的變量
  /=	將符號左邊的值和右邊的值進行相除操作，最后將結(jié)果賦值給左邊的變量
  %=	將符號左邊的值和右邊的值進行取余操作，最后將結(jié)果賦值給左邊的變量

public class SetValueTest1 {
	public static void main(String[] args) {
		int i1 = 10;
		long l1 = i1; //自動類型轉(zhuǎn)換

		byte bb1 = (byte)i1; //強制類型轉(zhuǎn)換

		int i2 = i1;

		//連續(xù)賦值的測試
		//以前的寫法
		int a1 = 10;
		int b1 = 10;
		
		//連續(xù)賦值的寫法
		int a2,b2;
		a2 = b2 = 10;
		
		int a3 = 10,b3 = 20;

		//舉例說明+=  -=  *=  /=   %=  
		int m1 = 10;
		m1 += 5; //類似于 m1 = m1 + 5的操作，但不等同于。
		System.out.println(m1);//15
		
		//練習1：開發(fā)中，如何實現(xiàn)一個變量+2的操作呢？
		// += 的操作不會改變變量本身的數(shù)據(jù)類型。其他拓展的運算符也如此。
		//寫法1：推薦
		short s1 = 10;
		s1 += 2; //編譯通過，因為在得到int類型的結(jié)果后，JVM自動完成一步強制類型轉(zhuǎn)換，將int類型強轉(zhuǎn)成short
		System.out.println(s1);//12
		//寫法2：
		short s2 = 10;
		//s2 = s2 + 2;//編譯報錯，因為將int類型的結(jié)果賦值給short類型的變量s時，可能損失精度
		s2 = (short)(s2 + 2);
		System.out.println(s2);


		//練習2：開發(fā)中，如何實現(xiàn)一個變量+1的操作呢？
		//寫法1：推薦
		int num1 = 10;
		num1++;
		System.out.println(num1);

		//寫法2：
		int num2 = 10;
		num2 += 1;
		System.out.println(num2);

		//寫法3：
		int num3 = 10;
		num3 = num3 + 1;
		System.out.println(num3);

	}
}

7.2.2 練習

練習1：

short s = 3; 
s = s+2;  //① 編譯報錯
s += 2;   //② 正常執(zhí)行

//①和②有什么區(qū)別？ 

練習2：

int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1

練習3：

int m = 2;
int n = 3;
n *= m++; 	//n = n * m++;
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6

練習4：

int n = 10;
n += (n++) + (++n);  //n = n + (n++) + (++n)
System.out.println(n);//32

練習5：你有幾種辦法實現(xiàn)變量值減1？變量值減2呢？

/**
 * @author 尚硅谷-宋紅康
 * @create 16:55
 */
public class MinusTest {
    public static void main(String[] args) {
        //練習①：變量值減1
        short s = 10;
        //方式1：
        //s = (short)(s - 1);
        //方式2：推薦
        s--; //或者 --s
        //方式3：
        s -= 1;

        //練習②：變量值減2
        short s1 = 10;
        //方式1：
        //s1 = (short)(s1 - 2);
        //方式2：推薦
        s1 -= 2;
    }
}

7.3 比較(關(guān)系)運算符

• 比較運算符的結(jié)果都是boolean型，也就是要么是true，要么是false。

• > < >= <= ：只適用于基本數(shù)據(jù)類型（除boolean類型之外）

  == != ：適用于基本數(shù)據(jù)類型和引用數(shù)據(jù)類型

• 比較運算符“==”不能誤寫成“=”

舉例：

class CompareTest {
	public static void main(String[] args) {
		int i1 = 10;
		int i2 = 20;
		
		System.out.println(i1 == i2);//false
		System.out.println(i1 != i2);//true
		System.out.println(i1 >= i2);//false


		int m = 10;
		int n = 20;
		System.out.println(m == n);//false
		System.out.println(m = n);//20

		boolean b1 = false;
		boolean b2 = true;
		System.out.println(b1 == b2);//false
		System.out.println(b1 = b2);//true
	}
}

思考：

boolean b1 = false;
//區(qū)分好==和=的區(qū)別。
if(b1 == true)  //if(b1 = true)
	System.out.println("結(jié)果為真");
else
	System.out.println("結(jié)果為假");

7.4 邏輯運算符

7.4.1 基本語法

• 邏輯運算符，操作的都是boolean類型的變量或常量，而且運算得結(jié)果也是boolean類型的值。

• 運算符說明：

  • & 和 &&：表示"且"關(guān)系，當符號左右兩邊布爾值都是true時，結(jié)果才能為true。否則，為false。
  • | 和 || ：表示"或"關(guān)系，當符號兩邊布爾值有一邊為true時，結(jié)果為true。當兩邊都為false時，結(jié)果為false
  • ! ：表示"非"關(guān)系，當變量布爾值為true時，結(jié)果為false。當變量布爾值為false時，結(jié)果為true。
  • ^ ：當符號左右兩邊布爾值不同時，結(jié)果為true。當兩邊布爾值相同時，結(jié)果為false。
    • 理解：異或，追求的是“異”！

• 邏輯運算符用于連接布爾型表達式，在Java中不可以寫成 3 < x < 6，應(yīng)該寫成x > 3 & x < 6 。

• 區(qū)分“&”和“&&”：

  • 相同點：如果符號左邊是true，則二者都執(zhí)行符號右邊的操作

  • 不同點：& ： 如果符號左邊是false,則繼續(xù)執(zhí)行符號右邊的操作

  ? && ：如果符號左邊是false,則不再繼續(xù)執(zhí)行符號右邊的操作

  • 建議：開發(fā)中，推薦使用 &&

• 區(qū)分“|”和“||”：

  • 相同點：如果符號左邊是false，則二者都執(zhí)行符號右邊的操作

  • 不同點：| ： 如果符號左邊是true，則繼續(xù)執(zhí)行符號右邊的操作

    ? || ：如果符號左邊是true，則不再繼續(xù)執(zhí)行符號右邊的操作

  • 建議：開發(fā)中，推薦使用 ||

代碼舉例：

public class LoginTest {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		int c = 5;

		// & 與，且；有false則false
		System.out.println((a > b) & (a > c)); 
		System.out.println((a > b) & (a < c)); 
		System.out.println((a < b) & (a > c)); 
		System.out.println((a < b) & (a < c)); 
		System.out.println("===============");
		// | 或；有true則true
		System.out.println((a > b) | (a > c)); 
		System.out.println((a > b) | (a < c)); 
		System.out.println((a < b) | (a > c));
		System.out.println((a < b) | (a < c));
		System.out.println("===============");
		// ^ 異或；相同為false，不同為true
		System.out.println((a > b) ^ (a > c));
		System.out.println((a > b) ^ (a < c)); 
		System.out.println((a < b) ^ (a > c)); 
		System.out.println((a < b) ^ (a < c)); 
		System.out.println("===============");
		// ! 非；非false則true，非true則false
		System.out.println(!false);
		System.out.println(!true);
        
        //&和&&的區(qū)別
        System.out.println((a > b) & (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) && (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) && (a++ > c)); 
        System.out.println("a = " + a);
        
        //|和||的區(qū)別
        System.out.println((a > b) | (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) || (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) || (a++ > c)); 
        System.out.println("a = " + a);
	}
}

7.4.2 案例與練習

案例：

1. 定義類 CompareLogicExer
2. 定義 main方法
3. 定義一個int類型變量a,變量b,都賦值為20
4. 定義boolean類型變量bo1 , 判斷++a 是否被3整除,并且a++ 是否被7整除,將結(jié)果賦值給bo1
5. 輸出a的值,bo1的值
6. 定義boolean類型變量bo2 , 判斷b++ 是否被3整除,并且++b 是否被7整除,將結(jié)果賦值給bo2
7. 輸出b的值,bo2的值

public class CompareLogicExer {
    public static void main(String[] args){
        int a = 20;
        int b = 20;
        boolean bo1 = ((++a % 3) == 0) && ((a++ % 7) == 0);
        System.out.println("bo1的值：" + bo1);
        System.out.println("a的值：" + a);
        System.out.println("----------------------------");
        
        boolean bo2 = ((b++ % 3) == 0) && ((++b % 7) == 0); 
        System.out.println("bo2的值：" + bo2);
        System.out.println("b的值：" + b);
    }
}

**練習1：**區(qū)分 & 和 &&

int x = 1;
int y = 1;

if(x++ == 2 & ++y == 2){
	x = 7;
}
System.out.println("x=" + x + ",y=" + y);

int x = 1,y = 1;

if(x++ == 2 && ++y == 2){
	x =7;
}
System.out.println("x="+x+",y="+y);

**練習2：**區(qū)分 | 和 ||

int x = 1,y = 1;

if(x++==1 | ++y==1){
	x =7;
}
System.out.println("x="+x+",y="+y);

int x = 1,y = 1;

if(x++==1 || ++y==1){
	x =7;
}
System.out.println("x="+x+",y="+y);

**練習3：**程序輸出

class  Test  {
	public static void main (String []  args)  {
		boolean x = true;
        boolean y = false;
        short z = 42;
        
        if ((z++ == 42) && (y = true)) {
            z++;
        }
        if ((x = false) || (++z == 45)) {
            z++;
        }

        System.out.println("z=" + z);
	}
}

//結(jié)果為：
//z= 46

7.5 位運算符（難點、非重點）

7.5.1 基本語法

• 位運算符的運算過程都是基于二進制的補碼運算

（1）左移：<<

運算規(guī)則：在一定范圍內(nèi)，數(shù)據(jù)每向左移動一位，相當于原數(shù)據(jù)*2。（正數(shù)、負數(shù)都適用）

【注意】當左移的位數(shù)n超過該數(shù)據(jù)類型的總位數(shù)時，相當于左移（n-總位數(shù)）位

3<<4  類似于  3*2的4次冪 => 3*16 => 48

-3<<4  類似于  -3*2的4次冪 => -3*16 => -48

（2）右移：>>

運算規(guī)則：在一定范圍內(nèi)，數(shù)據(jù)每向右移動一位，相當于原數(shù)據(jù)/2。（正數(shù)、負數(shù)都適用）

【注意】如果不能整除，向下取整。

69>>4  類似于  69/2的4次 = 69/16 =4

-69>>4  類似于  -69/2的4次 = -69/16 = -5

（3）無符號右移：>>>

運算規(guī)則：往右移動后，左邊空出來的位直接補0。（正數(shù)、負數(shù)都適用）

69>>>4  類似于  69/2的4次 = 69/16 =4

-69>>>4   結(jié)果：268435451

（4）按位與：&

運算規(guī)則：對應(yīng)位都是1才為1，否則為0。

• 1 & 1 結(jié)果為1

• 1 & 0 結(jié)果為0

• 0 & 1 結(jié)果為0

• 0 & 0 結(jié)果為0

9 & 7 = 1

-9 & 7 = 7

（5）按位或：|

運算規(guī)則：對應(yīng)位只要有1即為1，否則為0。

• 1 | 1 結(jié)果為1

• 1 | 0 結(jié)果為1

• 0 | 1 結(jié)果為1

• 0 & 0 結(jié)果為0

9 | 7  //結(jié)果： 15

-9 | 7 //結(jié)果： -9

（6）按位異或：^

運算規(guī)則：對應(yīng)位一個為1一個為0，才為1，否則為0。

• 1 ^ 1 結(jié)果為0

• 1 ^ 0 結(jié)果為1

• 0 ^ 1 結(jié)果為1

• 0 ^ 0 結(jié)果為0

9 ^ 7  //結(jié)果為14

-9 ^ 7 //結(jié)果為-16

（7）按位取反：~

運算規(guī)則：對應(yīng)位為1，則結(jié)果為0；對應(yīng)位為0，則結(jié)果為1。

• ~0就是1

• ~1就是0

~9  //結(jié)果：-10

~-9  //結(jié)果：8

7.5.2 舉例

舉例1：

舉例2：體會 m = k ^ n = (m ^ n) ^ n

7.5.3 案例

**案例1：**高效的方式計算2 * 8的值（經(jīng)典面試題）

答案：2 << 3 、  8  << 1

**案例2：**如何交換兩個int型變量的值？String呢？

public class BitExer {
    public static void main(String[] args) {
        int m = 10;
		int n = 5;

		System.out.println("m = " + m + ", n = " + n);

		//（推薦）實現(xiàn)方式1：優(yōu)點：容易理解，適用于不同數(shù)據(jù)類型    缺點：需要額外定義變量
		//int temp = m;
		//m = n;
		//n = temp;

		//實現(xiàn)方式2：優(yōu)點：沒有額外定義變量    缺點：可能超出int的范圍；只能適用于數(shù)值類型
		//m = m + n; //15 = 10 + 5
		//n = m - n;//10 = 15 - 5
		//m = m - n;//5 = 15 - 10
	
		//實現(xiàn)方式3：優(yōu)點：沒有額外定義變量    缺點：不易理解；只能適用于數(shù)值類型
		m = m ^ n; 
		n = m ^ n; //(m ^ n) ^ n
		m = m ^ n;

		System.out.println("m = " + m + ", n = " + n);
    }
}

7.6 條件運算符

7.6.1 基本語法

• 條件運算符格式：

(條件表達式)? 表達式1:表達式2

• 說明：條件表達式是boolean類型的結(jié)果，根據(jù)boolean的值選擇表達式1或表達式2

  

• 如果運算后的結(jié)果賦給新的變量，要求表達式1和表達式2為同種或兼容的類型

public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    
    boolean marry = false;
	System.out.println(marry ? "已婚" : "未婚"  );
    
    double d1 = (m1 > m2)? 1 : 2.0;
	System.out.println(d1);
    
    int num = 12;
    System.out.println(num > 0? true : "num非正數(shù)");
}

7.6.2 案例

**案例1：**獲取兩個數(shù)中的較大值

/**
 * @author 尚硅谷-宋紅康
 * @create 12:40
 */
public class ConditionExer1 {
    public static void main(String[] args) {
        //獲取兩個數(shù)的較大值
        int m1 = 10;
        int m2 = 20;

        int max1 = (m1 > m2)? m1 : m2;
        System.out.println("m1和m2中的較大值為" + max1);
    }
}

**案例2：**獲取三個數(shù)中的最大值

public class ConditionExer2 {
    public static void main(String[] args) {
        int n1 = 23;
        int n2 = 13;
        int n3 = 33;
        //寫法1：
        int tempMax = (n1 > n2)? n1:n2;
        int finalMax = (tempMax > n3)? tempMax : n3;
        System.out.println("三個數(shù)中最大值為：" + finalMax);

        //寫法2：不推薦，可讀性差
        int finalMax1 = (((n1 > n2)? n1:n2) > n3)? ((n1 > n2)? n1:n2) : n3;
        System.out.println("三個數(shù)中最大值為：" + finalMax1);
    }
}

**案例3：**今天是周2，10天以后是周幾？

要求：控制臺輸出"今天是周2，10天以后是周x"。

public class ConditionExer3 {

    public static void main(String[] args) {
        int week = 2;
        week += 10;
        week %= 7;
        System.out.println("今天是周2,10天以后是周" + (week == 0 ? "日" : week));
    }

}

7.6.3 與if-else的轉(zhuǎn)換關(guān)系

• 凡是可以使用條件運算符的地方，都可以改寫為if-else結(jié)構(gòu)。反之，不成立。

• 開發(fā)中，如果既可以使用條件運算符，又可以使用if-else，推薦使用條件運算符。因為執(zhí)行效率稍高。

//if-else實現(xiàn)獲取兩個數(shù)的較大值

int i1 = 10;
int i2 = 20;

int max;//聲明變量max，用于記錄i1和i2的較大值

if(i1 > i2){
    max = i1;
}else{
    max = i2;
}

System.out.println(max);

7.7 運算符優(yōu)先級

運算符有不同的優(yōu)先級，所謂優(yōu)先級就是在表達式運算中的運算符順序。

上一行中的運算符總是優(yōu)先于下一行的。

開發(fā)建議：

1. 不要過多的依賴運算的優(yōu)先級來控制表達式的執(zhí)行順序，這樣可讀性太差，盡量使用()來控制表達式的執(zhí)行順序。
2. 不要把一個表達式寫得過于復雜，如果一個表達式過于復雜，則把它分成幾步來完成。例如：
   ? (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

8. 【拓展】關(guān)于字符集

8.1 字符集

• 編碼與解碼

計算機中儲存的信息都是用二進制數(shù)表示的，而我們在屏幕上看到的數(shù)字、英文、標點符號、漢字等字符是二進制數(shù)轉(zhuǎn)換之后的結(jié)果。按照某種規(guī)則，將字符存儲到計算機中，稱為編碼 。反之，將存儲在計算機中的二進制數(shù)按照某種規(guī)則解析顯示出來，稱為解碼 。

• 字符編碼（Character Encoding） : 就是一套自然語言的字符與二進制數(shù)之間的對應(yīng)規(guī)則。

• 字符集：也叫編碼表。是一個系統(tǒng)支持的所有字符的集合，包括各國家文字、標點符號、圖形符號、數(shù)字等。

8.2 ASCII碼

• ASCII碼（American Standard Code for Information Interchange，美國信息交換標準代碼）：上個世紀60年代，美國制定了一套字符編碼，對英語字符與二進制位之間的關(guān)系，做了統(tǒng)一規(guī)定。這被稱為ASCII碼。
• ASCII碼用于顯示現(xiàn)代英語，主要包括控制字符（回車鍵、退格、換行鍵等）和可顯示字符（英文大小寫字符、阿拉伯數(shù)字和西文符號）。
• 基本的ASCII字符集，使用7位（bits）表示一個字符（最前面的1位統(tǒng)一規(guī)定為0），共128個字符。比如：空格“SPACE”是32（二進制00100000），大寫的字母A是65（二進制01000001）。
• 缺點：不能表示所有字符。

8.3 ISO-8859-1字符集

• 拉丁碼表，別名Latin-1，用于顯示歐洲使用的語言，包括荷蘭語、德語、意大利語、葡萄牙語等
• ISO-8859-1使用單字節(jié)編碼，兼容ASCII編碼。

8.4 GBxxx字符集

• GB就是國標的意思，是為了顯示中文而設(shè)計的一套字符集。
• GB2312：簡體中文碼表。一個小于127的字符的意義與原來相同，即向下兼容ASCII碼。但兩個大于127的字符連在一起時，就表示一個漢字，這樣大約可以組合了包含7000多個簡體漢字，此外數(shù)學符號、羅馬希臘的字母、日文的假名們都編進去了，這就是常說的"全角"字符，而原來在127號以下的那些符號就叫"半角"字符了。
• GBK：最常用的中文碼表。是在GB2312標準基礎(chǔ)上的擴展規(guī)范，使用了雙字節(jié)編碼方案，共收錄了21003個漢字，完全兼容GB2312標準，同時支持繁體漢字以及日韓漢字等。
• GB18030：最新的中文碼表。收錄漢字70244個，采用多字節(jié)編碼，每個字可以由1個、2個或4個字節(jié)組成。支持中國國內(nèi)少數(shù)民族的文字，同時支持繁體漢字以及日韓漢字等。

8.5 Unicode碼

• Unicode編碼為表達任意語言的任意字符而設(shè)計，也稱為統(tǒng)一碼、標準萬國碼。Unicode 將世界上所有的文字用2個字節(jié)統(tǒng)一進行編碼，為每個字符設(shè)定唯一的二進制編碼，以滿足跨語言、跨平臺進行文本處理的要求。

• Unicode 的缺點：這里有三個問題：

  • 第一，英文字母只用一個字節(jié)表示就夠了，如果用更多的字節(jié)存儲是極大的浪費。
  • 第二，如何才能區(qū)別Unicode和ASCII？計算機怎么知道兩個字節(jié)表示一個符號，而不是分別表示兩個符號呢？
  • 第三，如果和GBK等雙字節(jié)編碼方式一樣，用最高位是1或0表示兩個字節(jié)和一個字節(jié)，就少了很多值無法用于表示字符，不夠表示所有字符。

• Unicode在很長一段時間內(nèi)無法推廣，直到互聯(lián)網(wǎng)的出現(xiàn)，為解決Unicode如何在網(wǎng)絡(luò)上傳輸?shù)膯栴}，于是面向傳輸?shù)谋姸?UTF（UCS Transfer Format）標準出現(xiàn)。具體來說，有三種編碼方案，UTF-8、UTF-16和UTF-32。

8.6 UTF-8

• Unicode是字符集，UTF-8、UTF-16、UTF-32是三種將數(shù)字轉(zhuǎn)換到程序數(shù)據(jù)的編碼方案。顧名思義，UTF-8就是每次8個位傳輸數(shù)據(jù)，而UTF-16就是每次16個位。其中，UTF-8 是在互聯(lián)網(wǎng)上使用最廣的一種 Unicode 的實現(xiàn)方式。
• 互聯(lián)網(wǎng)工程工作小組（IETF）要求所有互聯(lián)網(wǎng)協(xié)議都必須支持UTF-8編碼。所以，我們開發(fā)Web應(yīng)用，也要使用UTF-8編碼。UTF-8 是一種變長的編碼方式。它可以使用 1-4 個字節(jié)表示一個符號它使用一至四個字節(jié)為每個字符編碼，編碼規(guī)則：
  1. 128個US-ASCII字符，只需一個字節(jié)編碼。
  2. 拉丁文等字符，需要二個字節(jié)編碼。
  3. 大部分常用字（含中文），使用三個字節(jié)編碼。
  4. 其他極少使用的Unicode輔助字符，使用四字節(jié)編碼。

• 舉例

Unicode符號范圍 | UTF-8編碼方式

(十六進制)           | （二進制）

————————————————————|—–—–—–—–—–—–—–—–—–—–—–—–—–—–

0000 0000-0000 007F | 0xxxxxxx（兼容原來的ASCII）

0000 0080-0000 07FF | 110xxxxx 10xxxxxx

0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx

0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

8.7 小結(jié)

注意：在中文操作系統(tǒng)上，ANSI（美國國家標準學會、AMERICAN NATIONAL STANDARDS INSTITUTE: ANSI）編碼即為GBK；在英文操作系統(tǒng)上，ANSI編碼即為ISO-8859-1。文章來源地址http://www.zghlxwxcb.cn/news/detail-816247.html

到了這里，關(guān)于第02章_變量與運算符(關(guān)鍵字,標識符,變量,基本數(shù)據(jù)類型,進制,運算符,字符集)的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！