標識符的命名規範
兩個基本的命名規範：
1：見名知意 通過標識符的名字要能體現標識符代表的內存區域的數據的性質。
比如：年齡的數據：age 名字的數據：name
2：遵循駝峯命名法：多個單詞構成標識符，單詞的首字符要大寫。
舉個栗子：學生的年齡：studentAge。 stuAge。
3：用英文單詞命名，拒絕使用漢語拼音，和其他形式。
不同種類的標識符的命名規範：
1：class 後的名字 類名：
首字符大寫，遵循基本命名規範即可。
2：局部變量的命名規範：
首字符小寫，如果是多個單詞構成，從第二個單詞的首字符開始遵循駝峯命名法，大寫。
儘量不要使用單個字符作爲變量名。
3：終態變量的命名規範：
所有字符全部大寫，多個單詞使用下劃線分割。
4：方法名命名規範：
首字符小寫，遵循見名知意，駝峯命名法。
5：形式參數變量：
就是局部變量，命名規範同局部變量。
6：包名的命名規範：
使用公司域名的逆序形式：爲了區別於其他的公司的包。後面是功能模塊的名稱。
所有的包名，都要求全部小寫。
7：類的成員變量的命名規範：
與局部變量相同。
8：接口名命名規範：
與類的命名規範一致。
計算機其他知識
進制
1：在java 程序中 表示一個具體的數的時候。可以使用幾種進制來表示？
四種： 二進制、八進制、十進制、十六進制。
//練習java 中程序的進制的表示形式
public class TestNumber{
// 入口方法 main
public static void main(String[] args){
System.out.println("我特別的好！~·");
//十進制表示的數字 10 將數字10 轉換爲數字對應的字符串，然後再打印。
System.out.println(10);
//二進制表示 10 高位添加0b 表示這是一個二進制的數據 jdk 1.7增加的功能
System.out.println(0b1010);
//八進制 高位補0 代表是一個八進制的數據
System.out.println(012);
//十六進制 高位補0x
System.out.println(0xa);
}
}
2：二進制：
規則：逢二進一 一個二進制位 可以有2種不同的狀態。[0-1]
在 計算機學科中 ，一個二進制位 一個0 或者是 一個1 是 計算機的最小的存儲單元。
一個二進制位 稱之爲 1bit。 8bits 稱之爲一個字節 1byte。 可以有256種狀態。
0 1
00 01 10 11
000 001 010 011 100 101 110 111
3：十進制：用0-9 十個字符 代表了10種不同狀態。多個十進制的位的組合來代表更多的不同的狀態。10 11 12.
規則：逢十進一，一個十進制位 可以有10種不同的表示形式[0-9].
4：八進制：
規則：逢八進一，一個八進制位 表示的範圍[0-7]
5:十六進制：
規則：逢十六進一 ，一個十六進制爲 表示的範圍是[0-15] 必須使用一個字符來表示 10~15.
規定，使用[a-f][A-F]來代表 [10-15]
使用四種進製表示0-15
十進制 二進制 八進制 十六進制
0 0 0 0
1 1 1 1
2 10 2 2
3 11 3 3
4 100 4 4
5 101 5 5
6 110 6 6
7 111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 A
11 1011 13 B
12 1100 14 C
13 1101 15 D
14 1110 16 E
15 1111 17 F
機器碼-原碼-反碼-補碼
一個整數 在 內存中 是以什麼樣的形式 表示的？
首先 內存中的 表現形式 計算機肯定能直接識別。 表現的形式 稱之爲 機器碼。
用一個字節來表示 機器碼。
計算機科學中規定：用字節的最高位來代表符號位，0 代表是正數 1 代表負數。
三種機器碼：原碼，反碼，補碼。
10：
-10：
1 原碼：
原碼機器碼的表示數據的規則：
最高位爲符號位，低7位爲數值位。
10： 0000 1010
-10：1000 1010
計算機並不是使用原碼來表示數據的。
缺點：
1：有+0 和 -0 之分。 0000 0000 1000 0000
2：如果考慮符號位參與運算，那麼在設計cpu的 時候，會增加cpu的設計的難度。
2 反碼：
規則：
如果是正數，那麼原碼和反碼一致。
負數，在原碼的基礎上，符號位不變，其他的二進制位 1 變0 0 變 1 取反。
10：0000 1010 --反碼--> 0000 1010
-10：1000 1010--反碼--> 1111 0101
補碼：
規則：
如果是正數，那麼補碼和原碼一致。 三碼合一。
負數，先求原碼，然後求反碼，最後+1.
-10：
1000 1010--反碼--> 1111 0101 --求補-->+1
1111 0110
-1：1000 0001--->1111 1110 ---> 1111 1111
優點：
1：沒有+0 和 -0 之分
0000 0000
1000 0000 1111 1111 + 1 1 0000 0000
2：計算機在使用補碼計算的時候，並沒有把符號位當作符號位來看待，而是當作了普通的數值位來使用，計算的規則和數值位的規則一致。
cpu 的設計很簡單了。
計算機科學中廣泛了採用了補碼的形式表示數據。
規則：補碼的補碼是原碼。
1111 1111 ---> 1000 0000 + 1 1000 0001
記住：-1 的二進制形式 1111111111111111111111111（全1）.
進制的轉換
1：任何進制到 十進制的轉換
123 = 1* 10^2 + 2*10^1 + 3*10^0 = 1*100 + 2 * 10 + 3 * 1 = 100 + 20 + 3 = 123;
0b101 = 1*2^2 + 0 * 2^1 + 1 * 2^0
0715 = 7*8^2 +1* 8^1 + 5* 8^0 =7*64+8+5 = 448+13 = 461;
0xa3 = 10 * 16^1+ 3* 16^0 = 163
2: 十進制到其他進制的轉換。
十進制
二進制：除二取餘法。逆序輸出。
除八取餘數
除十六取餘數
八進制和二進制
規則：一個八進制位表示成3個二進制位，3個二進制位合成一個八進制位
101010<--->52
61<--->110001
十六進制和二進制的轉換
規則：一個十六進制位表示成4個二進制位，4個二進制位合成一個十六進制位
0xae3<--->101011100011
標識符
思考一個問題：
寫程序的目的：數據的運算和處理。
那麼在程序中如何去訪問要處理的數據呢？
通常的做法是，給要處理的數據所在的內存起一個名字。
通過名字來訪問數據所在的內存區域。
內存區域的名字在java 稱之爲：標識符。
一個標識符對應着內存中的一塊區域。
標識符的命名規則：
1：首字符 必須是 26個英文字母的 的大小寫形式、下劃線、$.後續的字符多了10個數字字符。
2：不能使用 java 語言中的 關鍵字 (java 中具有特殊意義的單詞符號) 。又稱爲保留字。
3：標識符 大小寫敏感。
4：標識符的長度沒有限制。（不建議使用單個字符作爲標識符，也不能太長了）。
5：空格，#
數據類型
所有寫的 java 的源代碼 都要符合 java 編譯器 的 規範，要能夠讓編譯器 理解 編譯通過。
1：在編寫源代碼的時候，需要告訴編譯器，我申請的內存的名字，還有內存中數據的類型。
java 是一種強類型語言。
2：java 語言中，支持的數據的類型。
表達某些數據的時候，可以使用那些類型來表示。
java 中規定 一塊內存區域只能保存一種類型的數據。
3：java 支持的數據類型
2大類：
1：基本數據類型、簡單數據類型、java內置類型。
2：引用數據類型、複合數據類型、複雜數據類型。
4：java 支持的基本數據類型有哪些？8種。
1：4種整數類型
1：字節型 byte 佔用1byte 的內存空間。 數據範圍[-128~127][-2^7 ~ 2^7-1] 256
2: 短整型 short 佔用 2 bytes 數據表示的範圍 [-2^15 ~ 2^15-1] 65535
3: 整型 int 佔用 4 bytes 數據表示的範圍 [-2^31 ~ 2^31-1]
4：長整型 long 佔用 8個字節 數據表示的範圍 [-2^63 ~ 2^63-1]
2：2個浮點數
1：單精度類型 float 佔用4bytes 小數點後可以有7個小數位左右。
2：雙精度 double 佔用8bytes 小數點後可以保留 17位小數 左右。
3：字符類型 char 2bytes
4：布爾類型 boolean 官方沒有給出具體佔用空間的大小
只有兩個值 true 和 false。
只使用了一個二進制位來表示這兩種狀態。
1-->true 0---false.
引用數據類型的大小統一爲4個字節，記錄的是其引用對象的地址
並不是每個字節存放的是一個內存地址，而是變量存的就是首地址或者末地址，對應的高端法和低端法
（郝斌）
定義指定類型的標識符並存儲指定的數據的通用格式：
數據類型 標識符 = 某一個值;
float 和 double 兩種浮點數 類型。
float 和 double 在很多時候都不能 精確的表示 十進制的小數，還有比較大的整數。都是一種近似的表示。
float 和 double 這兩種類型 java 在設計 的時候就不是爲了精確運算而設計的。
float 和 double 表示數據範圍很大的原因：
一部分二進制位表示數值位 另外一部分表示 次冪數。
精確運算：BigDecimal。
變量
變量：變量的本質就是一塊有名字的內存區域。該內存區域中的數據可以被修改。通過名字來訪問和修改該內存區域的值。
定義變量的格式：
數據類型 變量名 = 初始值;
定義變量的本質：申請內存並賦值的過程。
方法中定義的變量：局部變量，必須先定義後使用。
聲明變量：
數據類型 變量名;
賦初值：
變量名 = 初始值;
所以，定義變量就是 聲明 + 賦值的過程。
聲明的變量不能訪問，如果只是聲明變量，那麼jvm 不會給 變量分配內存。
如果一個變量可以被訪問，那麼必須保證 被訪問的時候已經被分配了內存。
//使用變量
public class TestVariable{
public static void main(String[] args){
//定義一個int 類型的變量 保存一個100;
int value = 100;
//獲得變量的值 get
System.out.println("value = " + value);
//修改變量的值 set
value = 99;
//獲得變量的值 get
System.out.println("value = " + value);
//定義變量的其他的語法形式。
//聲明變量 聲明的變量不能訪問，如果只是聲明變量，那麼jvm 不會給 變量分配內存。
//如果一個變量可以被訪問，那麼必須保證 被訪問的時候已經被分配了內存。
int age;
//賦初值
age = 19;
System.out.println("age = " + age);
int num1 = 10,num2 = 20, num3 = 30;
int value1 = 10,value2,value3 = 50,value4;
value2 = 19;
System.out.println("value2 = " + value2);
//System.out.println("value4 = " + value4);
}
}
作用域
概念：
可以被訪問的範圍
局部變量的作用域：局部變量可以被訪問的範圍。
局部變量的作用域：從定義的位置開始，到變量所在的大括號的結尾處內。
常量
java 中的常量 分爲兩種：
1：字面常量、字面值。 12, 1.2,'A',"123",true,false.
1，整數常量，表示所有的整數
2，小數常量，表示所有的小數
3，布爾常量，只有兩個值，true和false
4，字符常量，由' '括起來的內容。在一般情況下，' '裏面括起來的只能是一個字符
5，字符串常量，由" "括起來的內容。
6，空常量，null
2：不可變的變量。
java 中所有的數據都是要有類型的，可以顯式的指定數據的類型。
字面值 是被編譯器 隱式指定數據類型。
隱式指定數據類型的規則：
如果是整數 類型爲int。
如果一個字面整數的值超過了int 的範圍，那麼必須告訴編譯器 申請8個字節的空間去存儲它。通過在常量的末尾添加 字符 l or L 建議使用 L
如果是浮點數，那麼默認類型 爲double。佔用8個字節。
肯定不能將八個字節的數據賦值給4個字節的內存空間。可能會有精度的損失。不安全。
需要在浮點數常量值的末尾添加 F or f 。來申請四個字節的空間存儲。
不可變的變量：
int maxYearDayCount = 366;
如何將一個變量變成不可變的量：
final int maxYearDayCount = 366;
final 修飾的變量稱之爲 終態變量。只能初始化一次。
char 類型：
佔用 2 bytes 。
可以當作整數來看來。[0-65535] 無符號短整型。沒有負數。
轉義字符
美國的字符集 ASCII
0 字符對應的整數 48
A --->65
a ---> 97
轉義字符：
Java 中的轉義字符有好幾種，常見的有：
八進制轉義字符，格式：\ + 1到3位八進制數字，如\1, \20，範圍爲 \0 ~ \377，即最大值爲255。
Unicode轉義字符，格式：\u + 四個十六進制數字，範圍爲\u0000 ~ \uFFFF，即：0~65535
特殊字符，包括3個："：雙引號；’：單引號；\：反斜線
控制字符：包括5個：’ 單引號字符；\ 反斜槓字符；\r 回車；\n 換行；\f 走紙換頁；\t 橫向跳格；\b 退格
例如： /72 是八進制的，化爲十進制爲58對應ASCII編碼爲冒號
\t 對應着鍵盤上的Tab 鍵 可以表示[1-8]個半角位 \t輸出的位置必須保證前面輸出的所有的內容要求是8的倍數的半角位，不夠8的倍數，補齊8的倍數，夠了，自己就獨自佔8個。
\b 對應着鍵盤上的Backspace 鍵 退格鍵。
\f 換頁符
\r 回車符 讓光標回到當前行的行首。
\n 換行符 讓光標去到下一行
注意：鍵盤上的回車鍵 對應了2個字符 \r\n
回車鍵：去到下一行的行首。
\': 單引號 字符
\"：雙引號 字符
\\: 反斜槓 字符
打印一個字消耗的時間是0.1s，每次換行 需要消耗0.2s 每次換行 都會丟倆字符。
後來就在需要換行的地方 添加兩個空白字符 \r\n。
1：讀取到了 97 去本地字符集 gbk 去查找 97 對應的字符 a ,再去unicode 字符集中 將 a 的字符對應的整數替換過來。
（見字符集詳解 沒寫）
字符集中的某些具有特殊意義的字符沒有辦法使用一個符號來表示，所以使用一種轉義字符的方式來表示
//char 類型 練習
public class TestChar{
public static void main(String[] args){
//定義char 類型的變量
char c1 = 'A';
//就是每一個字符都對應這個一個唯一的整數 這個整數在[0-65535]
char c2 = 66;
System.out.println(c1);
System.out.println(c2);
//使用轉義字符的方式去表示字符
//java 使用字符集是 Unicode 字符集
//使用4個16進制位來表示16bits
//轉義序列
char c3 = '\u0043';
System.out.println(c3);
//字符集中的某些具有特殊意義的字符沒有辦法使用一個符號來表示，所以使用一種轉義字符的方式來表示。
//System.out.println("\t123456789");
//System.out.println("123456789");
//System.out.println("1\t23456789");
System.out.println("1234567\n89");
char c4 = '\'';//單引號 字符
char c5 = '\"';//雙引號 字符
char c6 = '\\';//反斜槓 字符
}
}
註釋
註釋的作用：幫助開發人員更好的理解記憶程序的。
java 中支持三種註釋：
1：單行註釋 //後續的內容都是註釋的內容 可以單獨佔用一行，用來解釋說明它下面一行的代碼。 還可以放到一行代碼的末尾，短註釋。
2：多行註釋： /* 註釋的內容 */
3：多行文檔註釋: 幫助生成閱讀文檔的。 javadoc.exe 可以用來識別java 源代碼中的文檔註釋的內容。將文檔註釋中的內容生成一個幫助文檔。
/** 文檔註釋的內容 */
算術運算時的轉換
注意：java 不支持不同類型的數據之間的運算。
如果是不同類型的數據進行運算，那麼編譯器會對不同的類型的數據進行類型的統一的轉換。轉換爲統一類型之後才能做運算。
自動類型轉換的規則：
1：如果操作數 的類型 是 byte，char ，short ，int 中的一個或者幾個。那麼這些操作數的類型要被自動轉換爲 int 類型然後再做運算。
結果也是int。這種轉換不會修改數據的大小，只是數據使用內存空間的大小的變換。
2：如果操作數 的類型 是 byte，char ，short ，int，long 中的一個或者幾個，而且有long類型的數據存在。那麼這些操作數的類型要被自動轉換爲 long 類型然後再做運算。結果也是long。
3：如果所有的操作數的類型中，最大的類型是float，那麼所有的操作數的類型都向float 轉，結果也是float。
float 類型表示的範圍大於 long。
4：如果所有的操作數的類型中，最大的類型是double，那麼所有的操作數的類型都向double轉，結果也是double。
double 類型表示的範圍最大。
自動類型轉換：因爲這種轉換是安全的。
從 int 到 float 和 到 long ，有可能損失精度。
賦值時的轉換
賦值的時候的類型的轉換。
1：自動向上類型轉換：可以將一個小類型的數據 直接 賦值 給一個大類型的變量。 因爲安全。
小類型 向 大類型 自動轉換，因爲安全。
2：強制向下類型轉換：
整數的強制向下 直接將高位砍掉。
浮點數 到 整數 強轉 先直接砍掉小數點。然後再按照整數的規則砍。
強制轉換 不能確保是安全的。
老虎：一種類型
動物：一種類型
可以把老虎當動物使用。自動向上類型轉換。
不能把動物當老虎使用。除非這個動物的確是一隻老虎，纔可以強制轉換爲 老虎使用。
//類型轉換
public class TestChangeType{
public static void main(String[] args){
int age = 10;
byte value = 10;
int num = value;
System.out.println(num);
byte value1 = 12;
byte value2 = 10 + 23;//沒有問題
// 在編譯期，是不知道變量的值的。但是對於常量值，編譯器是可以判斷 賦值 是否安全。
byte value3 = (byte)(value1 + value2);//肯定不對所以要強轉
System.out.println((short)128.349329329);//-128 1000 0000 0111 1111
}
}
字符串連接時的轉換
1：“123” + 123
字符串和其他的類型也是不能直接連接的，其他的類型需要轉換爲字符串才能和字符串做連接。
這個基本數據類型的數據到字符串的轉換，是由底層的方法調用來完成。
面試題
1：java中爲什麼byte的取值範圍是-128到+127 ？
1、byte爲一字節8位，最高位是符號位，即最大值是01111111，因正數的補碼是其本身，即此正數爲01111111十進制表示形式爲127;
2、最大正數是01111111，那麼最小負是10000000(最大的負數是11111111，即-1);
3、10000000是最小負數的補碼錶示形式，我們把補碼計算步驟倒過來就即可。10000000減1得01111111然後取反 10000000，因爲負數的補碼是其絕對值取反，即10000000爲最小負數的絕對值，而10000000的十進制表示是128，所以最小負數是-128;
4、由此可以得出byte的取值範圍是-128到+127;
————————————————
此問題原文鏈接：https://blog.csdn.net/yun_ld/article/details/93220352
2：一個整數 在 內存中 是以什麼樣的形式 表示的？
首先 內存中的 表現形式 計算機肯定能直接識別。 表現的形式 稱之爲 機器碼。
用一個字節來表示 機器碼。
3：爲什麼要設計出反碼補碼 ？
正數的原碼反碼補碼是一樣的：
[+2] = [00000010]原=[00000010]反=[00000010]補;
但是對於負數來說，它的原碼反碼補碼就不盡相同：
[-2] =[10000010]原=[11111101]反=[11111110]補;
對於人來說，可以直接看出原碼和十進制數字的關係，而反碼和補碼還需要其他一些轉換，那麼爲什麼設計出反碼補碼？
因爲計算機只有加法，沒有減法，因爲在做減法的時候，可以認爲是加上一個負數，這樣可以減少計算機電路複雜度。
但是用原碼進行減法的時候會出問題。比如:計算1-1，因爲計算機沒有減法只有加法，所以計算機自動換成1+（-1）
1 - 1 = 1 + (-1) = [00000001]原+ [10000001]原= [10000010]原= -2（符號位也參與運算）
而實際上1-1的結果是0
爲了解決減法的問題，於是想出了反碼：
1 - 1 = 1 + (-1) = [0000 0001]原+ [1000 0001]原= [0000 0001]反+ [1111 1110]反= [1111 1111]反= [1000 0000]原= -0
這樣用反碼計算得出的結果是正確的，但是有個問題：00000000可以代表+0；10000000可以代表-0；但是+0和-0其實是一樣的，用2個編碼實在是浪費。
爲了解決±0的問題，於是想出了補碼：
1-1 = 1 + (-1) = [0000 0001]原+ [1000 0001]原= [0000 0001]補+ [1111 1111]補= [0000 0000]補=[0000 0000]原
這樣0用[0000 0000]表示, 而以前出現問題的-0則不存在了.而且可以用[1000 0000]表示-128:但是注意因爲實際上是使用以前的-0的補碼來表示-128, 所以-128並沒有原碼和反碼錶示.(對-128的補碼錶示[1000 0000]補算出來的原碼是[0000 0000]原, 這是不正確的)
使用補碼, 不僅僅修復了0的符號以及存在兩個編碼的問題, 而且還能夠多表示一個最低數. 這就是爲什麼8位二進制, 使用原碼或反碼錶示的範圍爲[-127, +127], 而使用補碼錶示的範圍爲[-128, 127].
總結：反碼是爲了解決減法運算，補碼是爲了解決反碼產生的±0的問題。
————————————————
原文鏈接：https://blog.csdn.net/yun_ld/article/details/93220352
4：編譯器都會提示哪些錯誤？
編寫錯誤，語句錯誤，邏輯錯誤，比如不可能使用到執行到的情況等，IO異常也會提示
5：數據類型的作用？：
1：決定了數據佔用內存空間的大小。
2：底層二進制存儲的格式。
（見基本數據類型詳解系列文章 還沒寫）
6：轉爲字符串的方法
把一個基本數據類型轉爲字符串類型，有三種方法。
假設a是integer類型的數據
方法1：a.toString();
方法2：String.valueOf(a); //推薦
方法3：a+"";
效率比較：
方法1效率最快、其次到方法2、最後纔是方法3；
原因：
1.a.toString()方法可以直接調用進行轉換
2.String.valueOf(a)方法底層調用了Integer.toString()方法，但是會在調用前做空判斷
3.a+""底層使用了StringBuilder實現，先用append方法拼接，再用toString()方法獲取字符串
原文鏈接：https://blog.csdn.net/qq_38039015/article/details/83050046
7：Java的安全性體現在哪些方面？
一：語言安全
取消指針：用引用代替指針，指針可以指向任意一個內存區域，不管這個區域是否可用，這樣做是危險的，因爲不知道這個區域是否被其他程序佔用或者是否存儲了重要數據，而且指針也會出現數組下標越界。
垃圾回收機制：不需要手動回收垃圾，由垃圾收集器統一回收不再使用的內存，避免程序中忘記及時回收內存而導致內存泄漏，也避免程序錯誤回收程序核心類庫的內存，導致系統被虧崩潰。（看垃圾收集器的文章 還沒寫）
異常處理機制：通過關鍵字來進行異常處理，讓程序在發生非正常情況的也能正確退出。try catch finally throw throws
強制類型轉換：只有滿足強制類型轉換規則的時候，才能進行類型轉換。分爲基本數據類型，和引用數據類型。
引用數據類型，比如發生繼承的時候，需要向下轉型，可以使用instanceof 。
如果是基本數據類型，則需要好好判斷一下，比如是否超過範圍，如果是轉成字符串，也可以使用類庫提供的方法。
二：底層安全
Java在字節碼傳輸的過程中，使用了公開密鑰加密機制PKC
三：運行環境的安全保障機制
字節碼校驗器–類裝載器–運行時內存佈局–文件訪問限制（可以看碼農翻身）