day_03

丶聖傑發表於2021-01-02

資料型別
1.1 本質
就是規定佔用記憶體空間的大小,用位和位元組表示
1.2 分類
資料型別 :
基本資料型別
數值型
整數型
Byte
Short
Int
long
浮點型
Float
double
字元型
Char
布林型
Boolean
引用資料型別
類
陣列
介面

1.3 進位制
Java中沒有辦法直接表示二進位制

	// 十進位制表示法
	int i_1 = 10;
	// 八進位制表示法
	int i_2 = 012;
	// 八進位制 每位最多到7
	// int i_3 = 019;

	// 十六進位制表示法
	int i_4 = 0x1f;

	// 雙引號 是字串,裡面的資料不會被解釋,所以 i_4 是找不到記憶體中的0x1f的
	System.out.println("i_4");
	System.out.println(i_4);
	// 以十六進位制展示
	System.out.println(Integer.toHexString(i_4));

1.4 型別使用
1.4.1 整數型
short s_1 = 123;
byte b_1 = 123;
int i_5 = 2147483647;

	// java中整數預設為 int(整型)
	// 所以 以下這個程式碼,是進行了自動型別轉換,把int值複製給long型別
	long l_1 = 2147483647;
	// 超過int上限 報錯
	// long l_2 = 2147483648 ;
	
	// 如何宣告long的值, 加 L/l  建議 L ,因為避免 l和1不容易區分
	long l_3 = 1232167864124L;
	
	// 最大值 : 9223372036854775807
	System.out.println(Long.MAX_VALUE);

1.4.2 浮點型

double d_1 = 1.2;
// 因為預設是double,所以 float宣告必須要加F/f才可以
float f_1 = 1.2f;

	// 強制型別轉換為float
	float f_2 = (float) 1.34;
	System.out.println(f_2);

1.4.3 字元型

char 字元型用英文單引號表示 ‘’ 並且只能有一個字元
char = 2 byte = 16 bit
字元 --> 整數 --> 二進位制
最初的ASCII編碼
```
 'a'  97
```
```
 'b'  98
```
```
 'A' 65
```
```
 'B' 66
```
```
 '0' 48
```
```
 '1' 49
```

採用unicode編碼

	char c_1 = 'a';
	char c_2 = '2';
	char c_3 = '張';
	char c_4 = ' ';
	System.out.println((int)c_1);
	System.out.println((int)c_3);
	
	// 測
	char c_5 = '\u6D4B';
	System.out.println(c_5);

轉移符

 把有意義字元轉換為無意義字元

比如 char用 ‘’ 單引號表示並且只能出現一個字元 ,如果我想輸入 ’ 單引號怎麼辦? 轉義
```
 java 中 \ 表示轉移符 	
```
```
 \t : 製表符
```
```
 \\ : 轉義轉移符
```

 \r\n : 換行符


 char c_1 = '\'';
 char c_2 = '\\';
 char c_3 = '\t';
 System.out.println(c_1);
 System.out.println(c_2);
 System.out.println('\n');
 System.out.println(c_3);

1.4.4 布林型

boolean 不是 bool
1 只有兩個值 : true/false,沒有 1和0
2 預設值為false
3 不參與任何型別轉換
4 佔用1位元組,全是0表示false, 0000001表示true

一般用於流程控制或者邏輯判斷

 boolean b_1 = false;
 boolean b_2 = true;
 // 不能轉換
 // boolean b_3 = (boolean)1;
 
 if (b_2) {
 	System.out.println("為真");
 }else{
 	System.out.println("為假");
 }

1.5 型別轉換

型別轉換
1 8種基本資料型別,除了boolean以外,都可以進行轉換
2 低精度向高精度是自動轉換
3 高精度向低精度是強制轉換
自動型別轉換
byte --> short --> int --> long --> float --> double
```
 			char -->
```
其他就需要強制轉換

 強制轉換有可能損失精度,造成資料不準確


 byte b1 = 1;
 short s1 = b1;
 int i1 = s1;
 // char c1 = s1;
 char c1 = '1';
 i1 = c1;
 // s1 = c1;
 long l1 = c1;
 float f1 = l1;
 // l1 = f1;
 
 byte b2 = (byte) 131;
 System.out.println(b2);
 
 int i2 = 10;
 byte b3 = (byte) i2;
 System.out.println(i2);
 
 // 混合運算

1.6 混合運算

	// 混合運算
	// 當一個運算中出現多個型別的值的時候,結果一定是最大型別
	
	int i_1 = 10;
	long l_1 = 10;
	long b_1 = i_1+l_1;
	// byte  , short , char , int 四種中任意一種或多種進行運算,結果都是int型別
	int b_2 = b3+s1;

1.7 小結
Float,char,boolean三個的使用
自動轉換和強制轉換
轉移符
混合運算

變數

2.1 常量
常量 : 整個程式生命週期中,值不能更改

字面量/直接量:也是有資料型別的, 整數預設int,小數預設double
Final

	// final 修飾的  不可更改
	final int i1 = 1;
	// i1 = 2;
	System.out.println(1);

2.2 變數
可以更改的量,可以再程式執行中對值進行更改
可以複用

2.2.1 全域性變數
什麼是全域性變數的概念 : 允許在類之外建立變數,和類同級別,那麼所有的類都可以直接訪問該變數,不需要二次引用
所謂二次引用,就是沒有使用 . 操作符 xxx.xxxxx
首先 java不允許在類之外建立變數,但是可以將一個類的變數設定為public static修飾的,那麼其他類就可以通過該類的類名.變數名來進行訪問
全域性變數的確定 : 安全性較差,容易命名衝突

所以 java引入了包概念,引用一個變數的時候必須通過該包和類才能訪問
2.2.2 變數定義/宣告

變數宣告 :
```
 資料型別  變數名 ;
```
變數定義 :
```
 資料型別 變數名 =  賦值	
```

 資料型別劃分記憶體空間  給空間命名  賦值(把資料儲存到空間中)

域 :
```
 空間範圍,記憶體空間的劃分
```

 一個 {} 大括號 就是一個作用域,變數不能超過向上碰到的第一個大括號,但是向下可以穿透域中巢狀的所以子大括號

Int i = 10;

int a=3,b=2,c=10;
2.2.3 變數分類

變數分類 :

 區域性變數 : 方法內部宣告的變數是區域性變數

 靜態變數 : 類體中使用static修飾的變數是靜態變數

 成員變數 : 類體中沒有使用static修飾的變數是成員變數

2.2.4 變數呼叫

 區域性變數 : 當前方法中,宣告之後,直接寫變數名呼叫即可

 靜態變數 : 類名.靜態變數名/當前類中呼叫當前類的靜態變數時,類名可以省略,編譯之後,JVM會自動補齊為類名呼叫

 成員變數 : 物件引用.成員變數名

 System.out.println(x1);
 System.out.println(_02_Var.x1);
 _02_Var aa = new _02_Var();
 System.out.println(aa.x);

2.2.5 預設值

區域性變數沒有預設值,必須先初始化賦值之後才能使用
靜態變數和成員變數有預設值

 	整型 : 0  , 浮點型 : 0.0 , 布林型 : false , 字元型 : \u0000 , 引用型別 : null

2.2.6 變數優先順序
變數可以重名嗎?
靜態變數和成員變數不能同名
但是區域性變數和靜態變數/成員變數是可以同名的
也就是說有一個區域性變數 i 那麼還可以再建立一個靜態變數/成員變數 i

如果靜態變數和區域性變數重名,那麼優先使用區域性變數
如果就想使用靜態變數的話,可以使用類名來區分

static int age = 18;
public static void main(String[] args) {
	int age = 22;
	System.out.println(_04_Var.age);
}

操作符
3.1 算數運算子

運算操作符 +,-,*,/,% ++,–
運算子優先順序單目/單元運算子優先順序最高 > 雙目 > 三目

i++ 和 ++i 的區別

 int a = 10;
 int b = 3;
 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);

 double d1 = 0.1;
 double d2 = 0.2;
 // 0.30000000000000004
 // 注意 不要使用小數做比較
 System.out.println(d1 + d2);

 System.out.println("----------------------");
 // ++ : 把值取出,+1,再放回去
 int k = 100;
 // 只要是單獨出現,不管k在前還是k在後,都一樣,原數+1即可
 // k++;
 // ++k;
 
 // 201 如果是 k++ ,就會申請一塊臨時空間,把k中的值先儲存到臨時空間中,然後k++的這個k 就指向臨時空間中的值
 // 然後計算++ , 計算完++ 後,繼續後續操作 100+k
 // 如果是 ++k 那麼 k 就不需要指向臨時空間了
 
 // k++ : k使用的是++之前的值
 // ++k : k使用的是++之後的值
 // 但是 ++ 優先順序 大於 雙目和三目
 k = k++ +k;
 System.out.println(k);
 
 int w = 10;
 w = w++ * w;
 System.out.println(w);
 
 int m = 10;
 int e = 2+m++;
 System.out.println(e);
 System.out.println(m);
 
 int p= 2;
 p = 2 + p++ + ++p + p++ + ++p;

// p = 2 + 2 + ++p + p++ + ++p; p=3
// p = 2 + 2 + 4 + 4 + 6; p=6
System.out.println§;

	int x = 10;
	x = 10 + x++ + ++x +(10 * x++) + ++x;

// x = 10 + 10 + 12 +120 + 14; x=14
System.out.println(x);

	int i = 10;
	i= i++ + (i +1);
	System.out.println(i);

3.2 關係運算子

關係運算子

 運算結果 是 boolean型  (true/false),可以叫布林型表示式

= < <=
== : = 是賦值操作,java中判斷相等使用 ==

 	如果是基本型別,比較值的大小

 	如果是引用型別,比較記憶體地址

!= : 不等於
常用於流程控制

3.3 位運算子

位運算

 &  位與  , 兩邊都是true 結果才是true,也可以兩邊是數字

 |  位或 一邊為true 結果就為true

 ! 位非,取反   !true 就是false   , !false 就是true

```
 ^ 異或  ,兩邊不一樣就是true
```

 ~ 按位非,轉換為二進位制,然後 每位取反

邏輯比較

 && : 短路與,切 , 如果 第一個就為假,第二個表示式就不執行了,結果為假

 || : 短路或,或,如果第一個為真,第二個就不執行了

: 右移運算子(考慮符號位,符號位不移動,正數就是正數,負數就是負數)
```
 	8 >> 2
```

 		0000000 10  轉換為二進位制,然後符號位之後補兩個0,最右邊刪除兩位

```
 	右移  8 >> n  就等於 8 / 2^n
```
```
 	如果是 -8 >>2  就是補1  
```
<< : 左移運算子(不考慮符號位),向最左邊補0
: 右移運算子(不考慮符號位)

 	如果是正數  和>> 沒有區別,因為最前面都是0

 	但是負數就不一樣了, >> 只會在符號位之後補1 , 而 >>> 在符號位之前 補0

 	所以 -1 >>> 1 就成了  2147483647