java語法

流程控制

Scanner物件

用來獲取使用者的輸入

Scanner s = new Scanner(System.in);

String str = s.nextLine(System.in);

獲取字串：nex（）、nextLine（）

判斷是否還有輸入的資料：hasNext（）、hasNestLine（） 一般在讀取資料前判斷

用完之後要關掉：s.close();

增強For迴圈

迴圈陣列和集合

for (宣告語句：表示式){

}

int[] numbers = {10,20,30,42};
for(int x:numvers){
    System.out.println(x);
}
 

方法

public static void Hello(){
    System.out.prinln("Hello World!");
}

public 公共的

static 靜態方法：獨立該類的任何物件，不依賴類特定的例項，被類的所有例項共享

• 能直接呼叫，不是static方法則需要例項化才能呼叫
• static方法不能呼叫非static方法 （static方法與類同時載入，非static方法在類例項化之後才載入）
• void 返回值

• 值傳遞：複製實參的值給形參
• 引用傳遞：對於物件，可以改變物件的屬性，本質還是值傳遞

方法的過載

方法名相同，但形參不同

• 方法名相同
• 引數列表不同
• 返回型別可以相同可以不同
• 僅僅返回型別不同不足以成為方法的過載

方法名相同時，編譯器根據呼叫方法的引數個數、型別等去匹配對應的方法

命令列傳參

cmd：java檔案路徑下編譯檔案 -> 退回到src檔案下執行（eg：java com.method.Demo01）並傳參

可變引數

在方法宣告中，在指定引數後加省略號

一個方法只能指定一個可變引數且必須時方法的最後一個引數

public static int add(int... num){
    
}

陣列

建立：dateType[] arrayRefVar = new dateType[arraySize];

Arrays類

面向物件

實質：以類的方式組織程式碼，以物件的組織（封裝）資料

一個類中只能有一個public

建立物件

使用new關鍵字建立物件

public class Student{
    String name;
    int age;
    public void study(){
        System.out.println(this.name+"在學習")；
    }
}

public class Application{
    public static void main(String[] args){
        Student lihua = new Student;
        System.out.println(lihua.name);
        lihua.study();
    }
}

類的構造器（構造方法）

• 例項化時會自動隱式定義，也可顯示定義
  • 必須與類的名稱相同
  • 沒有返回型別（不是void）
• 能例項化初始值
• 定義了有參構造，無參構造就必須顯示定義（儘量把無參構造顯化）

封裝

高內聚，低耦合

資料的隱藏

• 屬性私有：private關鍵字

private int name;

• get/set方法：可以操作私有屬性

public String getName{
    return this.name;
}
public void setName(String name){
    this.name = name;
}

繼承

對一批類的抽象

拓展：extends

public class Person{
    
}

public class Student extends Person(){
    
}

類只有單繼承，沒有多繼承

java中所有的類都預設繼承Object類

• this關鍵字：引用當前物件
• super關鍵字：引用父類物件

構造器

子類構造器預設呼叫父類構造器

呼叫構造器必須是建構函式主體的第一條語句（this()、super()）

public class Person{
    
}
public class Student extends Person(){
    public Student(){
        //super();預設呼叫父類構造器
    }
}

方法的重寫

重寫（Override）都是方法的重寫，與屬性無關

public class B(){
    public static void text{
        System.out.println("B->text()");
    }
}

public class A extends B{
    public static void text(){
        System.out.println("A->text()");
    }
}

public class A extends B{
    public static void main(String[] args){
        A a = new A();
        a.text();/*靜態方法：A->text()
        		   非靜態方法：A->text()
        		  */
        
        B b = new A();//父類的引用指向了子類
        b.text();/*靜態方法：B->text()
        		   非靜態方法：A->text()
        		  */
    }
}

• 靜態方法：方法呼叫只和定義的資料型別有關
• 非靜態方法：重寫了父類的方法，呼叫時使用的是重寫了之後的方法（需要用public）
• 修飾符：public > protected > default(預設) > private（範圍可以擴大但不能縮小）

多型

同一方法可以根據傳送物件的不同而採用不同的行為方式

一個物件的實際型別是確定的，指向的引用型別不確定

Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();

• 物件能執行的方法主要看定義的型別

• 多型存在的必要條件

  • 繼承
  • 重寫
  • 父類引用指向子類物件

• 關鍵字instanceof：a instanceof b判斷兩個物件之間是否存在父子關係（a（a的實際型別）是否是b的子類）

static

類載入時static方法就載入

public class Demo{
    static{}//靜態程式碼塊，最先載入，只執行一次
    {}//匿名程式碼塊，其次載入，可以用來賦初值
    public Demo(){}//構造器，最後載入
}

• 靜態匯入包:可以直接使用方法

import static java.lang.Math.random;

抽象類

• 關鍵字：abstract

不能new抽象類

抽象類裡可以寫普通方法

抽象方法必須在抽象類中

//抽象類
public abstract class Action{
    //約束，抽象方法
    public abstract void doSomething();
}

繼承了抽象類的子類必須實現抽象類的方法，除非子類也是抽象類

抽象類也存在構造器

介面

只有規範，不能寫方法，實現約束和實現分離：面向介面程式設計

• 關鍵字：interface

public interface UserService{
    //介面中的所有定義都是抽象的：public abstract（方法）、public static final（屬性）
    void add();
}

public interface TimeService{
    void time();
}

• 介面都需要有實現類

介面可以多繼承

//命名規則:介面名加Impl，用關鍵字implements實現
public UserServiceImpl implements UserService,TimeService{
    public void add(){
        
    }
    public void time(){
        
    }
}

內部類

成員內部類，靜態內部類

public class Outer{
    private int id;
    public void out(){
        System.out.println("外部")；
    }
    public class Inner{
        public void in(){
            System.out.println("內部")；
        }
        //能獲得外部類的私有屬性，加static之後（靜態內部類）則不能獲得
        public void getID(){
            System.out.println(id)；
        }
    }
}
//例項化
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

public class Demo01{
    
}
//一個類檔案中只能有一個public類
class Demo02{
    
}

區域性內部類

public class Demo01{
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

匿名內部類

public class Demo01{
    public void run(){
        
    }
}

new.Demo01().run();//沒有名字

異常

把異常當做物件處理，並定義一個基類java.lang.Throwable作為所有異常的超類

• 關鍵字：try、catch、finally、throw、throws

public class Demo01{
    public static void main(String[] args) {
        int a=1;
        int b=0;

        try{//try監控異常
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch(捕獲的異常型別)捕獲異常,可以寫多個，捕獲多個異常
            System.out.println("0");
        }finally{//善後，可以不使用，一般用於釋放資源
            System.out.println("finally");
        }
    }
    public void add(int a,int b) throws ArithmeticException{//方法上丟擲異常
        if(b==0){
            throw new ArithmeticException();//主動丟擲異常,一般在方法中使用
        }
    }

}

自定義異常：自定義異常類並繼承Exception類