java八大基本資料型別與運算子
- ??變數和型別
- ?? 整型變數(重點)
- ??長整型變數
- ??雙精度浮點型變數(重點)
- ??單精度浮點型變數
- ??字符型別變數
- ??位元組型別變數
- ??短整型變數
- ??布爾型別變數
- ??字串型別變數(重點)
- ??變數的作用域和變數的命名規則
- ??常量
- ??字面值常量
- ??final 關鍵字修飾的常量
- ??型別轉換與數值提升
- 📖運算子
- 📖算術運算子
- 📖關系運算子
- 📖邏輯運算子(重點)
- 📖位運算子
- 📖移位運算(了解)
- 📖條件運算子
- 📖小結
??變數和型別
變數指的是用于存盤可變資料的一個量，程式運行前創建，開辟一塊記憶體空間來保存一些資料.型別則是對變數的種類進行了劃分, 不同的型別的變數用于存盤不同的資料，具有不同的屬性.,這些變數是在計算機的記憶體儲器上創建的，程式的運行也是在記憶體儲器上運行的，而我們平時所產生的音頻，圖片視頻等內容是存盤在計算機的外存盤器上的，外存盤器簡單的說就是我們的硬碟，u盤，光碟等器件，現在的計算機都是依據馮諾依曼體系來作業的，下面我們簡單的來看一下馮諾依曼體系結構：
基本資料型別介紹：
| 資料型別 | 所占的位元組數 | 默認值 | 取值范圍 | 封裝器類 |
|---|---|---|---|---|
| byte | 1 | 0 | -2^7— 2^7-1 | Byte |
| short | 2 | 0 | -2^15— 2^15-1 | Short |
| int | 4 | 0 | -2^31— 2^31-1 | Integer |
| long | 8 | 0 | -2^63— 2^63-1 | Long |
| float | 4 | 0.0 | 3.4e-45~1.4e38 | Float |
| double | 8 | 0.0 | 4.9e-324~1.8e308 | Double |
| char | 1 | 空 | 0—2^16-1 | Character |
| boolean | JVM標準并未說明大小，沒有明確的大小 | false | true 或者false | Boolean |
上面的表格要記住，下面的這張圖更要截圖保存了（哈哈）
?? 整型變數(重點)
基本語法格式
int 變數名 = 初始值;
代碼示例:
int num = 10; // 定義一個整型變數
System.out.println(num) ;
注意事項:
- int 表示變數的型別是一個整型
- 變數名是變數的標識. 后續都是通過這個名字來使用變數
- Java 中 = 表示賦值(和數學不一樣), 意思是給變數設定一個初始值.
- 初始化操作是可選的, 但是建議創建變數的時候都顯式初始化.區域變數在使用的時候一定要初始化不初始化編譯不能通過，
- 在 Java 中, 一個 int 變數占 4 個位元組. 和使用的機器位數操沒有直接關系，含Int型變數的代碼，只要在安裝jvm的機器上都能跑起來，，這樣java的可移植性就很強，
什么是位元組?
位元組是計算機中表示空間大小的基本單位.計算機使用二進制表示資料. 我們認為 8 個二進制位(bit) 為一個位元組(Byte).其中 1KB
= 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB. 在 Java 中, 一個 int 變數占 4 個位元組，java中沒有無符號的整形，都是有符號的（如short,long,byte），
使用相應型別的包裝類可以查看相應的資料的取值范圍，包裝類其實就是原始資料型別的一個升級版，它們定義的資料型別是一致的， Java 中的整型資料范圍可通過如下代碼列印:
System.out.println(Integer.MAX_VALUE); // int 的最大值
System.out.println(Integer.MIN_VALUE); // int 的最小值
🎇🔍??給任何的資料型別賦值的時候字面值是一定不能超過這種型別的取值范圍，否則會發生溢位產生編譯錯誤，其次任意型別的資料，最大值加一就變成了最小值，最小值加一也就變成了最大值，這是一個規律可以記住，記憶的時候可以參照我上面畫的圖，
public static void main(String[] args) {
int maxValue = Integer.MAX_VALUE;
System.out.println(maxValue);//最大值
int a=Integer.MAX_VALUE+1;;
System.out.println(a);
int b=2147483647+1;
//int c=2147483648;代碼編譯錯誤
System.out.println(maxValue);
int minValue = Integer.MIN_VALUE;
System.out.println(minValue-1);
}
運行結果如下：
??長整型變數
基本語法格式:
long 變數名 = 初始值;
代碼示例：
long num = 10L; // 定義一個長整型變數, 初始值寫作 10l 也可以(小寫的 L, 不是數字1).
System.out.println(num) ;
注意事項:
- 基本語法格式和創建 int 變數基本一致, 只是把型別修改成 long
- 初始化設定的值為 10L , 表示一個長整型的數字. 10l 也可以.
- 使用 10 初始化也可以, 10 的型別是 int, 10L 的型別是 long, 使用 10 L 或者 10 l 更好一些.
Java 中的長整型資料范圍，這個資料范圍遠超過 int 的表示范圍. 足夠絕大部分的場景使用.
System.out.println(Long.MAX_VALUE);
System.out.println(Long.MIN_VALUE)
// 運行結果
9223372036854775807
-9223372036854775808
??雙精度浮點型變數(重點)
基本語法格式
double 變數名 = 初始值;
代碼示例:
double num = 1.0;
System.out.println(num)
在 Java 中, int 除以 int 的值仍然是 int(會直接舍棄小數部分).
int a = 1;
int b = 2;
System.out.println(a / b);
// 執行結果
0
如果想得到小數 , 需要使用 double 型別計算
double a = 1.0;
double b = 2.0;
System.out.println(a / b);
// 執行結果
0.5
java 中的 double 雖然也是 8 個位元組, 但是浮點數的記憶體布局和整數差別很大, 不能單純的用 2 ^ n 的形式表示資料范圍.**float精確表示6位小數,doubie精確表示到小數點后11位，**小數只能精確到幾位，超過精確的值就是不精確的，
double num = 1.1;
System.out.println(num * num)
// 執行結果
1.2100000000000002
??單精度浮點型變數
基本格式:
float 變數名 = 初始值;
代碼示例：
float num = 1.0f; // 寫作 1.0F 也可以
System.out.println(num);
float 型別在 Java 中占四個位元組, 同樣遵守 IEEE 754 標準. 由于表示的資料精度范圍較小, 一般在工程上用到浮點數都優先考慮 double, 不太推薦使用 float.
💣💥?float型別的資料，后面表示資料型別的的字母不能省略，浮點型資料的默認型別為double，如果省略,在定義的時候出現型別差異就會報錯，而整形的默認型別為int，后面的字母可以省略，如下代碼；
float num = 1.0; //編譯出錯，可寫成1.0f或者1.0F
System.out.println(num);
long num=4;
??字符型別變數
基本格式：
char 變數名 = 初始值;
代碼示例：
char ch = 'A';
char cp="好"
注意事項:
- Java 中使用 單引號 + 單個字母 的形式表示字符字面值.
- 計算機中的字符本質上是一個整數. 在 C 語言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一個字符占用兩個位元組, 表示的字符種類更多, 包括中文，
- 💣💥?char在java中表示一種無符號型別，也就是說不能存負數，沒有什么unsigned型別,都是正數，
??位元組型別變數
基本語法格式:
byte 變數名 = 初始值;
代碼示例:
byte value = 0;
System.out.println(value);
注意事項:
💣💥?1. 位元組型別表示的也是整數. 只占一個位元組, 表示的大小和c語言的char型別表示的范圍是一樣的，
2. 位元組型別和字符型別互不相干
??短整型變數
基本語法格式:
short 變數名 = 初始值;
代碼示例：
short value = 0;
System.out.println(value);
注意事項:
- short 占用 2 個位元組, 表示的資料范圍是 -32768 -> +32767（-2^15 —2^15），
- 這個表示范圍比較小, 一般不推薦使用，實際中int的使用大于short的使用，
??布爾型別變數
基本語法格式:
boolean 變數名 = 初始值;
代碼示例：
boolean value = true;
System.out.println(value);
注意事項:
> 1. boolean 型別的變數只有兩種取值, true 表示真, false 表示假，它也不能和其他的型別進行轉換，
2. Java 的 boolean 型別和 int 不能相互轉換, 不存在 1 表示 true, 0 表示 false 這樣的用法.
3. boolean 型別有些 JVM 的實作是占 1 個位元組, 有些是占 1 個位元位, 這個沒有明確規定
??字串型別變數(重點)
把一些字符放到一起就構成了字串，它屬于參考資料型別，
基本語法格式：
String 變數名 = "初始值";
//在這里的變數名，是一個參考變數，存的是這個字串的地址，該變數指向這個字串物件
代碼示例：
String name = "zhangsan";
System.out.println(name);
注意事項:
- Java 使用 雙引號 + 若干字符 的方式表示字串字面值.
- 和上面的型別不同, String 不是基本型別, 而是參考型別(后面博客重點解釋).
- 字串中的一些特定的不太方便直接表示的字符需要進行轉義.
| 轉義字符 | 解釋 |
|---|---|
| \n | 換行 |
| \t | 水平制表符 |
| \’ | 單引號 |
| \" | 雙引號 |
| \\ | 反斜桿 |
常用的轉義字符：
轉義字符示例：
// 創建一個字串 My name is "張三"
String name = "My name is \"張三\"";//中間的兩個引號被決議為轉義字符，最外面的兩個引號包含一串字串
💣💥?字串的 + 操作, 表示字串拼接，字串和任意型別的資料使用加號拼接后其結果也是字串
String a = "hello";
String b = "world";
String c = a + b;
System.out.println(c);
結果為：
💣💥?還可以用字串和整數進行拼接:當一個 + 運算式中存在字串的時候, 都是執行字串拼接行為：
String str = "result = ";
int a = 10;
int b = 20;
String result = str + a + b+"hello";
System.out.println(result);
// 結果為result = 1020hello
💣💥?在進行拼接的時候要注意，如果數字前面沒有字符，那么數字是會執行加法運算后，再進行拼接的
String str = "result = ";
int a = 10;
int b = 20;
String result = a + b+str + "hello";
System.out.println(result);
String result1="world"+a + b+str + "hello";
System.out.println(result1);
如圖：
??變數的作用域和變數的命名規則
也就是該變數能生效的范圍, 一般是變數定義所在的代碼塊 (大括號)，如果在代碼塊內部定義，在外部訪問就會出錯，區域變數定義在函式體內，它的作用范圍就是這個函式體內部，
class Test {
public static void main(String[] args) {
{
int x = 10;
System.out.println(x); // 編譯通過;
}
System.out.println(x); // 編譯失敗, 找不到變數 x.
}
}
命名規則： 硬性指標:
- 一個變數名只能包含數字, 字母, 下劃線,美元符號
- 數字不能開頭.
- 變數名是大小寫敏感的. 即 num 和 Num 是兩個不同的變數. 注意: 雖然語法上也允許使用中文/美元符($)命名變數, 但是 強烈 不推薦這樣 軟性指標:
- 變數命名要具有描述性, 見名知意.
- 變數名不宜使用拼音(但是不絕對).
- 變數名的詞性推薦使用名詞.
- 變數命名推薦 小駝峰命名法, 當一個變數名由多個單詞構成的時候, 除了第一個單詞之外, 其他單詞首字母都大寫，大駝峰命名是用來命名類介面的，每個單詞的首字母都是大寫的： 大小駝峰命名示例:
int zuidazhi//不能這樣命名
int maxValue = 100;
String studentName = "張三";
public TestDemo//類命名
??常量
上面討論的都是各種規則的變數, 每種型別的變數也對應著一種相同型別的常量，如int型別對應的常量就是就是int型別的常量.常量指的是運行時型別不能發生改變，
常量主要有以下兩種體現形式:
??字面值常量
- 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 關鍵字修飾的常量
java中用final修飾一個變數，將其轉換為常量，常量在程式運行程序中不可以修改，💣💥?一般也用大寫字母表示變數名，
final int a = 10;
a = 20; // 編譯出錯. 提示 無法為最終變數a分配值
final int SIZE ;
SIZE = 99;
System.out.println(SIZE);
??型別轉換與數值提升
型別轉換
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; // 編譯出錯, 提示不兼容的型別
結論: boolean 型別的變數只有兩種取值, true 表示真, false 表示假. int 和 boolean 是毫不相干的兩種型別, 不能相互賦值
int字面值常量 給 byte 賦值
byte a = 100; // 編譯通過
byte b = 256; // 編譯報錯, 提示 從int轉換到byte可能會有損失
注意: byte 表示的資料范圍是 -128 —+127, 256 已經超過范圍, 而 100 還在范圍之內.
結論: 使用字面值常量賦值的時候, Java 會自動進行一些檢查校驗, 判定賦值是否合理.
int 和 String 之間的相互轉換
int 轉成 String
int num = 10;
// 方法1
String str1 = num + "";
// 方法2
String str2 = String.valueOf(num);//使用valueOf函式轉換
String 轉成 int
String str = "100";
int num = Integer.parseInt(str);//使用parseInt函式轉換
System.out.println(num);//結果為100
使用強制型別轉換
int a = 0;
double b = 10.5;
a = (int)b;
int a = 10;
boolean b = false;
b = (boolean)a; // 編譯出錯, 提示不兼容的型別.
結論:
- 使用 (型別) 的方式可以將 double 型別強制轉成 int. 但是
強制型別轉換可能會導致精度丟失. 如剛才的例子中, 賦值之后, 10.5 就變成 10 了, 小數點后面的部分被忽略.- 強制型別轉換不是一定能成功, 互不相干的型別之間無法強轉(如boolean何其他型別之間的轉換)
型別轉換小結
1.如果兩種資料表示的精度不一樣時，要向表示精度大的資料型別轉換，不能向精度小的方向轉換，
3. 不同數字型別的變數之間賦值, 表示范圍更小的型別能隱式轉換成范圍較大的型別.
4. 如果需要把范圍大的型別賦值給范圍小的, 需要強制型別轉換, 但是可能精度丟失.
5. 將一個字面值常量進行賦值的時候, Java 會自動針對數字范圍進行檢查.
數值提升
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 來接收結果, 就需要使用強制型別轉換，轉換為Int型別
byte 和 byte 的運算
byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
結論: byte 和 byte 都是相同型別, 但是出現編譯報錯. 原因是, 雖然 a 和 b 都是 byte, 但是計算 a + b 會先將 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);
型別提升小結:
- 不同型別的資料混合運算, 范圍小的會提升成范圍大的.
- 對于 short, byte 這種比 4 個位元組小的型別, 會先提升成 4 個位元組的 int , 再運算
📖運算子
📖算術運算子
基本四則運算子 + - * / %
int / int 結果還是 int,如需得到小數要使用 double 來計算
int a = 1;
int b = 2;
System.out.println(a / b);
// 結果為 0
% 表示取余, 不僅僅可以對 int 求模, 也能對 double 來求模
System.out.println(11.5 % 2.0);
// 運行結果
//1.5
*🔺?👀增量賦值運算子 += -= = /= %=，復合運算子有個特點就是自動的幫我們進行型別轉換，
如+=
int a = 10;
a += 1; // 等價于 a = a + 1
System.out.println(a);//結果11
short c=2;
c+=1;//自動進行型別轉換=》c=(short)(c+1);
🔺?👀自增/自減運算子 ++ –
前置++是先加1再使用，后置++是先使用在自增1的（前置后置就是看++放在變數的前后位置）和語言是一樣的
//后置
public static void main(String[] args) {
int a = 10;
int b = a++;// b = a a = a+1;
System.out.println(a);//11
System.out.println(b);//10
//前置
/* int a = 10;*/
/* int b = ++a;//a = a+1 b = a;*/
/* System.out.println(a);//11*/
/* System.out.println(b);//11*/
}
🔺?👀但后面有一個特例如，如下代碼的結果和c不一樣，結果為10，c里面是11（厲害吧，解釋這個問題需要看匯編代碼，我們這里就不討論了）
public static void main(String[] args) {
int a = 10;
a = a++;
System.out.println(a);
}
📖關系運算子
關系運算子主要有六個:：== != < > <= >=
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 型別之后我們寫一些條件陳述句時，判斷條件都是關系運算后的boolean型別的值，而不是0和非0的區別了，
📖邏輯運算子(重點)
邏輯運算子主要有三個:
&& || !
邏輯與&&
規則: 兩個運算元都為 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);
短路求值
- 對于 && , 如果左側運算式值為 false, 則運算式的整體的值一定是 false, 無需計算右側運算式
- 對于 ||, 如果左側運算式值為 true, 則運算式的整體的值一定是 true, 無需計算右側運算式.
//我們都知道, 計算 10 / 0 會導致程式拋出例外. 但是上面的代碼卻能正常運行, 說明 10 / 0 并沒有真正被求值
System.out.println(10 > 20 && 10 / 0 == 0); // 列印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 列印 true
📖位運算子
位運算子主要有四個: & | ~ ^
🔺?👀位操作表示 按二進制位運算. 計算機中都是使用二進制來表示資料的(二進制位是01構成的序列), 按位運算就是在按照二進制位的每一位依次進行計算，操作的是資料的補碼
按位與 &: 如果兩個二進制位都是 1, 則結果為 1, 否則結果為 0
int a = 10;
int b = 20;
System.out.println(a & b);//結果為0
進行按位運算, 需要先把 10 和 20 轉成二進制, 分別為 1010 和 1010（正數的原反補相同）,如圖：
按位或 |: 如果兩個二進制位都是 0, 則結果為 0, 否則結果為 1.
int a=-1;
int b=2;
System.out.println(a|b);
🔺?👀注意: 當 & 和 | 的運算元為整數(int, short, long, byte) 的時候, 表示按位運算, 當運算元為 boolean 的時候, 表示邏輯運算.
按位取反 ~: 操作地是數字的二進制補碼，如果該位為 0 則轉為 1, 如果該位為 1 則轉為 0，操作的也是二進制位，
按位異或 ^: 如果兩個數字的二進制位相同, 則結果為 0, 相異則結果為 1.
int a = 1;
int b = 2;
System.out.printf("%d\n", a ^ b);//0011結果為3
📖移位運算(了解)
移位運算子有三個，都是按照二進制位的補碼來運算 << >> >>>
左移 <<: 最左側位不要了, 最右側補 0.
右移 >>: 最右側位不要了, 最左側補符號位(正數補0, 負數補1)
無符號右移 >>>: 最右側位不要了, 最左側補 0.，和右側一樣只是補的都是0
注意:
- 左移 1 位, 相當于原數字 * 2. 左移 N 位, 相當于原數字 * 2 的N次方.
- 右移 1 位, 相當于原數字 / 2. 右移 N 位, 相當于原數字 / 2 的N次方.
- 由于計算機計算移位效率高于計算乘除, 當某個代碼正好乘除 2 的N次方的時候可以用移位運算代替.
- 移動負數位或者移位位數過大都沒有意義.
📖條件運算子
條件運算子只有一個，也是 Java 中唯一的一個 三目運算子
運算式1 ? 運算式2 : 運算式3
當 運算式1 的值為 true 時, 整個運算式的值為 運算式2 的值; 當 運算式1 的值為 false 時, 整個運算式的值為 運算式3 的值.
// 求兩個整數的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
📖小結
- % 操作再 Java 中也能針對 double 來計算.
- 需要區分清楚 前置自增 和 后置自增之間的區別.
- 由于 Java 是強型別語言, 因此對于型別檢查較嚴格, 因此像 && 之類的運算運算元必須是 boolean.
- 要區分清楚 & 和 | 什么時候是表示按位運算, 什么時候表示邏輯運算.
整體來看, Java 的運算子的基本規則和 C 語言基本一致.
感🦀👍🏻🍹持，??你呦
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/292330.html
標籤：java