# 測(cè)試標(biāo)識(shí)符的使用
1. 什么是標(biāo)識(shí)符？Java中變量、方法、類等要素命名時(shí)使用的字符序列，稱為標(biāo)識(shí)符。
    技巧：凡是自己可以起名字的地方都叫標(biāo)識(shí)符。比如：類名、方法名、變量名、包名、常量名等。
2. 標(biāo)識(shí)符的命名規(guī)則（必須要遵守，否則編譯不通過）
    > 由26個(gè)英文字母大小寫、0-9、_或$組成
    > 數(shù)字不可以開頭。
    > 不可以使用關(guān)鍵字和保留字，但能包含關(guān)鍵字和保留字。
    > Java中嚴(yán)格區(qū)分大小寫，長(zhǎng)度無限制。
    > 標(biāo)識(shí)符不能包含空格。
3. 標(biāo)識(shí)符的命名規(guī)范（建議遵守的軟性要求，否則工作時(shí)容易被鄙視）：
    - 包名：多單詞組成時(shí)所有字母都小寫：xxxyyyzzz。
      例如：java.lang.com.atguigu.bean
    - 類名、接口名：多單詞組成時(shí)，所有單詞的首字母大寫：XxxYyyZzz
      例如：HelloWorld, String, System等
    - 變量名、方法名：多單詞組成時(shí)，第一個(gè)單詞首字母小寫，第二個(gè)單詞開始每個(gè)單詞首字母大寫：
      例如：age,name,bookName,main,binarySearch,getName
    - 常量名：所有字母都大寫。多單詞時(shí)每個(gè)單詞用下劃線連接：XXX_YYY_ZZZ
      例如：MAX_VALUE, PI, DEFAULT_CAPACITY
說明：定義標(biāo)識(shí)符時(shí)，盡量“見名知意”

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

/**
  測(cè)試變量的基本使用
    1. 變量的理解：內(nèi)存中的一個(gè)存儲(chǔ)區(qū)域，該區(qū)域的數(shù)據(jù)可以在同一類型范圍內(nèi)不斷變化
    2. 變量的構(gòu)成包含三個(gè)要素：數(shù)據(jù)類型、變量名、存儲(chǔ)的值
    3. Java中變量聲明的格式：數(shù)據(jù)類型 變量名 = 變量值
    4. Java中的變量按照數(shù)據(jù)類型來分類：
     基本數(shù)據(jù)類型（8種）：
         整型：byte \ short \ int \ long
         浮點(diǎn)型：float \ double
         字符型：char
         布爾型：boolean
     引用數(shù)據(jù)類型：
         類(class)
         數(shù)組(array)
         接口(interface)
         枚舉(enum)
         注解(annotation)
         記錄(record)
    5. 定義變量時(shí)，變量名要遵循標(biāo)識(shí)符命名的規(guī)則和規(guī)范。
    6. 說明：
     ① 變量都有其作用域。變量只在作用域內(nèi)是有效的，出了作用域就失效了。
     ② 在同一個(gè)作用域內(nèi)，不能聲明兩個(gè)同名的變量
     ③ 定義好變量以后，就可以通過變量名的方式對(duì)變量進(jìn)行調(diào)用和運(yùn)算。
     ④ 變量值在賦值時(shí)，必須滿足變量的數(shù)據(jù)類型，并且在數(shù)據(jù)類型有效的范圍內(nèi)變化。
*/
  class VariableTest {
     public static void main(String[] args) {
         // 定義變量的方式1：
         char gender; // 過程1：變量的聲明
         gender = '男'; // 過程2：變量的賦值（或初始化）
         gender = '女';
        // 定義變量的方式2：聲明與初始化合并
         int age = 10;
         System.out.println(age);
         System.out.println("age = " + age);
         System.out.println("gender = " + gender);
         //在同一個(gè)作用域內(nèi)，不能聲明兩個(gè)同名的變量
        //char gender = '女';
         gender = '男';
        //由于number前沒有聲明類型，即當(dāng)前number變量沒有提前定義。所以編譯不通過。
        //number = 10;
     }
  }

class VariableTest {
    public static void main(String[] args) {
        //1.測(cè)試整型變量的使用
        // byte(1字節(jié)=8bit) \ short(2字節(jié)) \ int(4字節(jié)) \ long(8字節(jié))
        byte b1 = 12;
        byte b2 = 127;
        //編譯不通過。因?yàn)槌隽薭yte的存儲(chǔ)范圍
        //byte b3 = 128;
        short s1 = 1234;
        int i1 = 123234123;
        //① 聲明long類型變量時(shí)，需要提供后綴。后綴為'l'或'l'
        long l1 = 123123123L;
        //② 開發(fā)中，大家定義整型變量時(shí)，沒有特殊情況的話，通常都聲明為int類型。
    }
}

class VariableTest {
    public static void main(String[] args) {
        //2.測(cè)試浮點(diǎn)類型變量的使用
        //float \ double
        double d1 = 12.3;
        // 聲明long類型變量時(shí)，需要提供后綴。后綴為'f'或'F'
        float f1 = 12.3f;
        System.out.println("f1 = " + f1);
        // 開發(fā)中，大家定義浮點(diǎn)型變量時(shí)，沒有特殊情況的話，通常都聲明為double類型，因?yàn)榫雀摺?
        // float類型表數(shù)范圍要大于long類型的表數(shù)范圍。但是精度不高。
        //測(cè)試浮點(diǎn)型變量的精度
        //測(cè)試1
        System.out.println(0.1 + 0.2);
        //測(cè)試2:
        float ff1 = 123123123f;
        float ff2 = ff1 + 1;
        System.out.println(ff1);
        System.out.println(ff2);
        System.out.println(ff1 == ff2);
    }
}

/*  
    案例1：定義圓周率并賦值為3.14，現(xiàn)有3個(gè)圓的半徑分別為1.2、2.5、6，求它們的面積。  
*/
class FloatDoubleExer {
    public static void main(String[] args) {
        // 定義圓周率變量
        double pi = 3.14;
        // 定義三個(gè)圓的半徑
        double radius1 = 1.2;
        double radius2 = 2.5;
        int radius3 = 6;
        //計(jì)算面積
        double arr1 = pi * radius1 * radius1;
        double arr2 = pi * radius2 * radius2;
        double arr3 = pi * radius3 * radius3;
        //輸出
        System.out.println("圓1的半徑為：" + radius1 + ",面積為：" + arr1);
        System.out.println("圓2的半徑為：" + radius2 + ",面積為：" + arr2);
        System.out.println("圓3的半徑為：" + radius3 + ",面積為：" + arr3);
    }
}

/**
 * 案例2：小明要到美國(guó)旅游，可是那里的溫度是以華氏度為單位記錄的。
 * 它需要一個(gè)程序?qū)⑷A氏溫度（80度）轉(zhuǎn)換為攝氏度，并以華氏度和攝氏度為單位分別顯示該溫度。
 * ℃ = (℉ - 32) / 1.8;
 */
class FloatDoubleExer1 {
    public static void main(String[] args) {
        double hua = 80.0;
        double she = (hua - 32) / 1.8;
        System.out.println("華氏度" + hua + "°F對(duì)應(yīng)的攝氏度" + she + "°C");
    }
}

class VariableTest2 {
    public static void main(String[] args) {
        //1.字符類型：char(2字節(jié))
        //表示形式1：使用一對(duì)‘'表示，內(nèi)部有且僅有一個(gè)字符(不能沒有)
        char c1 = 'a';
        char c2 = '中';
        char c3 = '1';
        char c4 = '%';
        char c5 = 'Y';
        //編譯不通過
        //char c6 = ' ';
        //char c7 = 'ab';
        //表示形式2：直接使用unicode值來表示字符型常量 。
        char c8 = '\u0036';
        System.out.println(c8);
        //表示形式3：使用轉(zhuǎn)義字符
        char c9 = '\n';
        char c10 = '\t';
        System.out.println("hello" + c9 + "world");
        // 表示形式4：使用具體字符對(duì)應(yīng)的數(shù)值（比如ASCII碼）
        char c11 = 97;
        System.out.println(c11);//a
        char c12 = '1';
        char c13 = 1;
        System.out.println(c12 == c13);
    }
}

class VariableTest2 {
    public static void main(String[] args) {
        //2. 布爾類型：boolean
        //只有兩個(gè)取值：true、false
        boolean bo1 = true;
        boolean bo2 = false;
        //編譯不通過
        //boolean bo3 = 0;
        //常使用在流程控制語句中。比如：條件判斷、循環(huán)結(jié)構(gòu)等
        boolean isMarried = true;
        if(isMarried){
            System.out.println("很遺憾，不能參加單身派對(duì)了");
        }else{
            System.out.println("可以多談幾個(gè)女朋友或男朋友");
        }
        //了解：我們不談boolean類型占用的空間大小。但是，真正在內(nèi)存中分配的話，使用的是4個(gè)字節(jié)。
    }
}

/**
 測(cè)試基本數(shù)據(jù)類型變量間的運(yùn)算規(guī)則。
 1. 這里提到可以做運(yùn)算的基本數(shù)據(jù)類型有7種，不包含boolean類型。
 2. 運(yùn)算規(guī)則包括：
 - 自動(dòng)類型提升
 - 強(qiáng)制類型轉(zhuǎn)換
 3. 此VariableTest3.java用來測(cè)試自動(dòng)類型提升
 規(guī)則：當(dāng)容量小的變量與容量大的變量做運(yùn)算時(shí)，結(jié)果自動(dòng)轉(zhuǎn)換為容量大的數(shù)據(jù)類型。
    byte 、 short 、 char ---> int  ---> long  ---> float ---> double
    特別的：byte、short類型的變量之間做運(yùn)算，結(jié)果為int類型
 說明：此時(shí)的容量小或大，并非指占用的內(nèi)存空間的大小，而是指表示數(shù)據(jù)的范圍的大小。
     long(8字節(jié)) < float(4字節(jié))
 */
class VariableTest3 {
    public static void main(String[] args) {
        int i1 = 10;
        int i2 = i1;
        long l1 = i1;
        float f1=l1;
        byte b1 = 12;
        int i3 = b1 + i1;
        //編譯不通過
        //byte b2 = b1 + i1;
        //********************************************************************
        //特殊的情況1：byte、short之間做運(yùn)算
        byte b3 = 12;
        short s1 = 10;
        //編譯不通過
        //short s2 = b3 + s1;
        i3 = b3 + s1;
        byte b4 = 10;
        //編譯不通過
        //byte b5 = b3 + b4;
        //特殊的情況2：char
        char c1 = 'a';
        //編譯不通過
        //char c2 = c1 + b3;
        int i4 = c1 + b3;
        //*******************************
        //練習(xí)1:
        long l2 = 123L;
        long l3 = 123; //理解為: 自動(dòng)類型提升 (int--->long)
        //long l4 = 123123123123; //123123123123理解為int類型, 因?yàn)槌隽薸nt范圍, 所以報(bào)錯(cuò)。
        long l5 = 123123123123L;//此時(shí)的123123123123L就是使用8個(gè)字節(jié)存儲(chǔ)的long類型的值
        //練習(xí)2:
        float f2 = 12.3F;
        //編譯不通過
        //float f3 = 12.3; //不滿足自動(dòng)類型提升的規(guī)則 (double --> float)。所以報(bào)錯(cuò)
        //練習(xí)3:
        //規(guī)定1: 整型常量, 規(guī)定是int類型。
        byte b5 = 10;
        //byte b6 = b5 + 1;
        int i11 = b5 + 1;
        //規(guī)定2: 浮點(diǎn)型常量, 規(guī)定是double類型。
        double dd1 = b5 + 12.3;
        //練習(xí)4: 說明為什么不允許變量名是數(shù)字開頭的。為了“自治”
        /*
        int 123L = 12;
        long l6 = 123L;
        */
    }
}

/*
    此VariableTest4.java用來測(cè)試強(qiáng)制類型轉(zhuǎn)換
    規(guī)則：
        1. 如果需要將容量大的變量的類型轉(zhuǎn)換為容量小的變量的類型，需要使用強(qiáng)制類型轉(zhuǎn)換
        2. 強(qiáng)制類型轉(zhuǎn)換需要使用強(qiáng)轉(zhuǎn)符：()。在()內(nèi)指明要轉(zhuǎn)換為的數(shù)據(jù)類型。
        3. 強(qiáng)制類型轉(zhuǎn)換過程中，可能導(dǎo)致精度損失
*/
class VariableTest4 {
    public static void main(String[] args) {
        double d1 = 12;//自動(dòng)類型提升
        //編譯失敗
        //int i1 = d1;
        int i2 = (int)d1;
        System.out.println(i2);
        long l1 = 123;
        //編譯失敗
        //short s1 = l1;
        short s2 = (short)l1;
        System.out.println(s2);
        //練習(xí)
        int i3 = 12;
        float f1 = i3;//自動(dòng)類型提升
        System.out.println(f1);//12.0
        float f2 = (float)i3; //編譯可以通過。只不過可以省略()而已。
        //精度損失的例子1:
        double d2 = 12.9;
        int i4 = (int)d2;
        System.out.println(i4);
        //精度損失的例子2:
        int i5 = 128;
        byte b1 = (byte)i5;
        System.out.println(b1); //-128
    }
}

/*
基本數(shù)據(jù)類型與String的運(yùn)算
    一、關(guān)于String的理解
        1. String類，屬于引用數(shù)據(jù)類型，俗稱字符串。
        2. String類型的變量，可以使用一對(duì)“”的方式進(jìn)行賦值。
        3. String聲明的字符串內(nèi)部，可以包含0個(gè)、1個(gè)或多個(gè)字符。
    二、String與基本數(shù)據(jù)類型變量間的運(yùn)算
        1. 這里的基本數(shù)據(jù)類型包括boolean在內(nèi)的8種。
        2. String與基本數(shù)據(jù)類型變量間只能做連接運(yùn)算，使用“+”表示。
        3. 運(yùn)算的結(jié)果的String類型
*/
class StringTest {
    public static void main(String[] args) {
        String str1 = "Hello World!";
        System.out.println("str1");
        System.out.println(str1);
        String str2 = "";
        String str3 = "a"; //char c1 = 'a';
        //測(cè)試連接運(yùn)算
        int num1 = 10;
        boolean b1 = true;
        String str4 = "hello";
        System.out.println(str4 + b1);
        String str5 = str4 + b1;
        String str6 = str4 + b1 + num1;
        System.out.println(str6); //hellotrue10
        //思考：如下的聲明編譯能通過嗎？不能
        //String str7 = b1 + num1 + str4;//布爾類型不能參與數(shù)值運(yùn)算
        //如何將String類型的變量轉(zhuǎn)換為基本數(shù)據(jù)類型？
        String str8 = "abc"; //不能考慮轉(zhuǎn)換為基本數(shù)據(jù)類型的。
        int num2 = 10;
        String str9 = num2 + ""; //"10"
        //編譯不通過
        //int num3 = (int)str9;
        //如何實(shí)現(xiàn)呢？使用Integer
        int num3 = Integer.parseInt(str9);
        System.out.println(num3+1);
    }
}

/**
 * 要求填寫自己的姓名、年齡、性別、體重、婚姻狀況（已婚用true表示，單身用false表示）、聯(lián)系方式等等。
 */
class StringExer {
    public static void main(String[] args) {
        String name = "李進(jìn)";
        int age = 24;
        char gender = '男';
        double weight = 130.5;
        boolean isMarried = false;
        String phoneNumber = "13012341234";
        String info = "name = " + name + ",age = " + age + ",gender = " + gender + ",weight = " + weight + ",isMarried = " + isMarried + ",phoneNumber = " + phoneNumber;
        System.out.println(info);
    }
}

class StringExer1 {
    public static void main(String[] args) {
        //練習(xí)1:
        //String str1 = 4;
        //判斷對(duì)錯(cuò): no
        String str2 = 3.5f + "";
        //判斷str2對(duì)錯(cuò): yes
        System.out.println(str2);
        //輸出: 3.5
        System.out.println(3 + 4 + "Hello!");
        //輸出: 7Hello!
        System.out.println("Hello!" + 3 + 4);
        //輸出: Hello!34
        System.out.println('a' + 1 + "Hello!");
        //輸出: 98Hello!
        System.out.println("Hello" + 'a' + 1);
        //輸出: Helloa1
        //練習(xí)2:
        System.out.println("*    *");
        //輸出: *    *
        System.out.println("*\t*");
        //輸出: *	*
        System.out.println("*" + "\t" + "*");
        //輸出: *	*
        System.out.println('*' + "\t" + "*");
        //輸出: *	*
        System.out.println('*' + '\t' + "*");
        //輸出: 51*
        System.out.println('*' + "\t" + '*');
        //輸出: *	*
        System.out.println('*' + '\t' + '*');
        //輸出: 93
    }
}

/*
測(cè)試常用的進(jìn)制：
    十進(jìn)制（decimal）
        - 數(shù)字組成：0-9
        - 進(jìn)位規(guī)則：滿十進(jìn)一
    二進(jìn)制（binary）
        - 數(shù)字組成：0-1
        - 進(jìn)位規(guī)則：滿二進(jìn)一，以“0b”或“0B”開頭
    八進(jìn)制（octal）： 很少使用
        - 數(shù)字組成：0-7
        - 進(jìn)位規(guī)則：滿八進(jìn)一，以數(shù)字“0”開頭表示
    十六進(jìn)制
        - 數(shù)字組成：0-9、a-f
        - 進(jìn)位規(guī)則：滿十六進(jìn)一，以“0x”或“0X”開頭表示。此處的 a-f 不區(qū)分大小寫
 */
class BinaryTest {
    public static void main(String[] args) {
        int num1 = 103; //十進(jìn)制
        int num2 = 0b10; //二進(jìn)制
        int num3 = 023; //八進(jìn)制
        int num4 = 0X23a; //十六進(jìn)制
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);
    }
}

/**
 * 測(cè)試運(yùn)算符的使用1：算術(shù)運(yùn)算符的使用
 * 1. + - * / % (前)++ (后)++ (前)--
 */
class AriTest {
    public static void main(String[] args) {
        //*************************************
        //除法：
        int m1 = 12;
        int n1 = 5;
        int k1 = m1 / n1;
        System.out.println(k1);//2
        System.out.println(m1 / n1 * n1);//10
        //*************************************
        //取模（或取余）：%
        int i1 = 12;
        int j1 = 5;
        System.out.println(i1 % j1); //2
        //開發(fā)中，經(jīng)常用來判斷某個(gè)數(shù)num1能整除另外一個(gè)數(shù)num2。
        //比如：判斷num1是否是偶數(shù)： num1 % 2 == 0
        //結(jié)論：取模以后，結(jié)果與被模數(shù)的符號(hào)相同
        int i2 = -12;
        int j2 = 5;
        System.out.println(i2 % j2); //-2
        int i3 = 12;
        int j3 = -5;
        System.out.println(i3 % j3); //2
        int i4 = -12;
        int j4 = -5;
        System.out.println(i4 % j4); //-2
        //*************************************
        //(前)++ : 先自增1，再運(yùn)算
        //(后)++ : 先運(yùn)算，后自增1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = " + a1 + ",b1 = " + b1); //a1 = 11,b1 = 11
        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2 = " + a2 + ",b2 = " + b2); //a2 = 11,b2 = 10
        //練習(xí)1:
        int i = 10;
        //i++;
        ++i;
        System.out.println("i = " + i);//11
        //練習(xí)2:
        short s1 = 10;
        //方式1：
        //編譯不通過
        //s1 = s1 + 1
        //s1 = (short) (s1 + 1);//先從short轉(zhuǎn)int后再?gòu)?qiáng)轉(zhuǎn)short（截?cái)啵?
        //System.out.println("s1 = " + s1);
        //方式2：
        s1++;//一直是short
        System.out.println("s1 = " + s1);
        //*******************************
        //(前) -- : 先自減1，再運(yùn)算
        //(后) -- : 先運(yùn)算，再自減1
        //略
        //++ 或 -- 運(yùn)算，不會(huì)改變變量的數(shù)據(jù)類型
        //+: 連接符，適用于String與其他類型的變量間的運(yùn)算，而且運(yùn)算的結(jié)果也是String類型。
    }
}

/**
 * 隨意給出一個(gè)三位的整數(shù)，打印顯示它的個(gè)位數(shù)、十位數(shù)、百位數(shù)的值。
 * 格式如下：
 * 數(shù)字xxx的情況如下：
 * 個(gè)位數(shù)：
 * 十位數(shù)：
 * 百位數(shù)：
 * <p>
 * 例如：
 * 數(shù)字153的情況如下：
 * 個(gè)位數(shù)：3
 * 十位數(shù)：5
 * 百位數(shù)：1
 */
class AriExer {
    public static void main(String[] args) {
        int num = 153;
        int ge = num % 10; //個(gè)位
        int shi = num / 10 % 10; //十位。 或者 int shi = num % 100 / 10
        int bai = num / 100;
        System.out.println("個(gè)位是: " + ge);
        System.out.println("十位是: " + shi);
        System.out.println("百位是: " + bai);
    }
}

/*
案例2：為抵抗洪水，戰(zhàn)士連續(xù)作戰(zhàn)89小時(shí)，編程計(jì)算共多少天零多少小時(shí)？
*/
class AriExer1 {
    public static void main(String[] args) {
        int hours = 89;
        int day = hours / 24;
        int hour = hours % 24;
        System.out.println("共奮戰(zhàn)了" + day + "天零" + hour + "小時(shí)");
    }
}

class AriExer1 {
    public static void main(String[] args) {
        //額外的練習(xí)1:
        System.out.println("5+5=" + 5 + 5);
        System.out.println("5+5=" + (5 + 5));
        //額外的練習(xí)2:
        byte bb1 = 127;
        bb1++;
        System.out.println("bb1 = " + bb1);
        //額外的練習(xí)3:
//        int i = 1;
//        int j = i++ + ++i * i++;
//
//        System.out.println("j = " + j);//10
        //額外的練習(xí)4:
        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);//2
    }
}

/**
 * 測(cè)試運(yùn)算符的使用2：賦值運(yùn)算符
 * 1. = += -= *= /= %=
 * 2. 說明：
 * ① 當(dāng)“=”兩側(cè)數(shù)據(jù)類型不一致時(shí)，可以使用自動(dòng)類型轉(zhuǎn)換或使用強(qiáng)制類型轉(zhuǎn)換原則進(jìn)行處理。
 * ② 支持連續(xù)賦值。
 * ③ +=、-=、*=、/=、%= 操作，不會(huì)改變變量本身的數(shù)據(jù)類型。
 */
class SetValueTest {
    public static void main(String[] args) {
        //**************************************
        int i = 5;
        long l = 10; // 自動(dòng)類型提升
        byte b = (byte) i; // 強(qiáng)制類型轉(zhuǎn)換
        // 操作方式1:
        int a1 = 10;
        int b1 = 10;
        // 操作方式2: 連續(xù)賦值
        int a2;
        int b2;
        // 或合并: int a2,b2;
        a2 = b2 = 10;
        System.out.println(a2 + ", " + b2);
        // 操作方式3:
        // int a3 = 10;
        // int b3 = 20;
        int a3 = 10, b3 = 20;
        System.out.println(a3 + ", " + b3);
        //*******************************************
//說明 += 的使用
        int m1 = 10;
        m1 += 5; //類似于m1 = m1 + 5;
        System.out.println(m1);
        byte by1 = 10;
        by1 += 5; //by1 = by1 + 5操作會(huì)編譯報(bào)錯(cuò)。應(yīng)該寫為：by1 = (byte)(by1 + 5);
        System.out.println(by1);
        int m2 = 1;
        m2 *= 0.1; // m2 = (int)(m2 * 0.1)
        System.out.println(m2);
        //練習(xí)1：如何實(shí)現(xiàn)變量的值增加2。
        //方式1:
        int n1 = 10;
        n1 += 2;
        //方式2: 推薦
        int n2 = 10;
        n2 += 2;
        // 練習(xí)2：如何實(shí)現(xiàn)變量的值增加1。
        // 方式1：
        int i1 = 10;
        i1 = i1 + 1;
        // 方式2：
        int i2 = 10;
        i2 += 1;
        // 方式3：推薦
        int i3 = 10;
        i3++; // ++i3;
    }
}

/*
測(cè)試運(yùn)算符的使用3：比較運(yùn)算符
1. == != > >= <= instanceof
2. 說明
① instanceof 在面向?qū)ο蟮亩鄳B(tài)性的位置講解。
② == != > >= <= 適用于除boolean類型之外的其它7種基本數(shù)據(jù)類型。
    運(yùn)算的結(jié)果為boolean類型。
③ 了解：== != 可以適用于引用數(shù)據(jù)類型
④ 區(qū)分：== 與 =
    I
*/
class CompareTest {
    public static void main(String[] args) {
        int m1 = 10;
        int m2 = 20;
        boolean compare1 = m1 > m2;
        System.out.println(compare1);
        int n1 = 10;
        int n2 = 20;
        System.out.println(n1 == n2);//false
        System.out.println(n1 = n2);//20
        boolean b1 = false;
        boolean b2 = true;
        System.out.println(b1 == b2);//false
        System.out.println(b1 = b2);//true
    }
}

/*
 測(cè)試運(yùn)算符的使用4：邏輯運(yùn)算符
 1. && || ! ^
 2. 說明：
 ① 邏輯運(yùn)算符針對(duì)的都是boolean類型的變量進(jìn)行的操作
 ② 邏輯運(yùn)算符運(yùn)算的結(jié)果也是boolean類型。
 ③ 邏輯運(yùn)算符常使用條件判斷結(jié)構(gòu)、循環(huán)結(jié)構(gòu)中
 */
class LogicTest {
    public static void main(String[] args) {
        //*******************************************************
        /*
            區(qū)分：& 和 &&
            1、相同點(diǎn)：兩個(gè)符號(hào)表達(dá)的都是“且”的關(guān)系。只有當(dāng)符號(hào)左右兩邊的類型值均為true時(shí)，結(jié)果才為true。
            2、執(zhí)行過程：
                1）如果符號(hào)左邊是true，則&&、&&&都會(huì)執(zhí)行符號(hào)右邊的操作
                2）如果符號(hào)左邊是false，則 &  會(huì)繼續(xù)執(zhí)行符號(hào)右邊的操作
                                       && 不會(huì)執(zhí)行符號(hào)右邊的操作
            3、開發(fā)中，推薦&&
        */
        boolean b1 = true;
        b1 = false;
        int num1 = 10;
        if (b1 & (num1++ > 0)) {
            System.out.println("床前明月光");
        } else {
            System.out.println("我叫郭德綱");
        }
        System.out.println("num1 = " + num1);
        //
        boolean b2 = true;
        b2 = false;
        int num2 = 10;
        if (b2 && (num2++ > 0)) {
            System.out.println("床前明月光");
        } else {
            System.out.println("我叫郭德綱");
        }
        System.out.println("num2 = " + num2);
        //***********************************************
        /*
            區(qū)分：| 和 ||
            1、相同點(diǎn)：兩個(gè)符號(hào)表達(dá)的都是“或”的關(guān)系。只要符號(hào)兩邊存在true的情況，結(jié)果就為true。
            2、執(zhí)行過程：
                1）如果符號(hào)左邊是false，則 | 、|| 都會(huì)執(zhí)行符號(hào)右邊的操作
                2）如果符號(hào)左邊是true，則 |  會(huì)繼續(xù)執(zhí)行符號(hào)右邊的操作
                                      || 不會(huì)執(zhí)行符號(hào)右邊的操作
            3、開發(fā)中，我們推薦使用||
        */
        boolean b3 = false;
        b3 = true;
        int num3 = 10;
        if (b3 | (num3++ > 0)) {
            System.out.println("床前明月光");
        } else {
            System.out.println("我叫郭德綱");
        }
        System.out.println("num3 = " + num3);
        //
        boolean b4 = false;
        b4 = true;
        int num4 = 10;
        if (b4 || (num4++ > 0)) {
            System.out.println("床前明月光");
        } else {
            System.out.println("我叫郭德綱");
        }
        System.out.println("num4 = " + num4);
    }
}

/*
1. 定義類 LogicExer
2. 定義 main方法
3. 定義一個(gè)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的值
*/
class LogicExer {
    public static void main(String[] args) {
        int a, b;
        a = b = 20;
        boolean bo1 = (++a % 3 == 0) && (a++ % 7 == 0);
        System.out.println("a = " + a + ",bo1 = " + bo1);
        boolean bo2 = (b++ % 3 == 0) && (++b % 7 == 0);
        System.out.println("b = " + b + ",bo2 = " + bo2);
    }
}

/*
測(cè)試運(yùn)算符的使用5：位運(yùn)算符
1. << >> >>> & | ^ ~
2. 說明：
① << >> >>> & | ^ ~ ：針對(duì)數(shù)值類型的變量或常量進(jìn)行運(yùn)算，運(yùn)算的結(jié)果也是數(shù)值
②
<< ：在一定范圍內(nèi)，每向左移動(dòng)一位，結(jié)果就在原有的基礎(chǔ)上 * 2。（對(duì)于正數(shù)、負(fù)數(shù)都適用）
>> ：在一定范圍內(nèi)，每向右移動(dòng)一位，結(jié)果就在原有的基礎(chǔ)上 / 2。（對(duì)于正數(shù)、負(fù)數(shù)都適用）
>>>：向右移，左邊空出來的補(bǔ)0。（對(duì)于正數(shù)、負(fù)數(shù)都適用）
 */
class BitTest {
    public static void main(String[] args) {
        int num1 = 7;
        System.out.println("num1 << 1 : " + (num1 << 1));
        System.out.println("num1 << 2 : " + (num1 << 2));
        System.out.println("num1 << 3 : " + (num1 << 3));
        System.out.println("num1 << 28 : " + (num1 << 28));
        System.out.println("num1 << 29 : " + (num1 << 29));//過猶不及
        int num2 = -7;
        System.out.println("num2 << 1 : " + (num2 << 1));
        System.out.println("num2 << 2 : " + (num2 << 2));
        System.out.println("num2 << 3 : " + (num2 << 3));
    }
}

/**
 * 案例2：如何交換兩個(gè)int型變量的值？String呢？
 */
class BitExer {
    public static void main(String[] args) {
        int m = 10;
        int n = 20;
        System.out.println("m = " + m + ",n = " + n);
        // 交換兩個(gè)變量的值
        // 方式1：聲明一個(gè)臨時(shí)變量。（推薦）
//        int temp = m;
//        m = n;
//        n = temp;
        // 方式2:優(yōu)點(diǎn)：不需要定義臨時(shí)變量     缺點(diǎn)：難，適應(yīng)性差（不適用于非數(shù)值類型）、可能超過int范圍
//        m = m + n; //30 = 10 + 20;
//        n = m - n; //10 = 30 - 20;
//        m = m - n; //20 = 30 - 10;
        //方式3:優(yōu)點(diǎn)：不需要定義臨時(shí)變量     缺點(diǎn)：難，適應(yīng)性差（不適用于非數(shù)值類型）
        m = m ^ n;
        n = m ^ n; //(m ^ n) ^ n ---> m
        m = m ^ n;
        System.out.println("m = " + m + ",n = " + n);
    }
}

（條件表達(dá)式）？ 表達(dá)式1：表達(dá)式2

/*
測(cè)試運(yùn)算符的使用6：條件運(yùn)算符
1.（條件表達(dá)式）? 表達(dá)式1 : 表達(dá)式2
2. 說明：
① 條件表達(dá)式的結(jié)果是boolean類型。
② 如果條件表達(dá)式的結(jié)果是true，則執(zhí)行表達(dá)式1。否則，執(zhí)行表達(dá)式2。
③ 表達(dá)式1 和 表達(dá)式2 需要是相同的類型或能兼容的類型。
*/
class ConditionTest {
    public static void main(String[] args) {
        String info = (2 > 10) ? "表達(dá)式1" : "表達(dá)式2";
        System.out.println(info);
        double result = (2 > 1) ? 1 : 2.0;
        System.out.println(result);
    }
}

class ConditionTest {
    public static void main(String[] args) {
        //練習(xí)1：獲取兩個(gè)整數(shù)的較大值
        int m = 10;
        int n = 20;
        int max = (m > n) ? m : n;
        System.out.println("較大值為: " + max);
        //練習(xí)2：獲取三個(gè)整數(shù)的最大值
        int i = 20;
        int j = 30;
        int k = 23;
        int tempMax = (i > j) ? i : j;
        int finalMax = (tempMax > k) ? tempMax : k;
        System.out.println(finalMax);
        //合并以后的寫法：不推薦
        int finalMax1 = ((((i > j) ? i : j) > k) ? ((i > j) ? i : j) : k);
        System.out.println(finalMax1);
    }
}

/**
 * 今天是周2，10天以后是周幾？
 * <p>
 * 要求：控制臺(tái)輸出“今天是周2，10天以后是周x”。
 */
class ConditionExer {
    public static void main(String[] args) {
        int week = 2;
//        week = 4;
        week += 10;
        week %= 7;
        System.out.println("今天是周2，10天以后是周" + ((week == 0) ? "日" : week));
    }
}