標識符與關鍵字
Java語言字符集採用16位Unicode字符編碼
Java關鍵字及作用
標識符命名規則：
以字母開頭的字母數字序列：字母（大小寫英文字母、下劃線_、符號$），數字（0-9），不能使用關鍵字
基本數據類型
| 整數類型 | 字節數 | 取值範圍 |
|---|---|---|
| 字節型byte | 1 | -2^7 ~ 2^7 - 1 |
| 短整型short | 2 | -2^15 ~ 2^15 -1 |
| 整型int | 4 | -2^31 ~ 2^31-1 |
| 長整型long | 8 | -2^63 ~ 2^63-1 |
| 單精度浮點數float | 4 | 具體百度吧 |
| 雙精度浮點數double | 8 | 具體百度吧 |
變量與常量
變量：
保存在程序中可以被改變的數據，四要素（名字、類型、值、作用域）
最終變量：
採用關鍵子final聲明的變量，只能進行一次賦值
final int value; // 聲明時未賦值
value = 100; // 只能進行一次賦值
常量：直接常量、符號常量
直接常量
程序中直接引用的常量，包括數值型常量、字符串常量
符號常量
保存在程序中不能被改變的數值，常量名是標識符，用關鍵子final聲明
Java與約定常量標識符全部用大寫字母表示
final int MAX = 100;
final double PI = 3.1415926;
運算符與表達式
1）算術運算符
單目運算符：+（正）、-（負）、++（自增）、–（自減）
雙目運算符：+（加）、-（減）、*（乘）、/（除）
2）關係運算符
運算結果爲布爾類型
==（等於）、！=（不等於）、>（大於）、<（小於）、>=（大於等於）、 <=（小於等於）
3）位運算符
單目運算符：~（非）
雙目運算符：&（與）、|（或）、^（異或）、<<（左移位）、>>（右移位）、>>>（無符號右移位）
4）邏輯運算符
單目運算符：！（非）
雙目運算符：&（與）、|（或）、^（異或）、&&（條件與）、||（條件或）
5）賦值運算符
assignment(=、+=、-=、*=、/=、&=、|=、^=、<<=、>>=、>>>=)
6）類型強制轉換符
（int）(98.4+0.5)
7）條件運算符
子表達式1 ? 子表達式2 ：子表達式3；
8）括號運算符
用於改變表達式中運算符的優先級
9）字符串連接運算符
+ System.out.println("max =" +max);
10）點運算符
. 用於分隔包、子包、類、類中成員
11）對象運算符
instanceof 判斷一個對象是否屬於指定類或其子類，結果爲布爾類型
12）new運算符
new運算符用於申請數組的存儲空間，創建對象
運算符的優先級及結合性
運算符的類型兼容原則
byte > short > int > long > float > double
char > int > long > float > double
1.0+1 // 2.0
1.0 == 1 // true
'a' + 1 // 98
(char)('a' + 1) // 'b'
'a' == 97 // true
'a'| 2 // 99
boolean b = 0; // 語法錯，布爾類型不是整數
true == 1; // 語法錯，布爾量與整數不可運算
!0 // 語法錯，整數不可邏輯運算
int x,y,z;
x>y>z // 語法錯，必須寫成x > y && y > z
++x||++y&&++z // 語法錯，整數不可邏輯運算
++x|++y&++z // 整數進行位運算
x>y & y>z // 邏輯運算，沒有短路計算功能
long big = 6; // 自動轉化long
float z = 0.0 // 語法錯，0.0默認爲double，賦值不相容
流程控制語句
java語言的語法和c/c++類似，但是不支持goto
i+1; // java中語法錯誤，沒有賦值功能的表達式不能成爲語句
if ()
if()
else ...;
// else 與第二個if匹配， java中else總是與最近的if匹配
switch(表達式)
{
case 常量表達式1: ... ; break;
}
// switch 表達式支持 String
// Fibonacci 數列
public class Fibonacci
{
private static void main(String args[]){
short i = 0, j = 1;
do{
System.out.println(" "+i+" "+j);
i = (short)(i+j);
j = (short)(i+j);
}while(i < 0); // short 整數溢出循環停止
}
}
一維數組
// 聲明
int a[];
int[] a;
// 分配空間
a = new int[3];
int alen = 3;
a = new int[alen]; // 常量變量均可
// 數組長度
a.length
// 數組元素表示及運算
a[0] - a[a.length - 1];
// 數組聲明時賦值
int a[] = {1,2,3,4};
// 數組元素的初始化
java對所有使用new運算符動態分配的存儲單元都進行初始化
// 逐元循環
int a[] = {1,2,3};
for(int value: a){
System.out.print(" "+value);
}
// 數組的引用模型
int a[] = {1, 2, 3}, b[];
b = a; // 引用賦值，相當於兩個指針賦值
b[1] = 10;
a == b; // true
b[] = new int[a.length];
for(int i = 0; i < a.length; i++){ // for(int i: a)
b[i] = a[i];
}
a == b; // false
// 釋放數組
b = null; // 通常，程序不需要釋放數組，java將自動收回不再使用的數組佔用的存儲空間
二維數組
// 聲明二維數組
int mat[][];
mat= new int[4][5];
or
int mat[][] = new int[4][5];
// 聲明時初始化賦值
int mat[][] = {{1,2,3},{4,5,6}};
// 二維數組長度
mat.length // 二維數組的行數
mat[0].length // 二維數組的列數
// 引用模型
mat[0][0] - mat[mat.length - 1][mat[0].length - 1];
// 不規則二維數組
int mat[][] = new int[3][]; // 申請第一維存儲空間
mat[0] = new int[4]; // 申請第二維存儲空間
mat[1] = new int[3];
靜態函數
java語言沒有全局函數，函數聲明在類中，稱爲成員方法，有靜態方法和全局方法兩種
可以聲明形式參數爲final， 函數方法體中不可以對其賦值
java不支持類之外的全局變量
實際參數向形式參數傳遞原則
方法調用時給出的參數稱爲實際參數，可以是常量、變量、表達式或方法調用等，多個參數用逗號分隔。實際參數必須在數據類型、參數個數及次序等三方面與形式參數–對應。
方法調用的參數傳遞原則與賦值相同，實際參數向實際參數賦值。傳遞方式因形式參數的數據類型不同而不同，若是基本數據類型，則傳遞值；若是引用數據類型，則傳遞引用。
常量形式參數
public static int[] random(final int n){ // 聲明n爲常量，方法體中不能賦值
n = 10; // 錯， 不可以對常量賦值
}
public static int[] random(final int a[]){ // 聲明a數組爲常量，方法體中不可以修改引用
a[0] = 0; // 可以更改常量數組元素值
a = new int[3]; // 錯，不可以對常量賦值，即不能改變數組引用
}
可變形式參數
public static void print(int... value) // 可變形式參數，可將value視爲int[]類型， int... 不能與int[] 重載
方法重載
一個類中有多個同名方法但帶有不同參數列表，稱爲方法重載。
參數列表不同：數據類型，個數，次序不同 （不能以返回值相區別）
java方法聲明沒有參數默認值，避免二義性。
public static int[] random(int n, int max)
public static int[] random(){ return random(10, 100);}
int abs(int a)
long abs(long a)
float abs(float a)
double abs(double a)
遞歸方法
遞歸定義必須滿足：
1） 邊界條件：至少有一條初始定義是非遞歸的
2）遞推通式：由已知函數值逐步遞推出未知函數值
字符串
java字符串String是一個類，屬於引用數據類型
字符串的基本數據類型特性
1）字符串常量
字符串是由雙引號括起來表示的字符序列，可以包含轉義字符（“Hello!”, “漢子\n”）,字符串只能在同一行中，不可換行，空串長度爲0，一個字母，漢字均是java的一個字符，數據類型爲char, 佔2字節。
約定字符串中首字符的序號爲0， -1表示某字符不在指定字符串中。
2）字符串的變量及運算
// 賦值運算
String s1; // 聲明變量
String s2 = "abc"; // 聲明變量時賦初值 // s2非字符數組！！！
String s3 = s2; // 引用賦值
String s4 = String("abc");
// 單引號括起來的是字符常量，如'a'；用雙引號括起來的是字符串常量，如"a";所以有空串"",沒有'';兩種數據類型不兼容
String s5 = 'a'; // 錯，類型不兼容
// 連接運算
s1 = "abc" + "efg";
s2 += "abc"; // 只有 += 複合賦值運算符可以用在字符串上
String str = "" + 'a'; // 結果爲"a"
int i = 10;
System.out.println("i="+i); // 結果爲"i=10"
// 字符串不是字符數組
str[1]='a'; // 錯，沒有該表達式
str.charAt(i);
StringBuffer::SetcharAt(i); // 錯，常量字符串不能賦值
字符串的類特性
String 是一個類
public final class String implements java.io.Serializable,Comparable<String>,CharSequence{
public String(byte value[]) // 由默認編碼的字節數組構造字符串
public String(byte value[], int i, int n) // 由value數組從i開始長度到n的若干字節構造串
public int length() // 返回字符串的長度
public char charAt(int i) // 返回第i(i >= 0)個字符
public boolean equals(Object obj) // 比較當前串與obj引用的串是否相等
public String substring(int begin) // 返回從begin(>=0) 開始到尾串的子串
public String substring(int begin, int end) // 返回從begin開始到end-1的子串
public static String format(String format, Object... args) // 返回format指定格式字符串，可變形參
}
format 格式字符串定義：%[參數索引|$][寬度][.精度]變換類型
變換類型取值：
b(boolean)、c(字符)、C(字母大寫)、d(十進制整數)、o(八進制整數)、x(十六進制整數)、e(浮點數指數形式)、f(浮點數小數形式)、s(字符串字母小寫)、S(字符串字母大寫)
從標準輸入流中讀取一行字符串，再轉換位整數
public class Input {
public static String readLine() throws java.io.IOException
{
System.out.print("輸入一行字符串，以回車換行符結束： ");
byte buffer[] = new byte[512];
int count = System.in.read(buffer); // 從標準輸入流讀字節到緩衝區buffer
// read()方法接收字母和漢字，每個字符長度都是 1
System.in.close(); // 關閉標準輸入流
return (count == -1) ? null : new String(buffer, 0, count-2); // 不計回車換行符
}
public static void main(String[] args) throws java.io.IOException{
String s = readLine();
int value = MyInteger.parseInt(s); // 將字符串轉化爲整數
System.out.println("MyInteger.toString(" + value + ",2)=" + MyInteger.toString(value,2));
System.out.println("MyInteger.toString(" + value + ",16)=" + MyInteger.toString(value,16));
}
}
public class MyInteger {
// 返回將字符串s轉換的整數，自動識別進制，若不能識別整數，則拋出格式異常
public static int parseInt(String s) throws NumberFormatException{
if(s == null) throw new NumberFormatException("null");
char ch = s.charAt(0); // 獲得首字符，識別進制
int value= 0, i = 0, sign = 1, radix = 0;
if(ch >= '1' && ch <= '9' || ch == '+' || ch == '-'){ // 10進制
radix = 10;
if(ch == '+' || ch == '-' ){ // 跳過正負號
i++;
}
sign = ch == '-' ? -1 : 1;
}else if (ch == '0' && s.charAt(1) != 'x'){ // 8進制
radix = 8;
i++;
}else if (ch == '0' && s.charAt(1) == 'x'){ // 16進制
radix = 16;
i+=2;
}else
throw new NumberFormatException("整數不能識別\'" + ch + "\'字符");
while(i < s.length()){
ch = s.charAt(i++);
if(ch >= '0' && ch-'0' < radix) // radix <= 10 識別 0-9
value = value * radix + ch - '0';
else if (radix == 16 && ch >= 'a' && ch <= 'f')
value = value * radix + ch - 'a' + 10;
else if (radix == 16 && ch >= 'A' && ch <= 'F')
value = value * radix + ch - 'A' + 10;
}
return value * sign;
}
public static String toString(int value, int radix){
if(radix == 10) return value + "";
if(radix == 2 || radix == 4 || radix == 8 || radix == 16){
int mask, n = 0; // mask 獲得radix最大進制數
for(mask = radix - 1; mask > 0 ; mask >>>=1){ // n 獲得mask的二進制位數
n++;
}
mask = radix - 1;
char buffer[] = new char[(int)(32.0/n + 0.5)]; // 存儲一個int表示radix進制的各位
for(int i = buffer.length - 1; i >=0; i--){
int bit = value & mask; // 獲得radix進制的個位數字
buffer[i] = (char)(bit <= 9 ? bit + '0' : bit + 'a' - 10);
value >>>= n; // 右移n位，高位補0， 即value除以radix
}
return new String(buffer);
}
throw new IllegalArgumentException("radix 參數值" + radix + "表示的進制無效");
}
}