Java語言概述

1、關鍵字&標識符

關鍵字：被Java語言賦予了特殊含義，用作專門用途的字符串（單詞）
標識符：凡是本身能夠起名字的地方都叫標識符

1. 命名的規範（必定要遵照，不遵照就會報編譯的錯誤）

• 由26個英文字母大小寫，0-9 ，_或 $ 組成
• 數字不能夠開頭。
• 不可使用關鍵字和保留字，但能包含關鍵字和保留字。
• Java中嚴格區分大小寫，長度無限制。
• 標識符不能包含空格。

2. Java中的名稱命名規範：（不遵照，也不會出現編譯的錯誤）

• 包名：多單詞組成時全部字母都小寫：xxxyyyzzz
• 類名、接口名：多單詞組成時，全部單詞的首字母大寫：XxxYyyZzz
• 變量名、方法名：多單詞組成時，第一個單詞首字母小寫，第二個單詞開始每一個單詞首字母大寫：xxxYyyZzz
• 常量名：全部字母都大寫。多單詞時每一個單詞用下劃線鏈接：XXX_YYY_ZZZ

3. 註釋:用於說明代碼的用途和做用,方便讀寫和維護

• HTML註釋:
• Java註釋:
• //單行註釋
• /* 多行註釋 */
• /** 文檔註釋 */

2、變量

變量是java程序中最基本的存儲單元,能夠存儲一個數據
java中變量按照數據類型來分類：基本數據類型 vs 引用數據類型(數組 類 接口)

1. 基本數據類型

• 整型：byte（8 bit） short int（默認類型） long
• 浮點型：float double (默認類型) float類型的數據: 必須在小數末尾添加上"F"或"f"
• 字符型：char（‘ ’）(1字符=2字節)
• 布爾類型： boolean（只能取值爲true 或false，不能取null）
• 補充：按照在類中存在的位置的不一樣：成員變量 vs 局部變量

2. 局部變量

• 局部變量必須編寫在方法體中
• 局部變量只能在當前方法體中被訪問
• 局部變量在使用以前,必須被賦值

3. 成員變量

• 全局變量只能編寫全部方法體以外
• 全局變量能夠在任何方法體中被訪問
• 全局變量在使用以前若是沒有賦值,系統將自動賦予默認值
• 全局變量的操做,會應用其餘引用了該變量的代碼

4. 基本數據類型的默認值

• 整數: 0
• 小數: 0.0
• 字符: 空格 或 0
• 布爾: false

3、變量的運算

1. 自動類型轉換

容量小的數據類型自動轉換爲容量大的數據類型，

此時的容量大小指的是數的範圍的大小

byte、char、short、--->int --->long --->float --->double

short s = 12;
int i = s + 2;
注意：byte short char之間作運算，結果爲int型！

2. 強制類型轉換

將取值範圍大/精度高的數據類型 轉爲 取值範圍小/精度低的數據類型

• 是①的逆過程。使用「（）」實現強轉
• 強制類型轉換可能精度損失

double d1 = 12.9;
int t1 = (int)d1;//截斷操做
System.out.println(t1);

3. 練習

char c = 'a';
int num = 10;
string str = "hello";
System.out.println(c + num + str); //107hello
System.out.println(c + str + num); //ahello10
System.out.println(c + (num + str)); //a10hello
System.out.println((c + num) + str); // 107hello
System.out.println(str + num + c); // helloa10

4、運算符

運算符是一種特殊的符號，用以表示數據的運算、賦值和比較等

1. 算術運算符

+ - + - * / % ++ -- +

1. /: int i = 12; i = i / 5;
2. %：最後的符號只跟被模數相同
3. 前++：先+1，後運算 後++：先運算，後+1
4. +：String字符串與其餘數據類型只能作鏈接運算，且結果爲String類型。sysout('' + '\t' + ''); vs sysout("" + '\t' + '')

2. 賦值運算符

= += -= *= /= %=

int i= 12；
i  = i * 5;
i *= 5;//與上一行代碼一樣的意思
//【特別地】
short s = 10;
s = s + 5;//報編譯的異常
s = (short)(s + 5);
s += 5;//s = s + 5，可是結果不會改變s的數據類型。

int m = 2;
int n = 3;
n *= m++;
Sysout(m);// 3
Sysout(n);// 6

int n = 10;
n += (n++) + (++n); //32

變量A++ 與 ++變量A的區別

• 變量A++ / ++變量A: 變量A+1,將結果賦給變量A
• 變量A-- / --變量A: 變量A-1,將結果賦給變量A
• 變量A=變量B++/--:先將變量B的值賦給變量A,而後執行變量自增或自減1 ,先賦值,後自增/自減
• 變量A=++/--變量B:先執行變量B自增或自減1,而後將變量B的值賦給變量A ,先自增/自減,後賦值

3. 比較運算符

== > < >= <= instanceof

【注意】區分== 與 = 區別。
進行比較運算操做之後，返回一個boolean類型的值
4>=3 表達的是4 > 3或者 4 = 3.結果是true。

if(i > 1 && i < 10){ }
不能寫爲：if(1 < i < 10){}

4. 邏輯運算符（運算符的兩端是boolean值）

& && | || ^ !

【注意】區分 & 與 && 的區別，以及 | 與 || 的區別咱們使用的時候，選擇&& ， ||

| || ,& &&區別

• &:分別比較先後兩個條件,當先後兩個條件都爲true時,總體爲true,不然爲false.
• &&[短路與]:當先後兩個條件都爲true時,總體爲true,不然爲false. 若是第一個爲false時,將再也不判斷以後的條件,將直接返回false
• |:分別判斷先後兩個條件,至少有一個爲true時,總體爲true,不然爲false.
• ||[短路或]:當先後兩個條件至少有一個爲true時,總體爲true,不然爲false. 若是第一個條件爲true時,將再也不判斷以後的條件,直接返回true.

5. 位運算符(兩端是數值類型的數據)

<< >> >>> & | ^ ~

• << 在必定範圍內，每向左移動一位至關於 * 2

【例子】1.如何交換m = 12和n = 5的值
2.將60轉換爲十六進制輸出。

m = m + n;
n = m - n;
m = m - n;
// 好處不用定義變量，但有侷限性，只能用數值類型

6. 三元運算符:(條件表達式)？ 表達式1 ： 表達式2

1. 既然是運算符，必定會返回一個結果，而且結果的數據類型與表達式1，2的類型一致
2. 表達式1與表達式2 的數據類型一致
3. 使用三元運算符的，必定能夠轉換爲if-else。反之不必定成立

5、流程控制

1. 分支結構

1. 條件判斷

三種格式

①if(條件表達式){   }

②if(條件表達式){
    //執行的語句1；
  }else{
    //執行的語句2；
  }

③if(條件表達式1){
    //執行的語句1；
  }else if(條件表達式2){
    //執行的語句2；
  }else if( 條件表達式3){
    //執行的語句3；
  }...
  }else{
    //執行的語句；
  }

注意：

• 一旦知足某個條件表達式，則進入其執行語句塊執行，執行完畢，跳出當前的條件判斷結構，不會執行其如下的條件結構語句
• 若是諸多個條件表達式之間爲「互斥」關係，多個結構能夠上下調換順序
• 若是諸多個條件表達式之間爲「包含」關係，要求條件表達式範圍小的寫在範圍大的上面

2. 選擇結構

switch(變量){
    case 值1:
        
    break;
	case 值2:
        
	break;
	...
	default:

	break;
}

注意：

• 變量能夠爲以下的數據類型：byte short int char 枚舉 String
• case後只能填寫變量的值，不能寫範圍
• default是能夠省略的。而且其位置也是靈活的，可是一般將其放在case語句以後
• 一旦知足某個case語句，則進入執行其操做。直至遇到break或者程序終止
• 若要判斷的語句的條件知足switch變量的數據類型，且值很少的狀況下，建議選擇switch-case,除此以外，選擇if-else.

2. 循環結構

1. 三種格式

①初始化條件
②循環條件 boolean類型
③迭代部分
④循環體

for(①;②;③){
    ④
}
①
while(②){
    ④
    ③
}

①
do{
    ④
    ③
}while(②);

// 遍歷100之內的偶數
for(int i = 1; i<100; i++){
	if(i % 2 == 0){
		System.out.println(i);
    }
}

注意：

• 不一樣的循環結構之間能夠相互轉換
• while和do-while的區別：do-while程序至少會執行一次

2. 嵌套循環

循環結構還能夠聲明循環。讓內層循環結構總體充當外層循環的循環體。
若外層循環執行m次，內層循環執行n次，整個程序執行m*n次

//題目
******
******
******
for(int i = 0;i < 3;i++){
    for(int j = 0;j < 6;j++){
        System.out.print("*");
    }
    System.out.println();
}
//說明：外層循環控制行數，內層循環控制列數

3. 無限循環結構

for(;;){
   ...
   if(  ){
    break;
   }
   ...
}
//或者
while(true){
   ...
   if(  ){
    break;
   }
   ...
}

每每咱們在無限循環結構內部提供循環的終止條件，使用break關鍵字。不然，此循環將無限制的執行下去，造成死循環,死循環是咱們要避免的

4. break & continue

• break:

  使用switch-case結構或者循環結構中

  在循環結構中，一旦執行到break，就跳出當前循環。

• continue:使用在循環結構中

  • 一旦執行到continue，就跳出當次循環。

for(int i = 1;i <= 10;i++){
    if(i % 4 == 0){
        //break; //123
        continue;  //123567910
    }

    System.out.print(i);
}

在嵌套循環中，使用帶標籤的break和continue

label:for(int i = 1;i < 5;i++){
    for(int j = 1;j <= 10;j++){
        if(j % 4 == 0){
            //break;
            //continue;
            //break label;
            continue label;
        }
        System.out.print(j);
    }
    System.out.println();
}

6、例題

1. 最大公約數和最小公倍數

/*
題目：輸入兩個正整數，求最大公約數和最小公倍數
好比：12和20的最大公約數是4，最小公倍數是60
*/
Scanner scan = new Scanner(System.in);
System.out.println("請輸入第一個正整數：");
int m = scan.nextInt();
System.out.println("請輸入第二個正整數：");
int n = scan.nextInt();
// 獲取這兩個數中的最小值
int min = (m <= n) ? m : n;
for(int i = min; i > 0; i--){
    if(m % i == 0 && n % i == 0 ){
        System.out.println("最大公約數爲："+i);
        break;
    }
}

// 獲取這兩個數中的最大值
int max = (m <= n) ? n : m;
for(int i = max; i <= n*m; i++){
    if(i % m == 0 && i % n == 0 ){
        System.out.println("最小公倍數爲："+i);
        break;
    }
}

2. 質數

//100之內的質數的輸出
boolean isFlag = true;

for(int i = 2; i <= 100; i++){
	for(int j = 2; j < i; j++){
        if(i % j == 0){
            isFlag = False;
            break;
        }
	}
    if(isFlag == ture){
		System.out.println(i);
    }
    isFlag = true;
}


// 優化
 
boolean isFlag = true;

for(int i = 2; i <= 100; i++){
    // j < i的開方
	for(int j = 2; j <= Math.sqrt(i); j++){
        if(i % j == 0){
            isFlag = False;
            break;
        }
	}
    if(isFlag == ture){
		System.out.println(i);
    }
    isFlag = true;
}