一、注釋
在java中，有3種标記注釋的方式。
1.1 單行注釋
1.2 多行注釋
/*
多行注釋内容
多行注釋内容
多行注釋内容
多行注釋内容
*/ 1.3 文檔注釋
/**
* 類注釋
*
* @author vivfeng
*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
} 二、關鍵字
2.1 總覽
| 通路控制 | private | protected | public | ||||||
| 類,方法和變量修飾符 | abstract | class | extends | final | implements | interface | native | new | static |
| strictfp | synchronized | transient | volatile | ||||||
| 程式控制 | break | continue | return | do | while | if | else | for | instanceof |
| switch | case | default | |||||||
| 錯誤處理 | try | catch | throw | throws | |||||
| 包相關 | import | package | |||||||
| 基本類型 | boolean | byte | char | double | float | int | long | short | null |
| true | false | ||||||||
| 變量引用 | super | this | void | ||||||
| 保留字 | goto | const |
2.2 含義
| 關鍵字 | 含義 |
| abstract | 表明類或者成員方法具有抽象屬性 |
| assert | 用來進行程式調試 |
| boolean | 基本資料類型之一，布爾類型 |
| break | 提前跳出一個塊 |
| byte | 基本資料類型之一，位元組類型 |
| case | 用在switch語句之中，表示其中的一個分支
|
| catch | 用在異常進行中，用來捕捉異常 |
| char | 基本資料類型之一，字元類型 |
| class | 類 |
| const | 保留關鍵字，沒有具體含義 |
| continue | 回到一個塊的開始處 |
| default | 預設，例如，用在switch語句中，表明一個預設的分支 |
| do | 用在do-while循環結構中 |
| double | 基本資料類型之一，雙精度浮點數類型 |
| else | 用在條件語句中，表明當條件不成立時的分支 |
| enum | 枚舉 |
| extends | 表明一個類型是另一個類型的子類型，這裡常見的類型有類和接口 |
| final | 用來說明最終屬性，表明一個類不能派生出子類，或者成員方法不能被覆寫，或者成員域的值不能被改變 |
| finally | 用于處理異常情況，用來聲明一個基本肯定會被執行到的語句塊 |
| float | 基本資料類型之一，單精度浮點數類型 |
| for | 一種循環結構的引導詞 |
| goto | 保留關鍵字，沒有具體含義 |
| if | 條件語句的引導詞 |
| implements | 表明一個類實作了給定的接口 |
| import | 表明要通路指定的類或包 |
| instanceof | 用來測試一個對象是否是指定類型的執行個體對象 |
| int | 基本資料類型之一，整數類型 |
| interface | 接口 |
| long | 基本資料類型之一，長整數類型 |
| native | 用來聲明一個方法是由與計算機相關的語言（如C/C++/FORTRAN語言）實作的 |
| new | 用來建立新執行個體對象 |
| package | 包 |
| private | 一種通路控制方式：私用模式 |
| protected | 一種通路控制方式：保護模式 |
| public | 一種通路控制方式：共用模式 |
| return | 從成員方法中傳回資料 |
| short | 基本資料類型之一,短整數類型 |
| static | 表明具有靜态屬性 |
| strictfp | 用來聲明FP_strict（單精度或雙精度浮點數）表達式遵循IEEE 754算術規範 |
| super | 表明目前對象的父類型的引用或者父類型的構造方法 |
| switch | 分支語句結構的引導詞 |
| synchronized | 表明一段代碼需要同步執行 |
| this | 指向目前執行個體對象的引用 |
| throw | 抛出一個異常 |
| throws | 聲明在目前定義的成員方法中所有需要抛出的異常 |
| transient | 聲明不用序列化的成員域 |
| try | 嘗試一個可能抛出異常的程式塊 |
| void | 聲明目前成員方法沒有傳回值 |
| volatile
| 表明兩個或者多個變量必須同步地發生變化 |
| while
| 用在循環結構中 |
三、常量與變量
3.1 常量
在 Java中，利用關鍵字 final訓示常量。例如：
關鍵字 final 表示這個變量隻能被指派一次。一旦被指派之後，就不能夠再更改了。習慣上, 常量名使用全大寫。
3.2 變量
在 Java中，每個變量都有一個類型。在聲明變量時，變量的類型位于變量名之前。例如：
int a;
long b;
String s; 變量名必須是一個以字母開頭并由字母或數字構成的序列。另外，不能使用 Java 保留字作為變量名。
四、運算符
4.1 算術運算符
| 運算符 | 描述 | 例子 |
|---|---|---|
| + | 加法：相加運算符兩側的值 | A + B 等于 30 |
| - | 減法：左操作數減去右操作數 | A – B 等于 -10 |
| * | 乘法：相乘操作符兩側的值 | A * B等于200 |
| / | 除法：左操作數除以右操作數 | B / A等于2 |
| ％ | 取餘：左操作數除以右操作數的餘數 | B%A等于0 |
| ++ | 自增：操作數的值增加1 | B++ 或 ++B 等于 21 |
| -- | 自減：操作數的值減少1 | B-- 或 --B 等于 19 |
4.2 關系運算符
| 運算符 | 描述 | 例子 |
|---|---|---|
| == | 檢查如果兩個操作數的值是否相等，如果相等則條件為真。 | （A == B）為假。 |
| != | 檢查如果兩個操作數的值是否相等，如果值不相等則條件為真。 | (A != B) 為真。 |
| > | 檢查左操作數的值是否大于右操作數的值，如果是那麼條件為真。 | （A > B）為假。 |
| < | 檢查左操作數的值是否小于右操作數的值，如果是那麼條件為真。 | （A <B）為真。 |
| >= | 檢查左操作數的值是否大于或等于右操作數的值，如果是那麼條件為真。 | （A >= B）為假。 |
| <= | 檢查左操作數的值是否小于或等于右操作數的值，如果是那麼條件為真。 | （A <= B）為真。 |
4.3 位運算符
| 運算符 | 描述 | 例子 |
|---|---|---|
| ＆ | 如果相對應位都是1，則結果為1，否則為0 | （A＆B）得到12，即 0000 1100 |
| | | 如果相對應位都是0，則結果為0，否則為1 | （A | B）得到61，即 0011 1101 |
| ^ | 如果相對應位值相同，則結果為0，否則為1 | （A ^ B）得到49，即 0011 0001 |
| 〜 | 按位取反運算符翻轉操作數的每一位，即0變成1，1變成0。 | （〜A）得到-61，即 1100 0011 |
| << | 按位左移運算符。左操作數按位左移右操作數指定的位數。 | （A << 2）得到240，即 1111 0000 |
| >> | 按位右移運算符。左操作數按位右移右操作數指定的位數。 | （A >> 2）得到15，即 0000 1111 |
| >>> | 按位右移補零操作符。左操作數的值按右操作數指定的位數右移，移動得到的空位以零填充。 | （A>>>2）得到15，即 0000 1111 |
4.4 邏輯運算符
| 運算符 | 描述 | 例子 |
|---|---|---|
| && | 稱為邏輯與運算符。當且僅當兩個操作數都為真，條件才為真。 | （A && B）為假。 |
| || | 稱為邏輯或操作符。如果任何兩個操作數任何一個為真，條件為真。 | （A || B）為真。 |
| ！ | 稱為邏輯非運算符。用來反轉操作數的邏輯狀态。如果條件為true，則邏輯非運算符将得到false。 | !(A && B) 為真。 |
4.4 指派運算符
| 運算符 | 描述 | 例子 |
|---|---|---|
| = | 指派運算符，将右操作數的值賦給左側操作數 | C = A + B将把A + B得到的值賦給C |
| += | 加和指派操作符，它把左操作數和右操作數相加指派給左操作數 | C += A等價于C = C + A |
| -= | 減和指派操作符，它把左操作數和右操作數相減指派給左操作數 | C -= A等價于C = C - A |
| *= | 乘和指派操作符，它把左操作數和右操作數相乘指派給左操作數 | C *= A等價于C = C * A |
| /= | 除和指派操作符，它把左操作數和右操作數相除指派給左操作數 | C /= A等價于C = C / A |
| %= | 取模和指派操作符，它把左操作數和右操作數取模後指派給左操作數 | C %= A等價于C = C％A |
| <<= | 左移位指派運算符 | C <<= 2等價于C = C << 2 |
| >>= | 右移位指派運算符 | C >>= 2等價于C = C >> 2 |
| ＆= | 按位與指派運算符 | C＆= 2等價于C = C＆2 |
| ^= | 按位異或指派操作符 | C ^= 2等價于C = C ^ 2 |
| |= | 按位或指派操作符 | C |= 2等價于C = C | 2 |
4.5 條件運算符（?:）
條件運算符也被稱為三元運算符。該運算符有3個操作數，并且需要判斷布爾表達式的值。該運算符的主要是決定哪個值應該指派給變量。
int a = 1;
int b = 2;
boolean f = a >= b ? true : false;//f為false 五、資料類型
5.1 基本資料類型
/* byte
* 存儲需求：1位元組
* 取值範圍：-128 ~ 127
* 預設值：0
* */
byte num1 = 100;
/* short
* 存儲需求：2位元組
* 取值範圍：-32,768 ~ 32,767
* 預設值：0
* */
short num2 = 10000;
/* int
* 存儲需求：4位元組
* 取值範圍：-2,147,483,648 ~ 2,147,483,647
* 預設值：0
* */
int num3 = 1_000_000_000;
/* long
* 存儲需求：8位元組
* 取值範圍：-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807
* 預設值：0L
* */
long num4 = 1_000_000_000_000_000_000L;
/* float
* 存儲需求：4位元組
* 有效位數：6 ~ 7位
* 預設值：0.0F
* */
float num5 = 1.1F;
/* double
* 存儲需求：8位元組
* 有效位數：15位
* 預設值：0.0D
* */
double num6 = 2.0D;
/* boolean
* 存儲需求：JVM規範中，boolean變量作為int處理，也就是4位元組
* 取值範圍：隻有兩個取值，即 true 和 false
* 預設值：false
* */
boolean k = true;
/* char
* 存儲需求：2位元組
* 取值範圍：0~65535
* */
char c = 'a'; 5.2 引用資料類型
/*
* 在Java中，引用類型的變量非常類似于C/C++的指針。引用類型指向一個對象，指向對象的變量是引用變量。
* 這些變量在聲明時被指定為一個特定的類型，比如 String 等。
* 變量一旦聲明後，類型就不能被改變了。
* 對象、數組都是引用資料類型。
* 所有引用類型的預設值都是 null。
*/
String string = null;
string = new String("aaaaa"); 六、大數值
如果基本的整數和浮點數精度不能夠滿足需求，那麼可以使用java.math包中的兩個很有用的類：Biglnteger和 BigDecimaL，這兩個類可以處理包含任意長度數字序列的數值。
BigInteger類實作了任意精度的整數運算，BigDecimal類實作了任意精度的浮點數運算。
//使用靜态的 valueOf方法可以将普通的數值轉換為大數值
BigInteger bigA = BigInteger.valueOf(5L);
BigInteger bigB = BigInteger.valueOf(10L);
BigInteger bigC = null;
//加
bigC = bigA.add(bigB);
//減
bigC = bigA.subtract(bigB);
//乘
bigC = bigA.multiply(bigB);
//除
bigC = bigA.divide(bigB);
//取餘
bigC = bigA.mod(bigB); 七、數組
數組是一種資料結構，用來存儲同一類型值的集合。通過一個整型下标可以通路數組中的每一個值。在聲明數組變量時， 需要指出數組類型 （資料元素類型緊跟 [] ) 和數組變量的名字。一旦建立了數組，就不能再改變它的大小。
7.1 一維數組
//靜态初始化
//靜态初始化的同時就為數組元素配置設定空間并指派
int[] array1 = {1, 2, 3, 4};
//動态初始化
int[] array2 = new int[4];
array2[0] = 1;
array2[1] = 2;
array2[2] = 3;
array2[3] = 4; 7.2 二維數組
//靜态初始化
int[][] array3 = {{1, 2}, {2, 3}, {4, 5}};
//動态初始化
int[][] array4 = new int[2][3];
array4[0][0] = 12;
array4[0][1] = 34;
array4[0][2] = 93;
array4[1][0] = 12;
array4[1][1] = 34;
array4[1][2] = 93; 7.3 周遊數組
//for循環
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]);
}
//for each循環
for (int i : array1) {
System.out.println(i);
} 八、控制流程
8.1 條件分支
int n = 19;
if (n < 10) {
System.out.println(n + " < 10");
} else if (n < 50) {
System.out.println("10 < " + n + " < 50");
} else {
System.out.println("50 < " + n);
} 8.2 開關分支
int n = 1;
switch (n) {
case 1:
System.out.println("n = 1");
break;
case 2:
System.out.println("n = 2");
break;
case 3:
System.out.println("n = 3");
break;
default:
System.out.println("n未知");
break;
} 8.3 循環
Integer[] integers = new Integer[5];
integers[0] = 0;
integers[1] = 1;
integers[2] = 2;
integers[3] = 3;
integers[4] = 4;
//for循環
for (int i = 0; i < integers.length; i++) {
System.out.println(integers[i]);
}
//for each循環
for (Integer integer : integers) {
System.out.println(integer);
}
//while循環
int j = 0;
while (j < integers.length) {
System.out.println(integers[j]);
j++;
}
//do while循環
int m = 0;
do {
System.out.println(integers[m]);
m++;
} while (m < integers.length); 轉載于:https://www.cnblogs.com/vivfeng/p/10048363.html