java基礎語法1 -狂神說

阿新 • • 發佈：2020-08-06

JAVA基礎語法

註釋、識別符號、關鍵字

註釋

平時我們編寫程式碼，如果程式碼量小的時候，我們可以看懂，如果多的時候，時間久後容易看不懂。
註釋不會被執行，是我們寫給寫程式碼人看的
書寫程式碼是個很好的習慣
平時寫程式碼一定要注意規範

java註解有三種：

單行註釋//
多行註釋/**/
文件註釋/*** */
idea快捷鍵ctrl+/

關鍵字

關鍵字不能修改名字

識別符號

JAVA的組成部分都需要名字、類名、變數名以及方法名都稱為表示符

1 、類名 2、方法名 3、變數名；

識別符號注意點：

所有的識別符號都應該以字母（A-Z或者a-z），所有的識別符號都應該以字母（A-Z或者a-z），美元符($)，或者下劃線（_）開始;"大小寫十分敏感“

首字母之後可以是字母（A-Z或者a-z），美元符($)，或者下劃線（_）或者數字的任何字元組合;“特殊符號不能使用”
不能使用關鍵字作為變數名或者方法名。
合法識別符號舉例：age、 $salary、 _value、 __1_value
非法識別符號舉例：123abc、 -salary、 #abc
可以使用中文命名，但是一般不建議這樣去使用，也不建議使用拼音，很Low

資料型別

強型別語言

要求變數的使用嚴格符合規定，所有變數都必須先定以後才能使用；安全性高，但是速度慢。

弱型別語言

弱型別語言也稱為弱型別定義語言。與強型別定義相反。像vb，php等就屬於弱型別語言·

型別分類

Java的資料型別分為倆大類

基本型別

整數：
- byte 1位元組 8位 java範圍2（7）-1到-2（7）
- short 2位元組很少使用 2（15）-1到-2（15）
- int 4位元組最常用 2（31）-1到-2（31）
- long 8位元組長整形 2（63）-1到-2（63）

小數：
- float 4位元組
- double 8位元組

其它
char 2位元組無符號 2（15）-1
boolean 1位元組代表真true or 假false

引用型別
String 字串

位元組

位（bit）:是計算機內部資料儲存的最小單位，11001100是一個八位二進位制數。
位元組（byte）：是計算機中資料處理的基本單位，習慣上用大寫B來表示。
1B（byte,位元組） = 8bit（位）
字元：是指計算機中使用的字母、數字、字和符號
1bit表示1位
1Byte表示一個位元組 1B=8b
1024B=1KB
1024KB=1M

1024M=1G

型別轉換

由於java是強型別語言，所有需要運算的時候的，需要用到型別轉換。

低----------------------------------------------------------》高

byte， short， char -> int -> long -> float -> double
（小數的優先順序高於整數）

運算中，不同型別的資料先轉換為同一型別，然後進行運算。

-強制型別轉換高-->低

自動型別轉換

由低到高直接輸入，無需強制轉換
注意
1. 不能對布林值進行轉換
2. 不能把物件型別轉化為不相關的型別
3. 在把高容量轉換為低容量時，需要強制轉換
4. 轉換的時候可能存在記憶體溢位或者精度問題！

char 轉化為 int

溢位問題

變數

變數是什麼：就是可以變化的量！
Java是一種強型別語言，每個變數都必須宣告其型別。
java變數是程式中最基層的儲存單元，其要素包括變數名，變數型別和作用域。
注意事項：
1. 每個變數都有型別，型別可以是基本型別，也可以是引用型別
2. 變數名必須是合法的識別符號
3. 變數宣告是一條完整的語句，因此每個宣告都必須以分號結束。

變數的作用域

類變數

在類裡，整個類裡可以使用，前面必須加static；“static int a = 666”

例項變數

在類裡，從屬於物件；“int age;//0”

如果不自行初始化，這個型別的預設值 0,0.0

布林值：預設是false；除了基本型別，其他的預設值都是null；

區域性變數

在方法中，使用時必須宣告和初始化值；“int cba = 666;"

常量

常量（Constant)：初始化（initialize）後不能再改變值！不會變動的值。
所謂常量可以理解成一種特殊的變數，他的值被設定後，在程式執行過程中不允許被改變。

final 常量名 = 值；
final double PI = 3.14;

常量名一般使用大寫字元。

變數的命名規範

所有變數、方法、類名：見名其意
類成員變數：首字母小寫和駝峰原則：monthSalary
除了第一個單詞外，後面的單詞首字母大寫
區域性變數：首字母小寫和駝峰原則
常量：大寫字母和下劃線 MAX_VALUE
類名：首字母大寫和駝峰原則：Man,GoodMan
方法名：首字母小寫和駝峰原則：run(),runRun()

運算子

Java語言支援如下運算子：優先順序：最好使用（）

算術運算子：+，-，*，/，%（餘），++（自增），–（自減）；
賦值運算子：=；
關係運算符：> , < , >= , <= , == , != , instanceof；
計算結果一定是true or false；以後會和if一起用
邏輯運算子：&& （與）， ||（或），！（非）；
計算結果一定是true or false
位運算子：&，|，^，~，>>，<<，>>>；
條件運算子：？，：；
擴充套件賦值運算子：+=，-=，*=，/=；

算術運算子

++（自增）
a++ ： ++在後時，先賦值，再自增；
++a：++在前時，先自增，再賦值；

int a = 5;
int b = a++;//a++加在後，先給b賦值，再自增；
System.out.println(a);//a=6
System.out.println(b);//b=5
================================================
int c = ++a;//++a加在前，先自增，再賦值給c；
System.out.println(a);//a=6;
System.out.println(c);//c=6;

-（自減）同理

注意事項

算術運算使用中，有一個為long或者double型別，其結果為long或者double型別，不然為int型別
很多運算java，會使用一些很多工具類來操作

邏輯運算子

&&（與）：邏輯與運算，來個變數都為真，結果才為true
||（或）：邏輯或運算，兩個變數有一個為真，結果才為true
！（非）：如果是真，則變為假，如果是假則變為真

int q = 10;
int  w = 20;
System.out.println(q<w && w>30);//（false)，q<w正確，w>30錯誤,
// 可解釋為:q<w與w>30同時兩條成立，結果為true，所以最後結果為"false"
System.out.println(q<w || w>30);//（true),q<w正確，w>30錯誤,
// 可以解釋為:q<w或w>30其中一條成立，結果就為true，所以最後結果為"true"
System.out.println(!(q<w));//（false),q<w正確。
// 可以解釋為:q應該不（非）小於w，但是實際上q<w，所以為”false"

斷路運算

當前面為“false”時，後面的將不執行，只有“true”才會執行，這就叫短路運算。

int z = 5;
boolean x = (z<4)&&(z++<4);//由於（z<4）不成立為false，（z++<4)就不執行
System.out.println(x);//(false)
System.out.println(z);//(5)由於（z++<4)沒有運算，所以z沒有自增

位運算子

& （1）：全部為1才為1，否者為0

| （0）：全部為0才為0，否者為1

^（同0）：相同為0，否者為1

~（取反）：取二進位制相反的數

 A = 1100 0011
 B = 1001 0110
---------------
A&B= 1000 0010
A|B= 1101 0111
A^B= 0101 0101
~B = 0110 1001

"<<"二進位制左位移=代表*2

">>"二進位制右位移=代表/2

擴充套件運算子

+=，-=，*=，/=;()

int a = 5, b = 10;
a+=b;//a=a+b(15)
a-=b;//a=a-b(-5)
a*=b;//a=a*b(50)
a/=b;//a=a/b(0.5)

字串連線符

在“+”號前出現string型別時，他會把“+”後面的一運算元，轉換成steing型別，進行拼接

 int a = 5, b = 20;
System.out.println("yes"+a+b);//(yes520)
System.out.println(a+b+"yes");//(25yes)
System.out.println("yes"+(a+b));//(yes25)
System.out.println(""+a+b+"yes");//(520yes)
System.out.println(""+a+b+(a+b)+"yes");//(52025yes)

條件運算子

x？ y：z //x值如果為true=y，如果為false=z；

int score = 60;
int xm = 70;
int xg = 49;
int xh = 60;
System.out.println("xm:"+(xm>=score ?"及格":"不及格"));//(xm:及格)
System.out.println("xg:"+(xg>=score ?"及格":"不及格"));//(xg:及格)
System.out.println("xh:"+(xh>=score ?"及格":"不及格"));//(xh:及格)

後期可以使用if做

包機制

“包的本質就是資料夾”

為了更好地組織類，Java提供了包機制，用於區別類名的名稱空間。
包語法的語法格式為：

package pkg1[.pkg2[.pkg3...]]//定義包

一般利用公司域名倒置作為包名；
為了能夠使用某一個包的成員，我們需要在Java程式中明確匯入該包。使用"import"完成此功能

import package1[.package2...].(classname|*);//匯入包，*匯入這個包下所以的類

儘量不要把包名重複

JavaDoc

javadoc命令是用來生成自己API文件的
引數資訊
- @author作者名
- @version版本號
- @since 指明需要最早使用的jdk版本
- @param 引數名
- @return 返回值情況
- @throws 異常丟擲情況

/**
 * @author ssxxz
 * @version 1.0
 * @since 1.8
 */

JAVA流量控制

使用者互動Scanner

Scanner

之前我們學習的基本語法中，我們並沒有實現程式和人的互動，但是Java給我們提供了這樣一個工具類，我們可以獲得使用者的輸入。java.util.Scanner是java5特性，我們可以通過Scanner類來獲取使用者的輸入。
基本語法

Scanner s = new Scanner(System.in);

通過 Scanner 類的next() 與 nextLine() 方法獲取輸入的字串，
在讀取前我們一般需要使用 hasNext() 與 hasNextLine() 判斷是否還有輸入的資料。
next():
1. 一定要讀取到有效字元後才可以結束輸入。
2. 對輸入有效字元之前遇到空白，next（）方法會子弟用去掉
3. 只有輸入有效字元後才將其後面輸入的空白作為分隔符或者結束符
4. next（）不能得到帶有空格的字串。
nestLine（）：
1. 以Enter為結束符也就是說nextLine()方法返回的是輸入回車之前的所有字元。
2. 可以獲得空白。

import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        Scanner ssxxz = new Scanner(System.in); //建立一個掃描器物件，用於接受鍵盤資料
        System.out.println("請輸入：");
            String str = ssxxz.nextLine();//使用nextLine方式接收
            System.out.println("輸出為："+str);//程式會等待使用者輸入完畢
        //凡是屬於IO流的類，如果不關閉會一直佔用資源，要養成好習慣用完就關閉掉
        ssxxz.close();
    }
}

if判斷語句，while迴圈語句
if

import java.util.Scanner;
public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //從鍵盤接收資料
        int i = 0;
        float f = 0.0f;
        System.out.println("請輸入整數：");
        //如果...那麼...
        if (scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整數資料："+i);
        }else{
            System.out.println("輸入的不是整數資料！");
        }
        System.out.println("請輸入小數資料：");
        if (scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小數資料："+f);
        }else{
            System.out.println("輸入的不是小數資料！");
        }
        scanner.close();
    }

}

while

import java.util.Scanner;
public class Demo05 {
    public static void main(String[] args) {
        //我們可以輸入多個數字，並求其總和與平均數，每輸入一個數字用回車確認，通過輸入非數字來結束輸入並輸出執行結果。
        Scanner scanner = new Scanner(System.in);
        //和
        double sum = 0;
        //計算輸入了多少個數字
        int m = 0;

        System.out.println("請輸入資料：");
        //通過迴圈判斷是否還有輸入，並在裡面對每一次進行求和和統計
        while(scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m = m +1;//m++
            sum = sum+x;
            System.out.println("當前是第："+m+"個，sun總數為："+sum);
        }
        System.out.println(m+"個數的和為："+sum);
        System.out.println(m+"個數的平均值是："+(sum/m));
      scanner.close();
    }
}

順序結構

JAVA的基本結構就是順序結構，排除特別指明，否則就是按照順序一句一句執行。
順序結構是最簡單的演算法結構。
語句與語句之間，框與框之間是按從上到下的順序進行的，它是由若干個依次執行的處理步驟組成的，它是任何一個演算法都離不開的一種基本演算法結構。

選擇結構

if單選結構
if雙選擇結構
if多選擇結構
巢狀的if結構
switch多選擇結構

if單選擇結構

我的很多時候需要去判斷一個東西是否可行，然後我們才去執行，這樣一個過程在程式中用if語句來表示。
語法：

if(布林表示式)｛
    //如果布林表示式為true將執行的語句
    ｝

語句：

import java.util.Scanner;
public class ifDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("請輸入咒語：");
        String s = scanner.nextLine();
        //equals:判斷字串是否相等
        if (s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}

if雙選擇結構

語法

if（布林表示式）｛
    //如果布林表示式的值為true
    ｝else{
    //如果布林表示式的值為false
}

語句：

import java.util.Scanner;
public class IfDemo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("請輸入你的成績：");
        int c = scanner.nextInt();
        if (c>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

if多選擇結構

我們發現剛才的程式碼不符合時間情況，真實的情況還可能存在ABCD,存在區間多級判斷，比如90-100就是A，80-90就是B…等等，在生活中我們很多時候的選擇也補僅僅只有兩個，所以我們需要一個多選擇結構來處理這類問題!
語法

if（布林表示式1）｛
    //如果布林表示式1的值為true執行程式碼
    ｝else if（布林表示式2）｛
    //如果布林表示式2的值為true執行程式碼
    ｝else if（布林表示式3）｛
    //如果布林表示式3的值為true執行程式碼
    ｝else{
    //如果以上布林表示式都不為true執行程式碼
}

if 語句最多有1個 else 語句，else 語句在所以 else if 語句之後。

if 語句可以有若干個 else if 語句，它們必須在 else 語句之前。

一旦其中一個 else if 語句檢測為 true，其它的 else if 以及 else 語句都將跳過執行。

巢狀的if結構

使用巢狀的 if…else 語句是合法的。也就是說你可以在另一個 if 或者 else if 語句中使用 if 或者 else if 語句。你可以像 if 語句一樣巢狀 else if…else。
語法：


if(布林表示式 1){
    //如果布林表示式 1的值為true執行程式碼
    if（布林表示式 2）{
        //如果布林表示式 2的值為true執行程式碼
    }
}

switch多選擇結果

多選擇結構還有一個實現方式就是 switch case 語句。
switch case 語句判斷一個變數與一個系列值中某個值是否相等，每個值稱為一個分支。

//switch 匹配一個具體的值
switch(expression){
    case value :
        //語句
        break://可選，主要功能防止case穿透
    case value:
        //語句
        breck://
     //你可以有任意數量的case語句
    default://可選，當出現無法匹配任何case時，可以用default表達
        //語句
}


public static void main(String[] args){
     char grade = 'B';
     switch (grade){
     case 'A':
     System.out.println("優秀")；
     break;
     case 'B':
     System.out.println("及格")；
     break;
     case 'C':
     System.out.println("一般")；
     break;
     default:
     System.out.println("未知等級")
}

迴圈結構


- switchi 語句中的變數型別可以是：

- byte、short、int 或者 chat.
- **從 Java SE 7開始**
- **switch 支援字串 String 型別**
- 同時 case 標籤必須為字串常量或字元量

### 迴圈結構

- while 迴圈
- do...while 迴圈
- for 迴圈



- 在Java5中引入了一種主要用於陣列的增強型for迴圈。

#### while迴圈

- while是最基層的迴圈，它的結構為：

```java
while(布林表示式){
   //迴圈內容
}

只有布林表示式為 true,迴圈就會一直執行下去。
我們大多數情況是會讓迴圈停止下來的，我們需要一個讓表示式失敗的方式來結束迴圈。
少部分情況需要迴圈一直執行，比如伺服器的請求響應監聽等。
迴圈條件一直未true就會造成無限迴圈【死迴圈】，我們正常的業務程式設計中應該儘量避免死迴圈，會影響程式效能或者造成程式卡死崩潰！

計算1+2+3+…+100=？

public class whileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        while(i<=100){
            sum = sum+i;
            i++;
            System.out.println(sum);
        }
        System.out.println(sum);
    }
}

do...while迴圈

對於while語句而言，如果不滿足條件，則不能進入迴圈。但有時候我們需要即使不滿足條件，也至少執行一次。
do … while 迴圈和 while 迴圈相似，不同的是， do … while 迴圈至少會執行一次

do{
    //程式碼語句
    while(布林表示式)
}

While 和 do-While 的區別：

while先判斷後執行。dowhile是先執行後判斷！
Do … while 總是保證迴圈體會被至少執行一次！這是他們的主要差別。

public class whileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do {
            sum = sum+i;
            i++;
        } while(i>100);
        {
            System.out.println("sum="+sum);
            System.out.println("i="+i);
        }
        System.out.println("最終結果："+sum);
    }
}

for迴圈

雖然所有迴圈結構都可以用 while 或者 do…while 表達，但是Java提供了另外一種語句 ——for迴圈，使一些迴圈結構變得更加簡單。
for迴圈語句是支援送代的一種通用結構，是最有效，最靈活的迴圈結構。
for迴圈執行的次數是在執行前就確定的。
語法

for(初始化；布林表示式；更新)｛
    //程式碼語句
   ｝

     - 最先執行初始化步驟，可以宣告一種型別，但可初始化一個或者多個迴圈控制變數，可以是空句
      - 然後，檢測布林表示式的值，如果是true，迴圈體被執行，如果為false，迴圈終止，開始執行迴圈體後面的語句。
      - 執行一次迴圈後，更新迴圈控制變數（送代因子控制迴圈變數的增減）。
      - 再次檢查布林表示式，迴圈執行上面的過程。

練習1：計算0到100之間的奇數和偶數的和
練習2：用while或者for迴圈輸出1-1000之間能被5整除的數，並且每行輸出3個。
練習3：列印九九乘法表

public class ForDemo01 {
    public static void main(String[] args) {
        int oddSum = 0;
        int evenSum = 0;
        for (int i = 0; i <=100; i++) {
            if (i%2!=0){
                oddSum=oddSum+i;
            }else {
                evenSum=evenSum+i; 
            }
        }
        System.out.println("偶數合計為："+oddSum);
        System.out.println("奇數合計為："+evenSum);
    }
}

public class ForDemo02 {
    public static void main(String[] args) {
        System.out.println("5的倍數：");
        for (int i = 1; i <=1000; i++) {
            if (i%5==0){
                System.out.print(i+" ");//可以（i+"\t"）
            }
            if (i%(5*3)==0){
                System.out.println();//可以print("\n")
            }
        }
    }
}

while

   public static void main(String[] args) {
       int i = 1;
       while (i<=100){
           if (i%5==0){
               System.out.print(i+" ");
           }
           if(i%15==0){
               System.out.println();
           }i++;
           }
       }
   }

public class ForDemo04 {
 public static void main(String[] args) {
     System.out.println("九九乘法表：");
     for (int j = 1; j < 10; j++) {
         for (int i = 1; i <= j; i++) {
             System.out.print(i + "*" + j + "=" + (i * j)+" ");
         }
         System.out.println();
     }
 }
}

增強for迴圈

這裡我們先只是見一面，做個瞭解，之後陣列我們重點使用。
Java5 引入了一種主要用於陣列或集合的增強型 for 迴圈。
Java 增強 for 迴圈語法格式如下：

for(宣告語句：表示式)
{
    //程式碼句子
}

宣告語句：宣告新的區域性變數，該變數的型別必須和陣列元素的型別匹配。其作用域限定在迴圈語句塊，其值與此時陣列元素的值相等。
表示式：表示式是要訪問的陣列名，或者是返回值為陣列的方法。

    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50};//定義了一個數組
        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }
        System.out.println("===============================");
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

break&continue

break 在任何迴圈語句的主體部分，均可用 break 控制迴圈的流程。break 用於強行退出迴圈，不執行迴圈中剩餘的語句。（break語句也在switchi語句中使用）。

    public static void main(String[] args) {
        int i = 0 ;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }
            System.out.println("break："+i);//break強制結束，雖然程式還未到達條件（i<100），但是迴圈已結束。
        }
        System.out.println("程式結束！");//迴圈外的程式還可以執行
    }
}

continue 語句用在迴圈語句體中，用於終止某次迴圈過程，即跳過迴圈體中尚未執行的語句，接著進行下次是否執行迴圈的判定。
關於 goto 關鍵字
1. goto 關鍵字很早就在程式設計語言中出現，儘管 goto 仍是 Java 的一個保留字，但並未在語言中得到正式使用； Java沒有 goto 。然而，在 break 和 continue 這兩個關鍵字的身上，我們仍然能看出一些 goto 的影子—帶標籤的 break 和 continue。
2. “標籤”是指後面跟一個冒號的識別符號，例如： label:
3. 對 Java 來說唯一用到標籤的地方是在迴圈語句之前。而在迴圈之前設定標籤的唯一理由是：我們希望在其中巢狀另一迴圈，由於 break 和 continue 關鍵字通常只中斷當前迴圈，但若隨同標籤使用，它們就會中斷到存在標籤的地方。

public static void main(String[] args) {
    outer: for (int i=101;i<150;i++){
        for(int j=2;j<i/2;j++){
           if (i%j==0){
               continue outer;//滿足條件後回到 outer 記錄位置從新執行。
          }
        }
        System.out.println(i);
    }
}

練習

列印三角形

        for (int i = 1; i <= 5; i++) {
                for (int j = 5; j >=i; j--) {
                    System.out.print(" ");
        }
                for (int j = 1; j <=i; j++){
                System.out.print("*");
            }
                for (int j = 1; j < i; j++){
                    System.out.print("*");
                }
                System.out.println();
    }
}