初識Java以及一些常見的資料型別與運算子(下)

初識Java以及一些常見的資料型別與運算子(下)

1.布爾型別變數

基本語法格式：

boolean 變數名 = 初始值

代碼示例：

boolean flg=true;
System.out.println(flg);
        
boolean flg2=false;
System.out.println(flg2);

注意事項：

1. boolean型別的變數只有兩種取值，true表示真，false表示假，
2. Java的boolean型別和int不能相互轉換，不存在1表示true，0表示false這樣的用法，
3. boolean型別有些JVM的實作是占一個位元組，有些是占1個位元位，這個沒有明確規定，

2.字串型別變數（重點）

把一些字符放到一起就構成了字串

基本語法格式：

String 變數名 = "初始值"；

代碼示例：

String name = "zhangsan";
System.out.println(name);

注意事項：

1. Java使用雙引號+若干字符的方式表示字串字面值，
2. 和上面的型別不同，String不是基本型別，而是參考型別（后面重點解釋），
3. 字串中的一些特定的不太方便直接表示的字符需要進行轉義，

轉義字符示例：

//創建一個字串 My name is "張三"
String name = "My name is \"張三\"";

轉義字符有很多，其中比較常見的如下：

字串+操作，表示字串拼接：

public class TestDemo {
    public static void main(String[] args) {
        String name = "zhangsan";
        System.out.println(name);

        //注意問題：
        System.out.println("hello"+"world");
        System.out.println("hello"+10+20);//其他資料型別和字串使用+拼接，結果就是一個字串
        System.out.println(10+20+"hello");//30hello
        System.out.println("hello"+(10+20));
        System.out.println(10+""+20+"hello");

        //a=10,b=20
        System.out.println("a="+10+",b="+20);
    }

以上代碼說明，當一個+運算式存在字串的時候，都是執行字串的拼接行為，因此我們可以很方便的使用System.out.println同時列印多個字串或數字，

3.變數的作用域

也就是變數能生效的范圍，一般是變數定義所在的代碼塊（大括號）

class Test{
    public static void main(String[] args) {
        {
            int x = 10;
            System.out.println(x);//編譯通過
        }
        System.out.println(x);//編譯失敗，找不到變數x
    }
}

4.變數的命名規則

硬性指標：

1. 一個變數名只能包含數字，字母，下劃線，美元符號（$），
2. 數字不能開頭，
3. 變數名大小寫敏感的，即num和Num是兩個不同的變數，

注意：雖然語法上也允許使用中文/美元符號（$）命名變數，但是強烈不推薦這樣做，

軟性指標：

1. 變數名要具有描述性，見名知意，
2. 變數名不宜使用拼音（但是不絕對），
3. 變數名的詞性推薦使用名詞，
4. 變數命名推薦小駝峰命名法，當一個變數名由多個單詞構成的時候，除了第一個單詞之外，其他單詞首字母大寫，

小駝峰命名示例：

int maxValue = 100;
String studentName = "張三";

5.常量

上面討論的都是各種規則的變數，每種型別的變數也對應著一種相同型別的常量，

常量指的是運行時型別不能發生改變，

常量主要有以下兩種體現形式：

5.1 字面值常量

10              //int 字面值常量（十進制）
010             //int 字面值常量（八進制）由數字0開頭
0x10            //int 字面值常量（十六進制）由數字0x開頭
10L             //long 字面值常量，也可以寫作10l（小寫的L）
1.0             //double 字面值常量，也可以寫作1.0d或者1.0D
1.5e2           //double 字面值常量，科學計數法表示，相當于1.5*10^2
1.0f            //float 字面值常量，也可以寫作1.0F
true            //boolean 字面值常量，同樣的還有false
'a'             //char 字面值常量，單引號中只能有一個字符
"abc"           //String 字面值常量，雙引號中可以有多個字符

5.2 final關鍵字修飾的常量

final int a = 10;
a = 20;   //編譯出錯，提示無法為最終變數a分配值

常量不能在程式運行程序中發生修改，

6.型別轉換

Java作為一個強型別編程語言，當不同型別之間的變數相互賦值的時候，會有嚴格的校驗，

先看以下幾個代碼場景：

int 和long/double相互賦值

int a = 10;
long b =20;
a = b;     //編譯出錯，提示可能會損失精度
b = a;     //編譯通過

int a = 10;
double b = 1.0;
a = b;     //編譯出錯，提示可能會損失精度
b = a;     //編譯通過

long 表示的范圍更大，可以將int賦值給long，但是不能將long賦值給int，

double 表示的范圍更大，可以將int賦值給double，但是不能將double賦值給int，

結論：不同數字型別的變數之間賦值，表示范圍更小的型別能隱式轉換成范圍較大的型別，反之則不行，

int 和boolean相互賦值

int a = 10;
boolean b = true;
b = a;     //編譯出錯，提示不兼容的型別
a = b;     //編譯出錯，提示不兼容的型別

int 字面值常量給byte賦值

byte a = 100;     //編譯通過
byte b = 256;     //編譯報錯，提示從int轉換到byte可能會有損失

注意：byte表示的資料范圍是-128 -> +127，256已經超過范圍，而100還在范圍之內，

結論：使用字面值常量賦值的時候，Java會自動進行一些檢查校驗，判斷賦值是否合理，

使用強制型別轉換

int a = 0;
double b = 10.5;
a = (int)b;

int a = 10;
boolean b = false;
b = (boolean)a;    //編譯出錯，提示不兼容的型別，

結論：使用（型別）的方式可以將double型別強制轉換成int，但是

1. 強制型別轉換可能會導致精度丟失，如剛才的例子中，賦值之后，10.5就變成10了，小數點后面的部分丟失了
2. 強制型別轉換不是一定能成功，互不相干的型別之間無法強轉，

型別轉換小結

1. 不同數字型別的變數之間賦值，表示范圍更小的型別能隱式轉換成范圍較大的型別，
2. 如果需要把范圍大的型別賦值給范圍小的，需要強制型別轉換，但是可能精度丟失，
3. 將一個字面值常量進行賦值的時候，Java會自動針對數字范圍進行檢查，

7.數值提升

int 和long混合運算

int a = 10;
long b = 20;
int c = a + b;    //編譯出錯，提示將long轉換成int會丟失精度
long d = a + b;

結論：當int和long混合運算的時候，int會提升成long，得到的結果仍然是long型別，需要使用long型別來接收結果，如果非要用int來接收結果，就需要使用強制型別轉換，

byte 和byte的運算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);    //編譯報錯，不兼容的型別：從int轉換到byte可能會有損失

結論：byte和byte都是相同型別，但是出現編譯報錯，原因是，雖然a和b都是byte，但是計算a+b都是會先提升成int，再進行計算，得到的結果也是int,這時賦給c，就會出現上述錯誤，

由于計算機的CPU通常是按照4個位元組為單位從記憶體中讀寫順序，為了硬體上實作方便，諸如byte和short這種小于4個位元組的型別，會先提升成int，再參與計算，

正確的寫法：

byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
System.out.println(c);

型別提升小結：

1. 不同型別的資料混合運算，范圍小的會提升成范圍大的，
2. 對于short,byte這種比4個位元組小的型別，會先提升成4個位元組的int，再運算，

8.int和String之間的相互轉換

int轉成String

int num = 10;
//方法1
String str1 = num + "";
//方法2
String str2 = String.valueOf(num);

String轉成int

String str = "100";
int num = Integer.parseInt(str);

9.算術運算子

基本四則運算子+ - * / %

規則比較簡單，值得注意的是除法：

1. int/int結果還是int，需要使用double來計算，

int a = 1;
int b = 2;
System.out.println(a / b);
//結果為0

2. 0不能作為除數

int a = 1;
int b = 0;
System.out.println(a / b);
//運行結果
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at TestDemo.main(TestDemo.java:12)

3. %表示取余，把僅僅可以對int求模，也能對double來求模

System.out.println(11.5%2);
//運行結果
1.5

增量賦值運算子+= -= *= /= %=

int a = 10;
a += 1;    //等價于a = a + 1;
System.out.println(a);

short s = 10;
s = (short)(s + 9);    //直接寫成s = s + 9;會報錯，因為short型別會強制轉換成int型別
s += 9;    //自動強制型別轉換
System.out.println(s);

自增/自減運算子++ --

int a=10;
int i1=a++;    //先使用 后++
System.out.println(a);
System.out.println(i1);

int c=10;
int i2=++c;    //先++ 后使用
System.out.println(c);
System.out.println(i2);
//運行結果
11 10 11 11

結論：

1. 如果不取自增運算的運算式的回傳值，則前置自增和后置自增沒有區別，
2. 如果取自增運算的運算式的回傳值，則前置自增的回傳值是自增之后的值，后置自增的回傳值是自增之前的值，

10.關系運算子

關系運算子主要有六個：

== ！= < > <= >=

int a = 10;
int b = 20;
System.out.println(a == b);
System.out.println(a != b);
System.out.println(a < b);
System.out.println(a > b);
System.out.println(a <= b);
System.out.println(a >= b);

注意：關系運算子的運算式回傳值都是boolean型別，

11.邏輯運算子

邏輯運算子主要有三個：

&& || !

注意：邏輯運算子的運算元（運算元往往是關系運算子的結果）和回傳值都是boolean，

邏輯與 &&

規則：兩個運算元都為true,結果為true，否則結果為false，

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c);

邏輯或 ||

規則：兩個運算元都為false,結果為false，否則結果為true，

int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b || b < c);

邏輯非 ！

規則：運算元為true,結果為false，運算元為false，結果為true（這是個單目運算子，只有一個運算元），

int a = 10;
int b = 20;
System.out.println(!(a < b));

短路求值

&&和||遵守短路求值的規則

System.out.println(10 > 20 && 10 / 0 == 0);    //列印 false
System.out.println(10 < 20 || 10 / 0 == 0);    //列印 true

我們都知道，計算10 / 0會導致程式拋出例外，但是上面的代碼卻能正常運行，說明10 / 0并沒有真正參與運算，

結論：

1. 對于&&，如果左側運算式值為false，則運算式的整體一定是false，無需計算右側運算式，
2. 對于||，如果左側運算式值為true，則運算式的整體一定是true，無需計算右側運算式，

12.位運算子

Java中對資料的操作的最小單位不是位元組，而是二進制位，

位運算子主要有四個：

& | ~ ^

位操作表示按二進制位運算，計算機中都是使用二進制來表示資料的（01構成的序列），

**按位與 &：**如果兩個二進制位都是1，則結果為1，否則結果為0，

int a = 10;
int b = 20;
System.out.println(a & b);

進行按位運算，需要先把10和20轉成二進制，分別為1010和10100

**按位或 |：**如果兩個二進制位都是0，則結果為0，否則結果為1，

int a = 10;
int b = 20;
System.out.println(a | b);

運算方式和按位與類似，

**按位取反 ~：**如果該位為0則轉為1，如果該位為1則轉為0，

int a = 0xf;
System.out.printlf("%x\n",~a);

**按位異或 ^：**如果兩個數字的二進制位相同，則結果為0，相異則結果為1，

int a = 0x1;
int b = 0x2;
System.out.printf("%x\n",a ^ b);

13.條件運算子

條件運算子只有一個：

運算式1 ? 運算式2 ： 運算式3

當運算式1的值為true時，整個運算式的值為運算式2的值；當運算式1的值為false時，整個運算式的值為運算式3的值，

也是Java中唯一一個三目運算子，是條件判斷陳述句的簡化寫法，

//求兩個數的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

14.小結

1. %操作在Java中也能針對double來計算，
2. 需要區分清楚前置自增和后置自增之間的區別，
3. 由于Java是強型別語言，因此對于型別檢查較嚴格，因此像&&之類的運算運算元必須是boolean，
4. 要區分清楚&和|什么時候是表示按位運算，什么時候表示邏輯運算，

整體來看，Java的運算子的基本規則和C語言基本一致，
為1，

int a = 0x1;
int b = 0x2;
System.out.printf("%x\n",a ^ b);

13.條件運算子

條件運算子只有一個：

運算式1 ? 運算式2 ： 運算式3

當運算式1的值為true時，整個運算式的值為運算式2的值；當運算式1的值為false時，整個運算式的值為運算式3的值，

也是Java中唯一一個三目運算子，是條件判斷陳述句的簡化寫法，

//求兩個數的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

14.小結

1. %操作在Java中也能針對double來計算，
2. 需要區分清楚前置自增和后置自增之間的區別，
3. 由于Java是強型別語言，因此對于型別檢查較嚴格，因此像&&之類的運算運算元必須是boolean，
4. 要區分清楚&和|什么時候是表示按位運算，什么時候表示邏輯運算，

整體來看，Java的運算子的基本規則和C語言基本一致，