第四章 運(yùn)算符

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

運(yùn)算符：

就是對常量或者變量進(jìn)行操作的符號鳞骤。

比如： + - * /

表達(dá)式：

用運(yùn)算符把常量或者變量連接起來的筷畦，符合Java語法的式子就是表達(dá)式词裤。

比如：a + b 這個整體就是表達(dá)式。

而其中+是算術(shù)運(yùn)算符的一種鳖宾，所以這個表達(dá)式也稱之為 算術(shù)表達(dá)式

4.1 運(yùn)算符的種類

1. 算數(shù)運(yùn)算符

2. 關(guān)系運(yùn)算符 [ 比較運(yùn)算符 ]

3. 邏輯運(yùn)算符

4. 賦值運(yùn)算符

5. 三元運(yùn)算符

6. 位運(yùn)算符 [ 學(xué)習(xí)二進(jìn)制的基礎(chǔ) ]

4.1.1 算數(shù)運(yùn)算符

在 Java 程序中吼砂，算術(shù)運(yùn)算符是對數(shù)值類型的變量進(jìn)行運(yùn)算的，經(jīng)常會使用到鼎文。

代碼實現(xiàn):

需求：使用所有運(yùn)算符進(jìn)行練習(xí)渔肩。

1. 練習(xí)基本運(yùn)算符的使用

2. 重點(diǎn)了解： / 、% 拇惋、++ 周偎、--

3. % 取模要注意 數(shù)據(jù)的類型

4. ++ 自增 可以作為獨(dú)立的語句使用，也可以作為表達(dá)式使用

作為獨(dú)立語句使用時： ++i 和 i++ 都表示 i = i + 1;

作為表達(dá)式使用時：

前++ ++i： ++i 先自增 后賦值

后++ i++： i++ 先賦值 后自增

【Arithmetic（算數(shù)）Operator（運(yùn)算符）】

//算數(shù)運(yùn)算符運(yùn)算符進(jìn)行練習(xí)
public class ArithmeticOperator{
    //編寫一個main方法
    public static void main(String[] args){

        //此次練習(xí)為了便于了解撑帖，一律使用 int double String 類型的變量
        int num1 = 10; // int ---> 10
        int num2 = 90; // int ---> 90
        double num3 = 3.33; // double ---> 3.33
        double num4 = 4.44; // double ---> 4.44
        String num5 = "Xiao"; // String ---> Xiao
        String num6 = "Yuan"; // String ---> Yuan

        int test2 = + 11; // int ---> 11
        int test3 = - 22; // int ---> -22

        //正號負(fù)號
        System.out.println(test2); // 11    
        System.out.println(test3); // -22

        //加法運(yùn)算 +
        double sum1 = num1 + num2; // double ---> int 10 + int 90;
        System.out.println(sum1); // double ---> 100.0

        //減法運(yùn)算 -
        double sum2 = num2 - num1; // double ---> int 90 - int 10;
        System.out.println(sum1); // double ---> 80.0

        //乘法運(yùn)算 *
        double sum3 = num1 * num2; // double ---> int 10 * int 90;
        System.out.println(sum3); // double ---> 900.0

        //除法運(yùn)算 /
        double sum4 = num2 / num1; // double ---> int 90 / int 10;
        System.out.println(sum4); // double ---> 9.0

        //特例: 除法運(yùn)算 小數(shù)
        System.out.println( 10 / 4 ); // int10 / int4 = int 2  ---》 2.5 整數(shù)丟失精度
        System.out.println( 10.0 / 4 ); // double10 / int 4 = double 2.5 ----> 自動轉(zhuǎn)為精度高的計算
        double test1 = 10 / 4; // int10 / int4 = int2后 ----> 自動提升為精度高的變量
        System.out.println(test1); // double ---> 2.0

        //拼接運(yùn)算 +
        System.out.println(num5 + num6); // String ---> XiaoYuan

        //分割線
        System.out.println("-----------------------------------------------------------");

        //取模運(yùn)算 %  -->取余數(shù)
        // x % y = x - [(x / y) * y ]  ---> 計算全部按照其類型來計算

        // 11 % 10 = 11 - [(11/10)*10] = 11 - 1*10 = 11- 10 =1
        System.out.println( test2 % num1 ); // int11 / int10 ===> % ===> 1

        // -22 % 10 = -22 - [(-22/10)*10] = -22 - [-2*10] = -22 + 20 =-2
        System.out.println( test3 % num1 ); // int-22 / int10 ===> % ===> -2

        // 90 % -22 = 90 - [(90/-22)*-22] = 90 - [-4*-22] = 90- 88 =2
        System.out.println( num2 % test3 ); // int90 / int-22 ===> % ===> 2

        // -69 % -66 = -69 - [(-69/-66)*-66] = -69 - [1*-66] = -69 + 66 =-3
        System.out.println( -69 % -66 ); // int-69 / int-66 ===> % ===> -3

        //分割線
        System.out.println("-----------------------------------------------------------");

        // 自增運(yùn)算 ++ 
        int i1 = 1; //定義一個 int 類型的變量 i1

        //可以作為獨(dú)立語句使用蓉坎，作為獨(dú)立語句使用時：
        //前++ 和 后++ 都可以表示為 i = i + 1;
        i1++; // i1 = i1 + 1;
        System.out.println("i1自增結(jié)束，結(jié)果為:" + i1); //int ---> 2
        ++i1; // i1 = i1 + 1;
        System.out.println("i1自增結(jié)束胡嘿，結(jié)果為:" + i1); //int ---> 3

        //作為表達(dá)式使用:
        int i2 = 2; // int ---> 2
        int i3 = 3; // int ---> 3

        //前++ ：++i 先自增后賦值
        int j1 = ++i2; // 先自增 i2 = i2(=2) + 1; 后賦值 j1 = i2;
        System.out.println("j1蛉艾，結(jié)果為:" + j1); //int ---> 3
        System.out.println("i2自增結(jié)束，結(jié)果為:" + i2); //int ---> 3

        //后++ ：i++ 先賦值后自增
        int j2 = i3++; // 先賦值 j2 = i3(=3); 后自增 i3 = i3(=3) + 1; 
        System.out.println("j2衷敌，結(jié)果為:" + j2); //int ---> 3
        System.out.println("i3自增結(jié)束勿侯，結(jié)果為:" + i3); //int ---> 4

        //分割線
        System.out.println("-----------------------------------------------------------");

        // 自增運(yùn)算 --
        int i11 = 11; //定義一個 int 類型的變量 i11

        //可以作為獨(dú)立語句使用，作為獨(dú)立語句使用時：
        //前-- 和 后-- 都可以表示為 i = i - 1;
        i11--; // i11 = i11 - 1;
        System.out.println("i1自減結(jié)束缴罗，結(jié)果為:" + i11); //int ---> 10
        --i11; // i11 = i11 - 1;
        System.out.println("i1自減結(jié)束助琐，結(jié)果為:" + i11); //int ---> 9

        //作為表達(dá)式使用:
        int i12 = 12; // int ---> 12
        int i13 = 13; // int ---> 13

        //前-- ：--i 先自減后賦值
        int j12 = --i12; // 先自減 i12 = i12(=12) - 1; 后賦值 j12 = i12;
        System.out.println("j12鳖藕，結(jié)果為:" + j12); //int ---> 11
        System.out.println("i12自減結(jié)束邑飒，結(jié)果為:" + i12); //int ---> 11

        //后-- ：i-- 先賦值后自減
        int j13 = i13--; // 先賦值 j13 = i3(=3); 后自減 i13 = i13(=13) - 1; 
        System.out.println("j13彤恶，結(jié)果為:" + j13); //int ---> 13
        System.out.println("i13自減結(jié)束寇僧，結(jié)果為:" + i13); //int ---> 12
    }
}

細(xì)節(jié)說明：

1. 對于 出號'/' , 整數(shù)除法運(yùn)算和小數(shù)除法運(yùn)算是有區(qū)別的：整數(shù)之間做除法時允华，只保留整數(shù)部分（默認(rèn)int類型皮壁，精度丟失）更米。

2. 對于 取模'%'爬舰，其底層運(yùn)算為：x % y = x - [(x / y) * y],這就是取模的運(yùn)算本質(zhì)禀横。

3. 當(dāng) 自增 作為 獨(dú)立語句使用時屁药， ++i 等價于 i++ 等價于 i + 1

4. 當(dāng)自增作為一個表達(dá)式使用時，++i 先自增 再賦值

5. 當(dāng)自增作為一個表達(dá)式使用時柏锄，i++ 先賦值 再自增

面試題:

[ArithmeticOperatorInterview.java]

1酿箭、面試題一 :

題目：

int i =1 ;

i = i++;

System.out.println(i);

求 控制臺打印的結(jié)果？及其如何實現(xiàn)

//面試題練習(xí)
public class ArithmeticOperatorInterview{
    //編寫一個main方法
    public static void main(String[] args){
        /*
         題目： 
         int i = 1;
         i = i++; 
         System.out.println(i);
         求 控制臺打印的結(jié)果趾娃？及其如何實現(xiàn)
        */
        int i = 1; // int 類型 ---> 1
        // 規(guī)則使用臨時變量 1缭嫡、temp = i ; 2、i = i++; 3抬闷、i = temp;
        /*
            先賦值妇蛀，后自增
            自己理解：i = 1 --> i ; i++ --> i = i + 1;  i = 1
        */
        i = i++; // int 類型 ---> 1
        System.out.println(i); // 1

    }
}

2、面試題二 :

題目：

int i =1 ;

i = ++1;

System.out.println(i);

求 控制臺打印的結(jié)果笤成？及其如何實現(xiàn)

//面試題練習(xí)
public class ArithmeticOperatorInterview{
    //編寫一個main方法
    public static void main(String[] args){

        /*
         題目： 
         int i = 1;
         i = ++i; 
         System.out.println(i);
         求 控制臺打印的結(jié)果评架？及其如何實現(xiàn)
        */
        int i = 1; // int 類型 ---> 1
        // 規(guī)則使用臨時變量 1、i = i++; 2炕泳、temp = i; 3纵诞、i = temp;
        /*
            先賦值，后自增
            自己理解：i++ --> i = i + 1 --> 2; i = i++ = 2 --> i = i = 2
        */
        i = ++i; // int 類型 ---> 2
        System.out.println(i); // 2

    }
}

運(yùn)算符練習(xí)：

[ArithmeticOperatorExercise01.java]

int num1 = 10;

int num2 = 20'

int sum3 = num1++;

System.out.println("sum3 自增后的結(jié)果為:" + sum3);

System.out.println("num2 結(jié)果為:" + num2);

sum3 = --num2;

System.out.println("sum3 自減后的結(jié)果為:" + sum3);

System.out.println("num2 結(jié)果為:" + num2);

//1培遵、自增浙芙，自減 練習(xí)實現(xiàn)
public class ArithmeticOperatorExercise01{
    //編寫一個main方法
    public static void main(String[] args){

        // int 類型 num1 ---> 10
        int num1 = 10;

        // int 類型 num2 ---> 20
        int num2 = 20;

        // int 類型 sum3 ---> 10
        int sum3 = num1++;

        System.out.println("sum3 自增后的結(jié)果為:" + sum3); // int ---> 10

        System.out.println("num2 結(jié)果為:" + num2); // int ---> 20

        // int 類型 sum3 ---> 19
        sum3 = --num2;

        System.out.println("sum3 自減后的結(jié)果為:" + sum3); // int ---> 19

        System.out.println("num2 結(jié)果為:" + num2); // int ---> 19

    }
}

[ArithmeticOperatorExercise02.java]

1. 假如還有 59 天放假，問：合 xx 個星期零 xx 天

2. 定義一個變量保存華氏溫度籽腕，華氏溫度轉(zhuǎn)換攝氏溫度的公式為：5/9*(華氏溫度-100),請求出華氏溫度對應(yīng)的攝氏溫度嗡呼。[234.5]

//2、生活應(yīng)用題
public class ArithmeticOperatorExercise02{
    //編寫一個main方法
    public static void main(String[] args){

        //1节仿、假如還有 59 天放假晤锥，問：合 xx 個星期零 xx 天

        //需求分析:
        //(1) 使用int變量 nearVacation 保存距離放假總天數(shù)。
        //(2) 定義 一個星期 week 是 7 天 星期數(shù) nearWeek : nearVacation / week 
        //    距離放假的不足星期的天數(shù)：nearDay： nearVacation % week 

        // 定義 距離放假總天數(shù)廊宪。
        int nearVacation = 59;
        // 定義 每一周 時長為七天
        int week = 7;

        //計算 距離放假的星期數(shù)
        int nearWeek = nearVacation / week;
        //計算 距離放假的不足星期的天數(shù)
        int nearDay = nearVacation % week;

        //在控制臺打印 距離需求1
        System.out.println("距離放假還有"+ nearVacation + "天矾瘾，合計:" 
        + nearWeek +"個星期零"+ nearDay + "天!");

        //2、定義一個變量保存華氏溫度箭启，華氏溫度轉(zhuǎn)換攝氏溫度的公式為：
        //     5/9*(華氏溫度-100),請求出華氏溫度對應(yīng)的攝氏溫度壕翩。[234.5] 

        //聲明 一個 double類型的變量 fahrenheit 華氏溫度 
        double fahrenheit;
        //聲明 一個 double類型的變量 centigrade 攝氏溫度
        double centigrade;

        fahrenheit = 234.5; //把 待求的溫度 234.5 賦給 華氏溫度

        centigrade = 5.0 / 9.0 * (fahrenheit - 100); //計算出對應(yīng)的攝氏度

        //在控制臺打印 距離需求2
        System.out.println("華氏溫度:"+ fahrenheit + "\n對應(yīng)的攝氏溫度為："+ centigrade);
    }
}

4.1.2 關(guān)系運(yùn)算符

1. 關(guān)系運(yùn)算符的結(jié)果都是 boolean 型，也就是要么是 true傅寡，要么是 false

2. 關(guān)系表達(dá)式 經(jīng)常用在 if 結(jié)構(gòu)的條件中或循環(huán)結(jié)構(gòu)的條件中

3. 關(guān)系運(yùn)算符也叫比較運(yùn)算符

代碼實現(xiàn):

關(guān)系運(yùn)算符的使用 [RelationalOperator.java]

//關(guān)系運(yùn)算符進(jìn)行練習(xí)
public class RelationOperator{
    //編寫一個main方法
    public static void main(String[] args){

        //聲明一個 變量名為 relationOne 的 int類型變量
        int relationOne = 66;
        //聲明一個 變量名為 relationTwo 的 int類型變量
        int relationTwo = 99;

        //關(guān)系運(yùn)算符的使用： == != < <= > >= instanceof
        System.out.println(relationOne == relationTwo); // Boolean ---> false
        System.out.println(relationOne != relationTwo); // Boolean ---> true
        System.out.println(relationOne < relationTwo); // Boolean ---> true
        System.out.println(relationOne > relationTwo); // Boolean ---> false
        System.out.println(relationOne <= relationTwo); // Boolean ---> true
        System.out.println(relationOne >= relationTwo); // Boolean ---> false
        System.out.println("Yuan" instanceof String); // Boolean ---> true
        // System.out.println(int instanceof RelationOperator); // Boolean ---> true

        boolean relation = relationOne!=relationTwo;
        System.out.println("賦給relation的Boolean類型是："+ relation);
    }
}

細(xì)節(jié)說明：

1. 關(guān)系運(yùn)算符的結(jié)果都是 boolean類型放妈，是 true 或者 false北救。

2. 關(guān)系運(yùn)算符組成的表達(dá)式，被稱為：關(guān)系表達(dá)式 a == b;

3. 比較運(yùn)算符 '==' 不能寫為 '='芜抒； 一個是相等 一個是賦值珍策。

4.1.3 邏輯運(yùn)算符

用于連接多個條件（多個關(guān)系表達(dá)式），最終的結(jié)果也是一個 boolean 值宅倒。

1. 短路與 && 攘宙， 短路或 ||，取反 !

2. 邏輯與 &缓淹，邏輯或 |哈打，^ 邏輯異或

3. 說明邏輯運(yùn)算規(guī)則：

• a&b : & 叫邏輯與：規(guī)則：當(dāng) a 和 b 同時為 true ,則結(jié)果為 true, 否則為 false

  true & true --> true true & false --> false 左邊不為真罢维，輸出false

• a&&b : && 叫短路與：規(guī)則：當(dāng) a 和 b 同時為 true ,則結(jié)果為 true,否則為 false

  true & true --> true true & false --> false全部不為真，輸出false

• a|b : | 叫邏輯或丙挽，規(guī)則：當(dāng) a 和 b 肺孵，有一個為 true ,則結(jié)果為 true,否則為 false

  true & true --> false true & false --> true

• a||b : || 叫短路或，規(guī)則：當(dāng) a 和 b 颜阐，有一個為 true ,則結(jié)果為 true,否則為 false

• !a : 叫取反平窘，或者非運(yùn)算。當(dāng) a 為 true, 則結(jié)果為 false, 當(dāng) a 為 false 是凳怨，結(jié)果為 true

• a^b: 叫邏輯異或瑰艘，當(dāng) a 和 b 不同時，則結(jié)果為 true, 否則為 false

邏輯與 & 短路與 &&

基本規(guī)則:

使用區(qū)別:

1. & 邏輯與：不管第一個條件是否為 false，第二個條件都會判斷李剖。

2. && 短路與：如果第一個條件為 false芒率，則第二個條件不會判斷，最終結(jié)果為 false篙顺。

3. 在正常項目開發(fā)中偶芍， 我們會優(yōu)選選擇 短路與&&充择，開發(fā)效率相對較高。

代碼實現(xiàn)：

 // 邏輯運(yùn)算符的使用案例
public class LogicOperator01{
    //編寫一個main方法
    public static void main(String[] args){

        //聲明一個 boyAge 的int變量
        int boyAge = 21; // int ---> 21
        //聲明一個 girlAge 的int變量
        int girlAge = 22; // int ---> 22

        // 邏輯運(yùn)算符 --  & 邏輯與 和 && 短路與
        // 1匪蟀、if語句 邏輯與&
        if( boyAge < 22 & girlAge > 20 ){
            //在控制臺打印 if語句無誤
            System.out.println("if語句成立椎麦，輸出邏輯與&相關(guān)信息--true！");
        } // 語句為 true

        // 2材彪、if語句 邏輯與&&
        if( boyAge < 22 && girlAge > 20 ){
            //在控制臺打印 if語句無誤
            System.out.println("if語句成立铃剔，輸出邏輯與&&相關(guān)信息--true！");
        } // 語句為 true

        // 3查刻、if語句 邏輯與&  錯誤判斷
        if( girlAge < 16 & boyAge > 18 ){
            //在控制臺打印 if語句無誤
            System.out.println("if語句成立，輸出邏輯與&相關(guān)信息--false凤类！");
        } // 語句為 false

        // 4穗泵、if語句 邏輯與&&  錯誤判斷
        if( boyAge < 22 && girlAge > 20 ){
            //在控制臺打印 if語句無誤
            System.out.println("if語句成立，輸出邏輯與&&相關(guān)信息--false谜疤！");
        } // 語句為 false

        //分隔符
        System.out.println("---------------------------------");

        // 邏輯 & 不管第一個條件是否為 false佃延，第二個條件都會判斷。
        if( boyAge < 20 & ++girlAge > 20 ){
            //在控制臺打印 --- 條件全部執(zhí)行
            System.out.println("if語句條件全部執(zhí)行夷磕，輸出邏輯與&相關(guān)信息--false履肃！");
        } // 語句為 false
        System.out.println("boyAge的數(shù)值為："+ boyAge + "。girlAge的數(shù)值為:" + girlAge);

        // && 短路與：如果第一個條件為 false坐桩，則第二個條件不會判斷尺棋，最終結(jié)果為 false。
        if( --girlAge < 20 && ++boyAge > 20 ){
            //在控制臺打印 --- 條件全部執(zhí)行
            System.out.println("if語句條件全部執(zhí)行绵跷，輸出邏輯與&&相關(guān)信息--false膘螟！");
        } // 語句為 false
        System.out.println("boyAge的數(shù)值為："+ boyAge + "。girlAge的數(shù)值為:" + girlAge);

        //分隔符
        System.out.println("---------------------------------");

        //測試--前面為true碾局，后面是否執(zhí)行 短路與&&
        if( --boyAge < 25 && --girlAge > 25 )
        {
            //在控制臺打印 --- 前半句為true荆残，后半句為 false  --- 》 false
            System.out.println("前半句為true，后半句為 false  --- 》 false");
        }
        System.out.println("boyAge的數(shù)值為："+ boyAge + "净当。girlAge的數(shù)值為:" + girlAge);
    }
}

邏輯或 | , 短路或 ||

基本規(guī)則：

使用區(qū)別：

1. | 邏輯或：不管第一個條件是否為 true，第二個條件都要判斷像啼。

2. ||短路或：如果第一個條件為 true俘闯，則第二個條件不會判斷，最終結(jié)果為 true忽冻。

3. 在正常項目開發(fā)中备徐， 我們會優(yōu)選選擇 短路或 ||，開發(fā)效率相對較高甚颂。

代碼實現(xiàn)：

// 邏輯運(yùn)算符的使用案例
public class LogicOperator02{
    //編寫一個main方法
    public static void main(String[] args){

        //聲明一個 appleNum 的int變量
        int appleNum = 66; // int ---> 21
        //聲明一個 eggNum 的int變量
        int eggNum = 99; // int ---> 22

        // 邏輯運(yùn)算符 --  | 邏輯或 和 || 短路或
        // 邏輯或 | 只要有一個條件成立蜜猾，結(jié)果為 true,否則為 false
        if( appleNum < 100 | eggNum > 100){
            System.out.println("1條件成立秀菱，輸出結(jié)果為：True");
        }

        // 邏輯或 || 只要有一個條件成立，結(jié)果為 true,否則為false
        if( appleNum < 100 || eggNum > 100){
            System.out.println("2條件成立蹭睡，輸出結(jié)果為：True");
        } else {
        System.out.println("條件不成立衍菱，輸出結(jié)果為：False");
        }

        // | 邏輯或：不管第一個條件是否為 true，第二個條件都要判斷肩豁。
        if( ++appleNum > 110 | ++eggNum > 110){
            System.out.println("3條件成立脊串，輸出結(jié)果為：True");
        }
        System.out.println("ApllleNum的數(shù)量為："+ appleNum + ",EggNum的數(shù)量為："+ eggNum);

        // ||短路或：如果第一個條件為 true，則第二個條件不會判斷清钥，最終結(jié)果為 true琼锋。
        if( --appleNum > 110 || --eggNum > 110){
            System.out.println("4條件成立，輸出結(jié)果為：True");
        }
        System.out.println("ApllleNum的數(shù)量為："+ appleNum + ",EggNum的數(shù)量為："+ eggNum);
    }
}

邏輯非 ! , 邏輯異或 ^

基本規(guī)則：

代碼實現(xiàn)：

// 邏輯運(yùn)算符的使用案例
public class LogicOperator03{
    //編寫一個main方法
    public static void main(String[] args){

        int num1 = 66;
        int num2 = 99;

        //篡悟！是 邏輯非 取值反  ===》 谜叹！true = false 
        System.out.println(num1 < num2); // boolean ---> true
        System.out.println(!(num1 < num2)); // boolean ---> false
        System.out.println(num1 > num2); // boolean ---> false
        System.out.println((num1 > num2) == !(num1 < num2)); // boolean ---> true

        //分隔符
        System.out.println("---------------------------------");

        // ^ 是 邏輯異或 ,當(dāng) 條件1 和 條件2 不同時，結(jié)果為true搬葬，否則為 false
        boolean sum3 = (num1 > 1) ^ (num2 > 2);
        System.out.println("sum3的結(jié)果為："+ sum3); // boolean ---> false
        System.out.println((num1 < num2) ^ (num1 > num2)); // boolean ---> true
        System.out.println((num1 < 100) ^ (num2 < 100)); // boolean ---> false

    }
}

邏輯運(yùn)算符 代碼練習(xí)：

練習(xí)一荷腊、

//邏輯運(yùn)算符 代碼練習(xí)：
public class LoginOperatorExercise01{
    //編寫一個main方法
    public static void main(String[] args){

        //定義兩個 int 變量
        int num1 = 9;
        int num2 = 9;

        //第一題 --> 10 10
        if( num1++ == 10 & ++num2 == 10 ){
            num1 = 99;
        }
        System.out.println("1、num1的值為："+ num1 + "急凰，num2的值為：" + num2);

        //定義兩個 int 變量
        int num3 = 9;
        int num4 = 9;

        //第二題 --> 10 9
        if( num3++ == 10 && ++num4 == 10 ){
            num3 = 99;
        }
        System.out.println("1女仰、num3的值為："+ num3 + "，num4的值為：" + num4);

        //定義兩個 int 變量
        int num5 = 9;
        int num6 = 9;

        //第三題 -->  99 10
        if( num5++ == 9 | ++num6 == 9 ){
            num5 = 99;
        }
        System.out.println("1抡锈、num5的值為："+ num5 + "董栽，num6的值為：" + num6);

        //定義兩個 int 變量
        int num7 = 9;
        int num8 = 9;

        //第四題 --> 99 9
        if( num7++ == 9 || ++num8 == 9){
            num7 = 99;
        }
        System.out.println("1、num7的值為："+ num7 + "企孩，num8的值為：" + num8);

    }
}

練習(xí)二锭碳、

//邏輯運(yùn)算符 代碼練習(xí)：
public class LoginOperatorExercise02{
    //編寫一個main方法
    public static void main(String[] args){

        //定義兩個 boolean 類型的變量
        boolean x = true;
        boolean y = false;
        //定義一個 short 類型的變量
        short z = 96;

        //首先判斷 ： true && y = true ==> true  z = 97; y = true;
        if(( z++ == 96 ) && ( y = true)){
            z++; // z = 98
            // if判斷：false || true ==> true x = false; z = 99;
            if(( x = false ) || ( ++z == 99 )){
                z++; // z= 100
            }
        }
        System.out.println("輸出z的最終值為:"+ z );

    }
}

4.1.4 賦值運(yùn)算符

賦值運(yùn)算符就是將某個運(yùn)算后的值，賦給指定的變量勿璃。

賦值運(yùn)算符的分類

1. 基本賦值運(yùn)算符 [ = ]

int number = 99 double number = 99.99 = 等號賦值

2. 復(fù)合賦值運(yùn)算符

[ +=擒抛、-=、*=补疑、/=歧沪、%= 以及其他 = ]

a += b; ======> a = a + b;

a -= b; ======> a = a - b;

a *= b; ======> a = a * b;

a /= b; ======> a = a / b;

a %= b; ======> a = a % b;

3. 復(fù)合賦值運(yùn)算符基本使用 [ AssignOperator.java ]

4. 基本賦值運(yùn)算符 [ int num1 = 10 ]

5. 復(fù)合賦值運(yùn)算符 [ num1 += 10 ]

//賦值運(yùn)算符的基本使用
public class AssignOperator{
    //編寫一個main方法
    public static void main(String[] args){
        //基本賦值運(yùn)算符的使用
        int num1 = 10; // 10
        num1 = 33; //將常量33 賦給變量num1

        //復(fù)合賦值運(yùn)算符的使用
        int num2 = 66; // 66
        num2 += num1; // num2 = num2 + num1; 66 + 33 = 99;
        System.out.println("復(fù)合運(yùn)算后的值為:"+ num2);

    }
}

賦值運(yùn)算符的特點(diǎn)

1. 運(yùn)算順序：從右往左 int number = num1 + num2 + num3; 先運(yùn)算再賦給number

2. 賦值運(yùn)算符的 左邊 只能是變量，右邊 可以是變量莲组、表達(dá)式诊胞、常量值

int number = 33; int number = 33 * 3 * 4 /4; int number = number;

3. 復(fù)合賦值運(yùn)算符的本質(zhì)是 變量 復(fù)合運(yùn)算符 常量 ===> 變量 = 變量 運(yùn)算符 常量

4. 復(fù)合賦值運(yùn)算符會進(jìn)行類型轉(zhuǎn)換

byte be1 = 9; be1 += 1 ===> be1 = be1 + 1; be1++; ===> be1 = be1 + 1;

其中后兩個涉及到了強(qiáng)制轉(zhuǎn)換，因為 變量+常量 自動提升為 int類型

代碼實現(xiàn):

//賦值運(yùn)算符的基本使用
public class AssignOperator{
    //編寫一個main方法
    public static void main(String[] args){
        //基本賦值運(yùn)算符的使用
        int num1 = 10; // 10
        num1 = 33; //將常量33 賦給變量num1

        //復(fù)合賦值運(yùn)算符的使用
        int num2 = 66; // 66
        num2 += num1; // num2 = num2 + num1; 66 + 33 = 99;
        System.out.println("復(fù)合運(yùn)算后的值為:"+ num2);

        //運(yùn)算順序：從右往左
        //賦值運(yùn)算符的 左邊 只能是變量，右邊 可以是變量撵孤、表達(dá)式迈着、常量值
        int sum = num1 + num2 * 2; // 將 運(yùn)算后的值賦給 變量sum
        System.out.println("sum的值為:"+ sum); // 231

        //復(fù)合賦值運(yùn)算符會進(jìn)行類型轉(zhuǎn)換
        byte be1 = 9; // 9
        byte be2 = 6; // 6
        System.out.println("be1的值為:"+ be1);
        System.out.println("be2的值為:"+ be2);

        be1 += 1; // be1 = (byte)(be1 + 1);
        // be2 = be2 + 2; // 從int轉(zhuǎn)換到byte可能會有損失
        System.out.println("+=be1的值為:"+ be1);
        //System.out.println("be2的值為:"+ be2); 

        be1++; // be1 = (byte)(be1 + 1);
        System.out.println("be1++的值為:"+ be1);


    }
}

4.1.5 三元運(yùn)算符

基本語法: 條件表達(dá)式 ? 表達(dá)式 1: 表達(dá)式 2;

運(yùn)算規(guī)則：

1. 對條件表達(dá)式進(jìn)行運(yùn)算判斷，為 true 或 false;

2. 如果條件表達(dá)式為 true邪码，運(yùn)算后的結(jié)果是表達(dá)式 1裕菠；

3. 如果條件表達(dá)式為 false，運(yùn)算后的結(jié)果是表達(dá)式 2闭专；

基本使用：

【TernartOperator.java】

//三元運(yùn)算符的基本使用
public class TernaryOperator{
    //編寫一個main方法
    public static void main(String[] args){
        //定義兩個int類型的變量 方便比較
        int small = 33; // 33
        int big = 66; // 66

        /*
            1. small > big 為false;
            2. 然后執(zhí)行條件2 big++;
            3. 后++ 先賦值后增加 故 result1 = 66;
            4. 返回的結(jié)果為: 66;

         */
        int result1 = small > big ? small++ : big++;
        int result2 = small < big ? small-- : big--;

        System.out.println("條件表達(dá)式判斷為 false 時候的值為" + result1); //66
        System.out.println("條件表達(dá)式判斷為 true 時候的值為" + result2); //33

    }
}

細(xì)節(jié)說明:

1. 表達(dá)式 1 和表達(dá)式 2 要為可以賦給接收變量的類型(或可以自動轉(zhuǎn)換)

2. 三元運(yùn)算符 可以轉(zhuǎn)成 if--else 語句

//三元運(yùn)算符
int result = big > small > big++ : small--;
//if -- else 語句
if(big > small){
    result = big ++;
} else {
    result = small --;
}

細(xì)節(jié)代碼實現(xiàn)：

//三元運(yùn)算符的使用細(xì)節(jié)
public class TernaryOperatorDetail{
    //編寫一個main方法
    public static void main(String[] args){
        //表達(dá)式 1 和表達(dá)式 2 要為可以賦給接收變量的類型
        //(也可以自動轉(zhuǎn)換和強(qiáng)制轉(zhuǎn)換)
        int num1 = 33;
        int num2 = 66;
        double num3 = 99.99;
        double num4 = 3.14;

        //直接賦給 sum int類型 
        int sum1 = num1 > num2 ? 99 : 88;

        // int sum = num1 > num2 ? num3 : num4; 
        //從double轉(zhuǎn)換到int可能會有損失 故需要強(qiáng)制類型轉(zhuǎn)換
        int sum = num1 > num2 ? (int)num3 : (int)num4;

        // 從 int ==》 double 可以完成自動轉(zhuǎn)換
        double sum0 = num3 > num4 ? num1 : num2 + 1;

        System.out.println("相同 類型的值為" + sum1); // 88
        System.out.println("int 類型的值為" + sum); // 3
        System.out.println("double 類型的值為" + sum0); // 33.0

    }
}

代碼實現(xiàn)：

實現(xiàn)三個數(shù)取最大值 【 TernaryOperatorDetail.java 】

//三元運(yùn)算符的代碼練習(xí)
public class TernaryOperatorExercise{
    //編寫一個main方法
    public static void main(String[] args){

        //實現(xiàn)三個數(shù)取最大值

        int num1 = 33;
        int num2 = 66;
        int num3 = 99;

        //通過三元運(yùn)算符實現(xiàn) 比較
        //先通過兩個值的比較 num1 和 num2 得到最大值 保存到 max1 里
        //然后比較 max1 和 第三個值 得到最大值 最后 得到最大值 max2

        int max1 = num1 > num2 ?  num1 : num2; //比較 num1 和 num2
        int max2 = max1 > num3 ? max1 : num3; //比較 max1 和 num3

        System.out.println("三個數(shù)中的最大值為:"+ max2); // 最大值為:99

        //通過三元運(yùn)算符實現(xiàn) 一條語句
        //程序優(yōu)化上 不建議使用這條語句 因為 程序重復(fù)執(zhí)行
        int max = (num1 > num2 ? num1 : num2) > num3 ? (num1 > num2 ? num1 : num2) : num3;
    }
}

4.1.6 位運(yùn)算符

位運(yùn)算符有七個奴潘，分為兩類：

• 邏輯位運(yùn)算符：位與（&）、位或（|）影钉、位異或（^）画髓、非位（~）
• 移位運(yùn)算符：左移（<<）、右移（>>）平委、無符號右移（>>>）

位運(yùn)算符表-邏輯位運(yùn)算符

邏輯位運(yùn)算符的基本使用：

//位運(yùn)算 的基本使用
public class BitOperator{ 
    //編寫一個main方法
    public static void main(String[] args){

        // 按位與 & 的基本使用
        // 數(shù)值自動判定為 int類型
        /* 1.先得到2的原碼 --> 00000000 00000000 00000000 00000010
         * 然后得到2的補(bǔ)碼 --> 00000000 00000000 00000000 00000010
         * 2.先得到3的原碼 --> 00000000 00000000 00000000 00000011
         * 然后得到3的補(bǔ)碼 --> 00000000 00000000 00000000 00000011
         * 4.執(zhí)行 按位與 判斷
         *    2的補(bǔ)碼 00000000 00000000 00000000 00000010
         *    3的補(bǔ)碼 00000000 00000000 00000000 00000011
         *  ----------------------------------------------------------------
         *    按位與后的補(bǔ)碼 00000000 00000000 00000000 00000010
         *  運(yùn)算后的原碼 00000000 00000000 00000000 00000010
         *  故結(jié)果為: 2 
         */
        System.out.println(2&3); // int --> 2

        // 按位取反 ~ 的基本使用
        // 數(shù)值自動判定為 int類型
        /* 1.先得到2的原碼 --> 10000000 00000000 00000000 00000010
         * 然后的到2的反碼 --> 11111111 11111111 11111111 11111101
         * 然后得到2的補(bǔ)碼 --> 11111111 11111111 11111111 11111110
         * 2.執(zhí)行運(yùn)算 按位取反
         * 取反后的補(bǔ)碼 結(jié)果 --> 00000000 00000000 00000000 00000001
         * 取反后的原碼為 --> 00000000 00000000 00000000 00000001
         * 3.先得到3的原碼 --> 00000000 00000000 00000000 00000011
         * 然后得到3的補(bǔ)碼 --> 00000000 00000000 00000000 00000011
         * 4.執(zhí)行運(yùn)算 按位取反
         *    取反后的補(bǔ)碼 11111111 11111111 11111111 11111011
         *    取反后的原碼 100000000 00000000 00000000 00000100
         *  ----------------------------------------------------------------
         * ~-2 ---> 1   ~3 ---> -4
         */
        System.out.println(~-2); // 1
        System.out.println(~3); //-4

        // 按位或的基本使用
        // 數(shù)值自動判定為 int類型
        /* 1.先得到2的原碼 --> 00000000 00000000 00000000 00000010
         * 然后得到2的補(bǔ)碼 --> 00000000 00000000 00000000 00000010
         * 2.先得到3的原碼 --> 00000000 00000000 00000000 00000011
         * 然后得到3的補(bǔ)碼 --> 00000000 00000000 00000000 00000011
         * 4.執(zhí)行運(yùn)算 按位或 
         *    2的補(bǔ)碼 00000000 00000000 00000000 00000010
         *    3的補(bǔ)碼 00000000 00000000 00000000 00000011
         *  ----------------------------------------------------------------
         *    按位或后的補(bǔ)碼 00000000 00000000 00000000 00000011
         *  運(yùn)算后的原碼 00000000 00000000 00000000 00000011
         *  故結(jié)果為: 3
         */
        System.out.println(2|3);

        // 按位異或的基本使用
        // 數(shù)值自動判定為 int類型
        /* 1.先得到2的原碼 --> 00000000 00000000 00000000 00000010
         * 然后得到2的補(bǔ)碼 --> 00000000 00000000 00000000 00000010
         * 2.先得到3的原碼 --> 00000000 00000000 00000000 00000011
         * 然后得到3的補(bǔ)碼 --> 00000000 00000000 00000000 00000011
         * 4.執(zhí)行運(yùn)算 按位或 
         *    2的補(bǔ)碼 00000000 00000000 00000000 00000010
         *    3的補(bǔ)碼 00000000 00000000 00000000 00000011
         *  ----------------------------------------------------------------
         *    按位或后的補(bǔ)碼 00000000 00000000 00000000 0000001
         *  運(yùn)算后的原碼 00000000 00000000 00000000 00000001
         *  故結(jié)果為: 1
         */
        System.out.println(2^3);
    }
}

位運(yùn)算符表-移位運(yùn)算符

邏輯位運(yùn)算符的基本使用：

//位運(yùn)算 移位運(yùn)算符 的基本使用
public class BitOperator01{ 
    //編寫一個main方法
    public static void main(String[] args){

        /*
         * 1. int 22的原碼為: 00000000 00000000 00000000 00010110;
         * 2. 22 的 補(bǔ)碼為: 00000000 00000000 00000000 00010110;
         * 3. 符號位不變 岗照， 向左移兩個位數(shù) ，低位補(bǔ)0
         * 4. << 后的補(bǔ)碼為：00000000 00000000 00000000 01011000;
         *      << 后的原碼為：00000000 00000000 00000000 01011000;
         * 5. 本質(zhì)為：22 * 2 * 2 ==> 22 * 2^2 = 88
         */
        int num1 = 22 << 2 ;
        /*
         * 1. int 88的原碼為: 00000000 00000000 00000000 01011000;
         * 2. 88 的 補(bǔ)碼為: 00000000 00000000 00000000 01011000;
         * 3. 符號位不變 笆环， 向右移兩個位數(shù) 攒至，符號位補(bǔ)溢出位置
         * 4. >> 后的補(bǔ)碼為：00000000 00000000 00000000 00010110;
         *      >> 后的原碼為：00000000 00000000 00000000 00010110;
         * 5. 本質(zhì)為：88 / 2 / 2 ==> 88 / 2^2 = 22
         */
        int num2 = 88 >> 2 ;
        /*
         * 1. int 88的原碼為: 00000000 00000000 00000000 01011000;
         * 2. 88 的 補(bǔ)碼為: 00000000 00000000 00000000 01011000;
         * 3. 符號位也參與移動，空位補(bǔ)0躁劣，被移除的舍去
         * 4. >>> 后的補(bǔ)碼為：00000000 00000000 00000000 00010110;
         *      >>> 后的原碼為：00000000 00000000 00000000 00010110;
         * 5. 本質(zhì)為：88 / 2 / 2 ==> 88 / 2^2 = 22
         */
        int num3 = 88 >>> 2;

        System.out.println(num1); // 88
        System.out.println(num2); // 22
        System.out.println(num3); // 22

    }
}

位運(yùn)算符表的基本使用:

//位運(yùn)算的思考猜測
public class  BitOperator02{ 
    //編寫一個main方法
    public static void main(String[] args){

        int n1 = 1 >> 2; //算術(shù)右移

        int n2 = -1 >> 2; //算術(shù)右移

        int n3 = 1 >> 2; //算術(shù)左移

        int n4 = -1 >> 2; //算術(shù)左移

        int n5 = -1 >>> 2; //邏輯右移

        //以上移位運(yùn)算符的結(jié)果為：
        System.out.println("n1="+ n1); //0
        System.out.println("n2="+ n2); //-1
        System.out.println("n3="+ n3); //0
        System.out.println("n4="+ n4); //-1
        System.out.println("n5="+ n5); //1073741823


        //以下邏輯位運(yùn)算符為
        System.out.println(~2);//按位取反 -3
        System.out.println(~-5);//按位取反 4
        System.out.println(2&3);//按位與 2
        System.out.println(13&7);//按位與 5
        System.out.println(2|3);//按位或 3
        System.out.println(5|4);//按位或 5
        System.out.println(-3^3);//按位異或 -2

    }
}

4.1.7 運(yùn)算符優(yōu)先級

1. 運(yùn)算符又不同的優(yōu)先級迫吐，所謂的優(yōu)先級就是表達(dá)式運(yùn)算中的運(yùn)算順序。

2. 運(yùn)算符中從右往左運(yùn)算的是：單目運(yùn)算符账忘、賦值運(yùn)算符志膀。

3. 表格中的上一行運(yùn)算符優(yōu)先于下一行運(yùn)算符。

4.1.7 運(yùn)算符綜合練習(xí)

1. 計算下列表達(dá)式的結(jié)果
   10/3=3;10/5=2;10%2=0;-10.5%3=?;
   //a%b當(dāng)a是小數(shù)時鳖擒，公式=a-(int)a/b*b
   //-10.5%3 = -10.5 - (-10)/3 * 3 = -10.5 + 9 = -1.5
   //注意:
   有小數(shù)運(yùn)算溉浙，得到結(jié)果是近似值

2. 試說出下面代碼的結(jié)果
   int i= 66;
   System.out.println(++i+i);// 執(zhí)行i=i+ 1 =>i=67 => 134

3. 在Java中，以下賦值語句正確的是(C D)蒋荚。
   A) int num1 =(int)"18"; //錯誤應(yīng)該Integer.parselnt("18") ;
   B) int num2= 18.0; //錯誤 double -> int
   C) double num3=3d; //ok
   D) double num4=8; //ok int -> double
   E) int i=48; char ch = i+1; //錯誤int -> char
   F) byte b= 19; shorts = b+2; //錯誤int -> short

4. 試寫出將String轉(zhuǎn)換成double類型的語句戳稽， 以及將char類型轉(zhuǎn)換成String的語句,舉例
   說明即可,寫簡單代碼
   String str = "18.8";//注意字符串要可以被轉(zhuǎn)成double
   double d1 = Double.parseDouble(str);
   charc1 = '原';
   String str2 = c1 + "";

4.2 標(biāo)識符的命名規(guī)則和命名規(guī)范

標(biāo)識符的概念

1. Java 對各種變量、方法和類等命名時使用的字符序列稱為標(biāo)識符

2. 簡稱-凡是可以自己定義名稱的地方都叫標(biāo)識符 int number = 100; number為標(biāo)識符期升。

標(biāo)識符的命名規(guī)則

1. 只能由26個字母大小寫惊奇，數(shù)字0-9互躬，_或$組成（不能有空格）

2. 不能由數(shù)字開頭

3. 嚴(yán)格區(qū)分大小寫

4. 不能使用關(guān)鍵字和保留字，但是能包含關(guān)鍵字和保留字

代碼練習(xí):

//命名規(guī)范的練習(xí)
public class VariableJudgment{ 
    //編寫一個main方法
    public static void main(String[] args){

        int yuan; // 可以 由26個字母大小寫赊时，數(shù)字0-9吨铸，_或$組成
        int yuan01; // 可以 由26個字母大小寫，數(shù)字0-9祖秒，_或$組成
        int 0yuan; // 不可以 不能以數(shù)字開頭
        int x-y; // 不可以 不能有 - 符號
        int x y; // 不可一 變量名不能有空格
        int x$y; // 可以 由26個字母大小寫诞吱，數(shù)字0-9，_或$組成
        int class; //不可以 不能用關(guān)鍵字
        int int; //不可以 不能用關(guān)鍵字
        int double; //不可以 不能用關(guān)鍵字
        int public; //不可以 不能用關(guān)鍵字
        int static; //不可以 不能用關(guān)鍵字
        int goto; //不可以 不能用保留字
        int xiao_yuan; // 可以 由26個字母大小寫竭缝，數(shù)字0-9房维，_或$組成

    }
}

標(biāo)識符命名規(guī)[基礎(chǔ)版]

1. 包名：

多單詞組成時所有字母都小寫：aaa.bbb.ccc //比如 com.hsp.crm

2. 類名、接口名：

多單詞組成時抬纸，所有單詞的首字母大寫：XxxYyyZzz [大駝峰]
比如： TankShotGame

3. 變量名咙俩、方法名：

多單詞組成時，第一個單詞首字母小寫湿故，第二個單詞開始每個單詞首字母大寫：xxxYyyZzz [小駝峰阿趁，簡稱 駝峰法] 比如： tankShotGame

4. 常量名：

所有字母都大寫。多單詞時每個單詞用下劃線連接：XXX_YYY_ZZZ
比如 ：定義一個所得稅率 TAX_RATE.

5. 后面我們學(xué)習(xí)到 類坛猪，包脖阵，接口，等時墅茉，我們的命名規(guī)范要這樣遵守,更加詳細(xì)的看文檔.

代碼示例:

//命名規(guī)范的示例
public class NamingRules{
    //編寫一個main方法
    public static void main(String[] args){

        //不能包含空格
        // int a B = 999; // ××××××

        //不能由數(shù)字開頭
        // int 01Test = 100; // ××××××

        //不能使用關(guān)鍵字和保留字命黔，但是能包含關(guān)鍵字和保留字
        // int class = 10 ; // ××××××
        int class01 = 10 ; // √√√√√√

        //嚴(yán)格區(qū)分大小寫
        int n = 1; // √√√√√√
        int N = 2; // √√√√√√
        System.out.println(n == N); // false 不相等
        System.out.println(n + N + " = 1 + 2"); // false 不相等

        // abc 和 aBc 是兩個不同的變量
        int abc = 33;
        int aBc = 66;
        System.out.println(abc == aBc); // false 不相等
        System.out.println(abc + aBc + " = 33 + 66");

4.3 關(guān)鍵字

48個關(guān)鍵字：

abstract、assert就斤、boolean悍募、break、byte洋机、case坠宴、catch、char绷旗、class啄踊、continue、default刁标、do颠通、double、else膀懈、enum顿锰、extends、final、finally硼控、float刘陶、for、if牢撼、implements匙隔、import、int熏版、interface纷责、instanceof、long撼短、native再膳、new、package曲横、private喂柒、protected、public禾嫉、return灾杰、short、static熙参、strictfp艳吠、super、switch尊惰、synchronized讲竿、this泥兰、throw弄屡、throws、transient鞋诗、try膀捷、void、volatile削彬、while全庸。

4.4 保留字

Java 保留字：現(xiàn)有 Java 版本尚未使用，但以后版本可能會作為關(guān)鍵字使用融痛。自己命名標(biāo)識符時要避免使用這些保留字壶笼。

2個保留字（現(xiàn)在沒用以后可能用到作為關(guān)鍵字）：goto、const雁刷。

byValue覆劈、cast、future、 generic责语、 inner炮障、 operator、 outer坤候、 rest胁赢、 var 、 goto 白筹、const

3個特殊直接量：true智末、false、null遍蟋。

4.5 鍵盤輸入語句

在編程中吹害，需要接收用戶輸入的數(shù)據(jù)，就可以使用鍵盤輸入語句來獲取虚青。Input.java , 需要一個掃描器(對象), 就是Scanner

實現(xiàn)步驟:

1. 導(dǎo)入該類的所在包, java.util.*

2. 創(chuàng)建該類對象（聲明變量）

3. 調(diào)用里面的功能

代碼實現(xiàn):

要求：可以從控制臺接收用戶信息它呀，【姓名，年齡棒厘，薪水】

//鍵盤輸入的練習(xí)

import java.util.Scanner; //導(dǎo)入 java.util 下的 Scanner 類

public class Input{ 
    //編寫一個main方法
    public static void main(String[] args){
        //要求：可以從控制臺接收用戶信息纵穿，【姓名，年齡奢人，薪水】
        //需求實現(xiàn)：
        //1. 導(dǎo)入 java.util 下的 Scanner 類
        //2. 創(chuàng)建 Scanner 對象 實例 --> scanner 就是 Scanner 類的對象
        //3. 調(diào)用 Scanner 里面的方法 獲取用戶輸入的信息

        //創(chuàng)建 掃描器 實例
        Scanner scanner = new Scanner(System.in);

        //接受用戶輸入信息
        System.out.println("請輸入用戶的姓名:");
        //當(dāng)程序執(zhí)行到 next 方法時谓媒，會等待用戶輸入
        String userName = scanner.next();

        //接受用戶輸入信息
        System.out.println("請輸入用戶的年齡:");
        //當(dāng)程序執(zhí)行到 next 方法時，會等待用戶輸入
        int userAge = scanner.nextInt();

        //接受用戶輸入信息
        System.out.println("請輸入用戶的薪水:");
        //當(dāng)程序執(zhí)行到 next 方法時何乎，會等待用戶輸入
        double userSalary = scanner.nextDouble();

        System.out.println("--------以下為用戶的基本信息--------");
        System.out.println("用戶姓名:" + userName
            + "\t用戶年齡:" + userAge
            + "\t用戶收入:" + userSalary
        );

    }
}

4.6 進(jìn)制(程序員的基本功)

4.6.1 進(jìn)制介紹

對于整數(shù)句惯，有四種表示方式：
二進(jìn)制：0,1 ，滿 2 進(jìn) 1. 以 0b 或 0B 開頭支救。

---------- 二進(jìn)制是Binary抢野，簡寫為B
十進(jìn)制：0-9，滿 10 進(jìn) 1.

---------- 十進(jìn)制是Decimal各墨，簡寫為D

八進(jìn)制：0-7 指孤，滿 8 進(jìn) 1. 以數(shù)字 0 開頭表示。

---------- 八進(jìn)制是Octal贬堵，簡寫為O
十六進(jìn)制：0-9 及 A(10)-F(15)恃轩，滿 16 進(jìn) 1. 以 0x 或 0X 開頭表示。此處的 A-F 不區(qū)分大小寫黎做。

---------- 十六進(jìn)制為Hexadecimal叉跛，簡寫為H

代碼實現(xiàn)：

BinaryTest.java

//四種進(jìn)制的格式信息
public class BinaryTest{ 
    //編寫一個main方法
    public static void main(String[] args){

        //用二進(jìn)制表示
        int base2 = 0B1111; // int --->15

        //用八進(jìn)制表示
        int base8 = 01121; // int --->

        //用十進(jìn)制表示
        int base10 = 1121; // int --->

        //用十六進(jìn)制表示
        int base16 = 0X1121; // int --->

        System.out.println("二進(jìn)制為:"+ base2); //15
        System.out.println("八進(jìn)制為:"+ base8);    //593
        System.out.println("十進(jìn)制為:"+ base10); //1121
        System.out.println("十六進(jìn)制為:"+ base16); //4385

        System.out.println(0X1121B); //70171

    }
}

4.6.2 進(jìn)制的轉(zhuǎn)換(基本功)

• 進(jìn)制轉(zhuǎn)十進(jìn)制

  二進(jìn)制轉(zhuǎn)十進(jìn)制；

  八進(jìn)制轉(zhuǎn)十進(jìn)制蒸殿；

  十六進(jìn)制轉(zhuǎn)十進(jìn)制筷厘；

• 十進(jìn)制轉(zhuǎn)進(jìn)制

  十進(jìn)制轉(zhuǎn)二進(jìn)制挽铁；

  十進(jìn)制轉(zhuǎn)八進(jìn)制；

  十進(jìn)制轉(zhuǎn)十六進(jìn)制敞掘；

• 二進(jìn)制轉(zhuǎn)進(jìn)制

  二進(jìn)制轉(zhuǎn)八進(jìn)制叽掘；

  二進(jìn)制轉(zhuǎn)十六進(jìn)制；

• 進(jìn)制轉(zhuǎn)二進(jìn)制

  八進(jìn)制轉(zhuǎn)二進(jìn)制玖雁；

  十六進(jìn)制轉(zhuǎn)二進(jìn)制更扁；

一、進(jìn)制轉(zhuǎn)十進(jìn)制

以 1100 為例赫冬，分別以二進(jìn)制浓镜，八進(jìn)制，十六進(jìn)制轉(zhuǎn)換為 十進(jìn)制

1. 二進(jìn)制轉(zhuǎn)十進(jìn)制

轉(zhuǎn)換方法:

從最低位(右邊)開始劲厌，將每個位上的數(shù)提取出來膛薛，乘以2的(位數(shù)- 1)次方，然后求和补鼻。

二進(jìn)制 0b1100 --> 十進(jìn)制：

1 * 23(2的(位數(shù)4 -1)次方) + 1 * 22(2的(位數(shù)3 -1)次方) + 0 * 2 + 0 *1 = 12

2. 八進(jìn)制轉(zhuǎn)十進(jìn)制

轉(zhuǎn)換方法:

從最低位(右邊)開始哄啄，將每個位上的數(shù)提取出來，乘以8的(位數(shù)- 1)次方风范，然后求和咨跌。

八進(jìn)制 01100 --> 十進(jìn)制：

1 * 83 + 1 * 82 + 0 * 8 + 0 * 1 = 512 + 64 = 576

3. 十六進(jìn)制轉(zhuǎn)十進(jìn)制

轉(zhuǎn)換方法:

從最低位(右邊)開始，將每個位上的數(shù)提取出來硼婿，乘以16的(位數(shù)- 1)次方锌半，然后求和。

十六進(jìn)制 0X1100 --> 十進(jìn)制：

1 * 163 + 1 * 162 + 0 * 16 + 0 * 1 = 16 * 16 * 16 + 16 * 16 = 4352

4. 轉(zhuǎn)換練習(xí)

0b110001100 轉(zhuǎn)成 十進(jìn)制

--> 1 * 2^8 + 1 * 2^7 + 1 * 2^3 + 1 * 2^2 = 256+ 128+ 8 + 4 = 396
02456 轉(zhuǎn)成 十進(jìn)制

--> 2 * 8^3 + 4 * 8^2 + 5 * 8 + 6 * 1 = 1024 + 256 + 40 + 6 = 1326
0xA45 轉(zhuǎn)成 十進(jìn)制

--> A * 16^2 + 4 * 16 + 5 * 1 = 2560 + 64 + 5 = 2629

二寇漫、十進(jìn)制轉(zhuǎn)進(jìn)制

十進(jìn)制以 99刊殉、9999 為例，以十進(jìn)制 分別轉(zhuǎn)換為 二進(jìn)制州胳，八進(jìn)制记焊，十六進(jìn)制

1. 十進(jìn)制轉(zhuǎn)二進(jìn)制；

轉(zhuǎn)換方法:

十進(jìn)制數(shù)除以2陋葡，余數(shù)為權(quán)位上的數(shù)亚亲，得到商繼續(xù)除以2彻采，直到商為0終止腐缤，然后反向取余數(shù)。

十進(jìn)制 99 --> 二進(jìn)制: （ 0b01100011 ）

99 / 2 --1 = 49 / 2 -- 1 = 24 / 2 -- 0 = 12 / 2 -- 0 = 6 / 2 -- 0 = 3 / 2 -- 1 = ---- 1

2. 十進(jìn)制轉(zhuǎn)八進(jìn)制肛响；

轉(zhuǎn)換方法:

十進(jìn)制數(shù)除以8岭粤，余數(shù)為權(quán)位上的數(shù)，得到商繼續(xù)除以8特笋，直到商為0終止剃浇，然后反向取余數(shù)巾兆。

十進(jìn)制 9999 --> 八進(jìn)制: （ 023417 ）

9999 / 8 -- 7 = 1249 / 8 -- 1 = 0156 / 8 -- 4 = 019 / 8 -- 3 = ----2

3. 十進(jìn)制轉(zhuǎn)十六進(jìn)制；

轉(zhuǎn)換方法:

十進(jìn)制數(shù)除以16虎囚，余數(shù)為權(quán)位上的數(shù)角塑，得到商繼續(xù)除以16，直到商為0終止淘讥，然后反向取余數(shù)圃伶。

十進(jìn)制 9999 --> 十六進(jìn)制: （ 0X270F ）

9999 / 16 -- 15 = 624 / 16 -- 0 = 39 / 16 -- 7 = ----2

4. 轉(zhuǎn)換練習(xí)

123 轉(zhuǎn)成 二進(jìn)制 => 0b01111011

123 / 2 -- 1 = 61 / 2 -- 1 = 30 / 2 -- 0 = 15 / 2 -- 1 = 7 / 2 -- 1 = 3 / 2 -- 1 = 1

678 轉(zhuǎn)成八進(jìn)制 => 01246

678 / 8 -- 6 = 84 / 8 -- 4 = 10 / 8 -- 2 = 1

8912 轉(zhuǎn)成十六進(jìn)制 => 0x22D0

8912 / 16 -- 0 = 557 / 16 -- 13 = 34 / 16 -- 2 = 2

三、二進(jìn)制轉(zhuǎn)進(jìn)制

二進(jìn)制以 10110110 為例蒲列， 以二進(jìn)制 分別轉(zhuǎn)換為八進(jìn)制窒朋，十六進(jìn)制

1. 二進(jìn)制轉(zhuǎn)八進(jìn)制；

轉(zhuǎn)換方法:

從低位開始蝗岖，將二進(jìn)制數(shù)每三位一組侥猩，轉(zhuǎn)成對應(yīng)的八進(jìn)制數(shù)即可删性。

二進(jìn)制 10110110 --> 八進(jìn)制:

110 --> 6 蛙婴、110 --> 6 、010 --> 2 ----> 0266

2. 二進(jìn)制轉(zhuǎn)十六進(jìn)制展辞；

轉(zhuǎn)換方法:

從低位開始铅鲤，將二進(jìn)制數(shù)每四位一組杰标，轉(zhuǎn)成對應(yīng)的十六進(jìn)制數(shù)即可。

二進(jìn)制 10110110 --> 十六進(jìn)制:

0110 --> 6 彩匕、 1011 --> 11 ----> 0XB6

3. 轉(zhuǎn)換練習(xí)

0b11100101 轉(zhuǎn)成 八進(jìn)制
--> 011 --> 3 100 --> 4 101 --> 5 --> 345

0b1110010110 轉(zhuǎn)成 十六進(jìn)制

--> 0011 --> 3 1001 --> 9 0110 --> 6 --> 396

四腔剂、進(jìn)制轉(zhuǎn)二進(jìn)制

八進(jìn)制，十六進(jìn)制 以 765 驼仪、0x42b為例掸犬，分別轉(zhuǎn)換二進(jìn)制

1. 八進(jìn)制轉(zhuǎn)二進(jìn)制

轉(zhuǎn)換方法:

將八進(jìn)制數(shù)每 1 位，轉(zhuǎn)成對應(yīng)的一個 3 位的二進(jìn)制數(shù)即可绪爸。（注意事項湾碎，三位二進(jìn)制轉(zhuǎn)成八進(jìn)制是從右到左開始轉(zhuǎn)換，不足時補(bǔ)0）奠货。

八進(jìn)制 765--> 二進(jìn)制：（0b000111110101）

7 / 2 -- 1 = 3 / 2 -- 1 = 1 ----> 111

6 / 2 -- 0 = 3 / 2 -- 1 = 1 ----> 110

5 / 2 -- 1 = 2 / 2 -- 0 = 1 ----> 101

2. 十六進(jìn)制轉(zhuǎn)二進(jìn)制

轉(zhuǎn)換方法:

將十六進(jìn)制數(shù)每 1 位介褥，轉(zhuǎn)成對應(yīng)的一個 4 位的二進(jìn)制數(shù)即可。（注意事項递惋，四位二進(jìn)制轉(zhuǎn)成十六進(jìn)制是從右到左開始轉(zhuǎn)換柔滔，不足時補(bǔ)0）。

八進(jìn)制 0x42b --> 二進(jìn)制：

4 / 2 -- 0 = 2 / 2 -- 0 = 1 ----> 0100

2 / 2 -- 0 = 1 ----> 0010

11 / 2 -- 1 = 5 / 2 -- 1 = 2 / 2 -- 0 = 1 ----> 1011

3. 轉(zhuǎn)換練習(xí)

01230 轉(zhuǎn)成 二進(jìn)制 --> 0b0010 1001 100
001 010 011 000

0xAB29 轉(zhuǎn)成二進(jìn)制 --> 0b1010 1011 0010 1001

A --> 1010 B --> 1011 0010 1001

五萍虽、原碼睛廊、反碼、補(bǔ)碼(重點(diǎn) 難點(diǎn))

1. 對于有符號的而言:二進(jìn)制的最高位是符號位: 0表示正數(shù)杉编，1表示負(fù)數(shù)

2. 正數(shù)的原碼超全，反碼咆霜，補(bǔ)碼都相同

3. 負(fù)數(shù)的反碼=原碼取反（原碼符號位不變，其他取反）

4. 負(fù)數(shù)的補(bǔ)碼=原碼取反 + 1

5. 0的反碼嘶朱、補(bǔ)碼都是0

6. Java 沒有無符號數(shù) ==》 Java 都是有符號的數(shù)

7. 在計算機(jī)運(yùn)算的時候蛾坯，都是以補(bǔ)碼的方式來運(yùn)算的。

8. 當(dāng)我們看運(yùn)算結(jié)果的時候疏遏，要以原碼來看

原碼偿衰、反碼和補(bǔ)碼

1、機(jī)器數(shù)與真值

機(jī)器數(shù)：在計算機(jī)中數(shù)據(jù)和符號全部數(shù)字化改览，最高位為符號位下翎，且用0表示正、1表示負(fù)宝当，那么把包括符號在內(nèi)的一個二進(jìn)制數(shù)我們稱為機(jī)器數(shù)视事，機(jī)器數(shù)： 有原碼、反碼和補(bǔ)碼三種表示方法庆揩。

比如俐东，十進(jìn)制中的數(shù) +3 ，計算機(jī)字長為8位订晌，轉(zhuǎn)換成二進(jìn)制就是00000011虏辫。如果是 -3 ，就是 10000011 锈拨。

那么砌庄，這里的 00000011 和 10000011 就是機(jī)器數(shù)。

真值：用“+”奕枢、“—”號表示的二進(jìn)制數(shù)娄昆。

機(jī)器數(shù)因為第一位是符號位，所以機(jī)器數(shù)的形式值就不等于真正的數(shù)值缝彬。例如上面的有符號數(shù) 10000011萌焰，其最高位1代表負(fù)，其真正數(shù)值是 -3 而不是形式值131（10000011轉(zhuǎn)換成十進(jìn)制等于131）谷浅。所以扒俯，為區(qū)別起見，將帶符號位的機(jī)器數(shù)對應(yīng)的真正數(shù)值稱為機(jī)器數(shù)的真值一疯。

例：0000 0001的真值 = +000 0001 = +1撼玄，

1000 0001的真值 =   - 000 0001 =  -1

2、原碼违施、反碼和補(bǔ)碼的概念

原碼：

是最簡單的機(jī)器數(shù)表示法互纯。其數(shù)符位用0表示正瑟幕，1表示負(fù)磕蒲，其余各位表示真值本身留潦。

即用第一位表示符號， 其余位表示值辣往，比如如果是8位二進(jìn)制：

  1的原碼是00000001兔院，

-1的原碼是10000001。

反碼：

正數(shù)的反碼同原碼站削， 負(fù)數(shù)的反碼為除符號位外坊萝，其它各位按位取反。

正數(shù)的反碼是其本身许起， 負(fù)數(shù)的反碼是在其原碼的基礎(chǔ)上十偶，符號位不變，其余各個位取反

  1的反碼是00000001园细，

   -1的反碼是11111110惦积。

補(bǔ)碼：

正數(shù)的補(bǔ)碼同原碼，負(fù)數(shù)的補(bǔ)碼為反碼加1猛频。

負(fù)數(shù)的補(bǔ)碼是在其原碼的基礎(chǔ)上, 符號位不變, 其余各位取反, 最后+1

  1的補(bǔ)碼是00000001狮崩，

-1的補(bǔ)碼是11111110。

本文由博客一文多發(fā)平臺 OpenWrite 發(fā)布鹿寻！