一，寫在前面

二，變數和型別

1，整型變數

2，長整型變數

3，雙精度浮點型變數

4，單精度浮點型變數

5，字符型別變數

6，位元組型別變數

7，短整型變數

8，布爾型別變數

9，字串型別變數

10，變數的作用域

11，變數的命名規則

12，常量

13，理解型別轉換

14，理解數值提升

15，int 和 String 之間的相互轉換

三，運算子

1，算術運算子

2，關系運算子

3，邏輯運算子

4，位運算子

5，移位運算

6，條件運算子

7，運算子的優先級

四，注釋

1，基本規則

2，注釋規范

一，寫在前面

現在已經進入Java的基礎學習，每天多加練習可以提高自己的能力，如果你覺的寫的不錯的話，求點贊，求評論，求收藏，你的三連是我制作的最大的動力，關注我，一直會更新JavaSE的學習干貨，廢話不多少，讓我們學起來吧！！！

二，變數和型別

變數指的是程式運行時可變的量. 相當于開辟一塊記憶體空間來保存一些資料. 型別則是對變數的種類進行了劃分, 不同的型別的變數具有不同的特性.

變數和我們的記憶體緊密相關

1，整型變數

基本語法格式

int 變數名 = 初始值;

代碼示例:

  public static void main(String[] args) {
        int a = 1;
        System.out.println(a);
    }

注意事項:

1. int 表示變數的型別是一個整型

2. 變數名是變數的標識. 后續都是通過這個名字來使用變數

3. Java 中 = 表示賦值(和數學不一樣), 意思是給變數設定一個初始值.

4. 初始化操作是可選的, 但是建議創建變數的時候都顯式初始化.

5. 最后不要忘記分號, 否則會編譯失敗.

6. // 表示注釋. 注釋作為代碼的解釋說明部分, 不參與編譯運行.

    public static void main(String[] args) {
        //int a = 1;
        //System.out.println(a);
    }

在 Java 中, 一個 int 變數占 4 個位元組. 和作業系統沒有直接關系.

什么是位元組?

位元組是計算機中表示空間大小的基本單位. 計算機使用二進制表示資料. 我們認為 8 個二進制位(bit) 為一個位元組(Byte). 我們平時的計算機為 8GB 記憶體, 意思是 8G 個位元組. 其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB. 所以 8GB 相當于 80 多億個位元組.

4 個位元組表示的資料范圍是 -2^31 -> 2^31-1 , 也就大概是 -21億到 +21億.

使用以下代碼查看 Java 中的整型資料范圍:

 public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);  // int 的最大值
        System.out.println(Integer.MIN_VALUE);  // int 的最小值
    }

如果運算的結果超出了 int 的最大范圍, 就會出現溢位的情況

 public static void main(String[] args) {
        int maxValue = Integer.MAX_VALUE;
        System.out.println(maxValue+1);
        int minValue = Integer.MIN_VALUE;
        System.out.println(minValue-1);
    }

2，長整型變數

基本語法格式:

long 變數名 = 初始值;

代碼示例:

 public static void main(String[] args) {
        long num = 10L; // 定義一個長整型變數, 初始值寫作 10l 也可以(小寫的 L, 不是數字1).
        System.out.println(num) ;

    }

注意事項:

1. 基本語法格式和創建 int 變數基本一致, 只是把型別修改成 long

2. 初始化設定的值為 10L , 表示一個長整型的數字. 10l 也可以.

3. 使用 10 初始化也可以, 10 的型別是 int, 10L 的型別是 long, 使用 10 L 或者 10 l 更好一些.

Java 中 long 型別占 8 個位元組. 表示的資料范圍 -2^63 -> 2^63-1

使用以下代碼查看 Java 中的長整型資料范圍:

  public static void main(String[] args) {
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
    }

3，雙精度浮點型變數

基本語法格式

double 變數名 = 初始值;

代碼示例:

  public static void main(String[] args) {
        double num = 1.0;
        System.out.println(num);
    }

 public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a / b);
    }

在 Java 中, int 除以 int 的值仍然是 int(會直接舍棄小數部分).

如果想得到 0.5, 需要使用 double 型別計算

  public static void main(String[] args) {
        double a = 1.0;
        double b = 2.0;
        System.out.println(a / b);
    }

 public static void main(String[] args) {
            double num = 1.1;
            System.out.println(num * num);
        }

Java 中的 double 雖然也是 8 個位元組, 但是浮點數的記憶體布局和整數差別很大, 不能單純的用 2 ^ n 的形式表示資料范圍.Java 的 double 型別的記憶體布局遵守 IEEE 754 標準(和C語言一樣), 嘗試使用有限的記憶體空間表示可能無限的小數, 勢必會存在一定的精度誤差.

4，單精度浮點型變數

基本格式:

float 變數名 = 初始值;

代碼示例:

  public static void main(String[] args) {
            float num = 1.0f;    // 寫作 1.0F 也可以
            System.out.println(num);
        }

float 型別在 Java 中占四個位元組, 同樣遵守 IEEE 754 標準. 由于表示的資料精度范圍較小, 一般在工程上用到浮點數都優先考慮 double, 不太推薦使用 float，

5，字符型別變數

基本格式:

char 變數名 = 初始值;

代碼示例:

   public static void main(String[] args) {
            char ch = 'A';
            System.out.println(ch);
        }

注意事項:

1. Java 中使用單引號 + 單個字母的形式表示字符字面值.

2. 計算機中的字符本質上是一個整數. 在 C 語言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一個字符占用兩個位元組, 表示的字符種類更多, 包括中文.

   public static void main(String[] args) {
            char ch = '呵';
            System.out.println(ch);
        }

6，位元組型別變數

基本語法格式:

byte 變數名 = 初始值;

代碼示例:

  public static void main(String[] args) {
            byte value = 0;
            System.out.println(value);
        }

注意事項:

1. 位元組型別表示的也是整數. 只占一個位元組, 表示范圍較小 ( -128 -> +127 )

2. 位元組型別和字符型別互不相干.

7，短整型變數

基本語法格式:

short 變數名 = 初始值;

代碼示例:

 public static void main(String[] args) {
            short value = 0;
            System.out.println(value);
        }

注意事項:

1. short 占用 2 個位元組, 表示的資料范圍是 -32768 -> +32767

2. 這個表示范圍比較小, 一般不推薦使用.

8，布爾型別變數

基本語法格式:

boolean 變數名 = 初始值;

代碼示例:

 public static void main(String[] args) {
            boolean value = true;
            System.out.println(value);
        }

注意事項:

1. boolean 型別的變數只有兩種取值, true 表示真, false 表示假.

2. Java 的 boolean 型別和 int 不能相互轉換, 不存在 1 表示 true, 0 表示 false 這樣的用法.

3. boolean 型別有些 JVM 的實作是占 1 個位元組, 有些是占 1 個位元位，

Test.java:4: 錯誤: 二元運算子 '+' 的運算元型別錯誤 System.out.println(value + 1);

9，字串型別變數

基本語法格式:

String 變數名 = "初始值";

代碼示例:

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

注意事項:

1. Java 使用雙引號 + 若干字符的方式表示字串字面值.

2. 和上面的型別不同, String 不是基本型別, 而是參考型別(后面重點解釋).

3. 字串中的一些特定的不太方便直接表示的字符需要進行轉義

轉義字符有很多, 其中幾個比較常見的如下:

轉義字符	解釋
\n	換行
\t	水平制表符
\'	單引號
\"	雙引號
\\	斜杠

字串的 + 操作, 表示字串拼接:

public static void main(String[] args) {
            String a = "hello";
            String b = "world";
            String c = a + b;
            System.out.println(c);
        }

還可以用字串和整數進行拼接:

  public static void main(String[] args) {
            String str = "result = ";
            int a = 10;
            int b = 20;
            String result = str + a + b;
            System.out.println(result);
        }

因此我們可以很方便的使用 System.out.println 同時列印多個字串或數字

    public static void main(String[] args) {
            int a = 10;
            int b = 20;
            System.out.println("a = " + a + ",b = " + b);
        }

10，變數的作用域

也就是該變數能生效的范圍, 一般是變數定義所在的代碼塊

11，變數的命名規則

硬性指標:

1. 一個變數名只能包含數字, 字母, 下劃線

2. 數字不能開頭.

3. 變數名是大小寫敏感的. 即 num 和 Num 是兩個不同的變數

軟性指標:

1. 變數命名要具有描述性, 見名知意.

2. 變數名不宜使用拼音(但是不絕對).

3. 變數名的詞性推薦使用名詞.

4. 變數命名推薦小駝峰命名法, 當一個變數名由多個單詞構成的時候, 除了第一個單詞之外, 其他單詞首字母都大寫.

小駝峰命名示例:

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

12，常量

字面值常量

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

final 關鍵字修飾的常量

13，理解型別轉換

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

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

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

int 和 boolean 相互賦值

結論: int 和 boolean 是毫不相干的兩種型別, 不能相互賦值.

int字面值常量給 byte 賦值

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

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

使用強制型別轉換

  public static void main(String[] args) {
            int a = 0;
            double b = 10.5;
            a = (int)b;
            System.out.println(a);
        }

結論: 使用 (型別) 的方式可以將 double 型別強制轉成 int.

1. 強制型別轉換可能會導致精度丟失. 如剛才的例子中, 賦值之后, 10.5 就變成 10 了, 小數點后面的部分被忽略.

2. 強制型別轉換不是一定能成功, 互不相干的型別之間無法強轉

型別轉換小結

1. 不同數字型別的變數之間賦值, 表示范圍更小的型別能隱式轉換成范圍較大的型別.

2. 如果需要把范圍大的型別賦值給范圍小的, 需要強制型別轉換, 但是可能精度丟失.

3. 將一個字面值常量進行賦值的時候, Java 會自動針對數字范圍進行檢查.

14，理解數值提升

int 和 long 混合運算

public static void main(String[] args) {
            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 的運算

   public static void main(String[] args) {
            byte a = 10;
            byte b = 20;
            byte c = a + b;
            System.out.println(c);

            // 編譯報錯Test.java:5: 錯誤: 不兼容的型別: 從int轉換到byte可能會有損失
        }

結論:

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

正確的寫法:

public static void main(String[] args) {
            byte a = 10;
            byte b = 20;
            byte c = (byte)(a + b);
            System.out.println(c);
        }

型別提升小結:

1. 不同型別的資料混合運算, 范圍小的會提升成范圍大的.

2. 對于 short, byte 這種比 4 個位元組小的型別, 會先提升成 4 個位元組的 int , 再運算.

15，int 和 String 之間的相互轉換

int 轉成 String

    public static void main(String[] args) {
            int num = 10;
            // 方法1
            String str1 = num + "";
            // 方法2
            String str2 = String.valueOf(num);
            System.out.println(str1);
            System.out.println(str2);
        }

String 轉成 int

   public static void main(String[] args) {
            String str = "100";
            int num = Integer.parseInt(str);
            System.out.println(str);
        }

三，運算子

1，算術運算子

基本四則運算子

 + - * / %

a）int / int 結果還是 int, 需要使用 double 來計算

 public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a / b);
    }

b)0 不能作為除數

   public static void main(String[] args) {
        int a = 1;
        int b = 0;
        System.out.println(a / b);
    }

c) % 表示取余, 不僅僅可以對 int 求模, 也能對 double 來求模

System.out.println(11.5 % 2.0);

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

public static void main(String[] args) {
        int a = 10;
        a += 1; // 等價于 a = a + 1
        System.out.println(a);
    }

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

  public static void main(String[] args) {
        int a = 10;
        int b = ++a;
        System.out.println(b);
        int c = a++;
        System.out.println(c);
    }

結論:

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

2. 如果取運算式的回傳值, 則前置自增的回傳值是自增之后的值, 后置自增的回傳值是自增之前的值.

2，關系運算子

關系運算子主要有六個

== != < > =

public static void main(String[] args) {
        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型

3，邏輯運算子

邏輯運算子主要有三個

&& || !

注意: 邏輯運算子的運算元(運算元往往是關系運算子的結果)和回傳值都是 boolean

邏輯與 &&

規則: 兩個運算元都為 true, 結果為 true, 否則結果為 false.

 public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a < b && b < c);
    }

邏輯或 ||

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

 public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a < b || b < c);
    }

邏輯非 !

規則: 運算元為 true, 結果為 false; 運算元為 false, 結果為 true(這是個單目運算子, 只有一個運算元)

  public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(!(a < b));
    }

短路求值

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

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

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

  public static void main(String[] args) {
        //我們都知道, 計算 10 / 0 會導致程式拋出例外. 
        //但是代碼卻能正常運行, 說明 10 / 0 并沒有真正被求值.
        System.out.println(10 > 20 && 10 / 0 == 0); // 列印 false
        System.out.println(10 < 20 || 10 / 0 == 0); // 列印 true
    }

4，位運算子

位運算子主要有四個:

& | ~ ^

按位與 &: 如果兩個二進制位都是 1, 則結果為 1, 否則結果為 0

 public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a & b);
    }

按位或 |: 如果兩個二進制位都是 0, 則結果為 0, 否則結果為 1

   public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a|b);
    }

注意: 當 & 和 | 的運算元為整數(int, short, long, byte) 的時候, 表示按位運算, 當運算元為 boolean 的時候, 表示邏輯運算.

按位取反 ~: 如果該位為 0 則轉為 1, 如果該位為 1 則轉為 0

  public static void main(String[] args) {
        int a = 0xf;
        System.out.printf("%x\n", ~a);

    }

注意:

1. 0x 前綴的數字為十六進制數字. 十六進制可以看成是二進制的簡化表示方式. 一個十六進制數字對應 4 個二進制位.

2. 0xf 表示 10 進制的 15, 也就是二進制的 1111

3. printf 能夠格式化輸出內容, %x 表示按照十六進制輸出.

4. \n 表示換行符

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

 public static void main(String[] args) {
        int a = 0x1;
        int b = 0x2;
        System.out.printf("%x\n", a ^ b);
    }

5，移位運算

移位運算子有三個:

<< >>

左移 <<: 最左側位不要了, 最右側補 0.

 public static void main(String[] args) {
        int a = 0x10;
        System.out.printf("%x\n", a << 1);
    }

右移 >>: 最右側位不要了, 最左側補符號位 (正數補0, 負數補1)

  public static void main(String[] args) {
        int a = 0x10;
        System.out.printf("%x\n", a >> 1);
        // 運行結果(注意, 是按十六進制列印的)
        //8
        int b = 0xffff0000;
        System.out.printf("%x\n", b >> 1);
        // 運行結果(注意, 是按十六進制列印的)
        //ffff8000
    }

6，條件運算子

運算式1 ? 運算式2 : 運算式3

當運算式1 的值為 true 時, 整個運算式的值為運算式2 的值; 當運算式1 的值為 false 時, 整個運算式的值為運算式 3 的值.

 public static void main(String[] args) {
        // 求兩個整數的最大值
        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println(max);
    }

7，運算子的優先級

先看一段代碼

public static void main(String[] args) {
        System.out.println(1 + 2 * 3);
    }

 public static void main(String[] args) {
        System.out.println(10 < 20 && 20 < 30);

    }

此時明顯是先計算的 10 < 20 和 20 < 30, 再計算 &&. 否則 20 && 20 這樣的操作是語法上有誤的(&& 的運算元只能是 boolean).

小結

1. % 操作再 Java 中也能針對 double 來計算.

2. 需要區分清楚前置自增和后置自增之間的區別.

3. 由于 Java 是強型別語言, 因此對于型別檢查較嚴格, 因此像 && 之類的運算運算元必須是 boolean.

4. 要區分清楚 & 和 | 什么時候是表示按位運算, 什么時候表示邏輯運算

四，注釋

1，基本規則

單行注釋：// 注釋內容（用的最多）

多行注釋：/* 注釋內容*/（不推薦）

檔案注釋： /** 檔案注釋 */（常見于方法和類之上描述方法和類的作用)，可用來自動生成檔案

2，注釋規范

1. 內容準確: 注釋內容要和代碼一致, 匹配, 并在代碼修改時及時更新.

2. 篇幅合理: 注釋既不應該太精簡, 也不應該長篇大論.

3. 使用中文: 一般中國公司都要求使用中文寫注釋, 外企另當別論

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/316596.html

標籤：java

上一篇：cgb2108-day10

下一篇：（聯想記憶法）JAVA如何巧妙的記憶位運算子號！！小朋友都能學會

02 JavaSE—資料型別與運算子

一，寫在前面

二，變數和型別

1，整型變數

2，長整型變數

3，雙精度浮點型變數

4，單精度浮點型變數

5，字符型別變數

6，位元組型別變數

7，短整型變數

8，布爾型別變數

9，字串型別變數

10，變數的作用域

11，變數的命名規則

12，常量

13，理解型別轉換

14，理解數值提升

15，int 和 String 之間的相互轉換

三，運算子

1，算術運算子

2，關系運算子

3，邏輯運算子

4，位運算子

5，移位運算

6，條件運算子

7，運算子的優先級

四，注釋

1，基本規則

2，注釋規范