繼承

子類可繼承父類所有的public 方法/屬性

在Java 中，所有的類，都默認直接或間接繼承Object 類

java 類中只有單繼承，沒有多繼承，只能繼承一個父類（無法繼承多個）

? 私有的東西（方法/類）無法被繼承

// 繼承一個類，關鍵字extends
public class Student extends Person{
    private String name = “test”;
    protected String name1 = "11";		// protected ： 受保護的
	public void test(String name){
        System.out.println(name);		// 方法形參傳入的name
        System.out.println(this.name);	// Student 類中定義的屬性 
        System.out.println(super.name); // Person 類中定義的屬性，父類中的屬性/方法
    }
}

super 注意點：

 	1. super 調用父類的構造方法，必須在構造方法的第一個（默認都會調用父子類的構造方法）
 	2. super 必須只能出現在子類的方法或者構造方法中！
 	3. super 和 this 不能同時調用構造方法！
        
Vs this :
	代表的對象不同：
        this ： 本身調用者這個對象
        super ： 代表父類對象的應用
    前提：
        this ： 沒有繼承者也可以使用
        super ： 只能在繼承條件才能使用
    構造方法：
        this（）； 本類的構造
        super() : 父類的構造

方法重寫

重寫都是方法的重寫，與屬性無關；子類與父類名稱返回傳參等都一致，但子類重寫構建方法體

? 父類的引用可以指向子類

靜態方法和非靜態的方法區別很大

? 靜態方法： 方法的調用之和左邊，定義的數據類型有關

如：// test 方法都為靜態
    A a = new A（）;
	a.test();			// 正常調用子類中的test 方法
	
	B b = new A();
	b.test();			// 靜態方法以左邊為準，即B（父類）

? 非靜態：重寫

靜態方法無法重寫，調用時以左邊為主，非靜態重寫時以右邊為主

重寫：需要繼承關系，子類重寫父類的方法
    1. 方法名相同
    2. 參數列表相同
    3. 修飾符：范圍可以擴大但不能縮小： public > protected > default >private
    4. 拋出的異常：范圍，可以被縮小，但不能擴大;

Alt + Insert; override;

多態

一個對象的實際類型時確定的

對象能執行哪些方法，主要看對象左邊的類型，和右邊關系不大（右邊用于重寫父類）

// 可以指向的引用類型不確定：父類的引用指向子類
Person s2 = new Student();		// 父類的引用指向子類

/*
多態注意事項：
1. 多態是方法的多態，屬性沒有多態
2. 父類和子類，有聯系  類型轉換異常!  ClassCastException !
3. 存在關系 ： 繼承關系，方法需要重寫，父類引用指向子類！ Father f1 = new Son();
  無法重寫：
	1. static 方法，其屬于類，不屬于實例
	2. final 常量
	3. private 方法；

*/

? 多態：同一方法可根據發送對象的不同而采用多種不同的行為方式，典型的有方法重寫和方法重載

instanceof 和類型轉換

? instanceof（類型轉換）引用類型，判斷一個對象是什么類型;

對象 instanceof 對象2 # 判斷兩個類是否有關系，返回boolean

無論是父類轉子類還是子類轉父類，轉換過后能使用的方法只有其類中的方法

當然子類已經繼承了父類中的方法，所以可以看作所有的方法

子類轉父類可能會丟失方法

高轉低需強轉，低轉高無需強轉

// 高           低
Person obj = new Studenr();			// 對象為Person 類，但new Student 后會對方法重寫

// Person 中無go 方法，無法使用，強轉為Student 類，可調用Student 類中方法

Student obj1 = (Student) obj;		// Person 對象強轉為Student類的對象

static 關鍵字詳解

靜態會隨著類的創建而創建，非靜態是隨著對象的創建而創建

private static int age; 			// 靜態變量
private double score;				// 非靜態變量
Student student1 = new Student();
student1.score;					// 可以調用，隨著對象創建存在
Student.score;					// 無法調用，隨著類的創建存在

匿名代碼塊會默認執行，執行順序高于構造器

被 final (常量) 關鍵字定義的類，無法被繼承

{
    System.out.prtinln("匿名代碼塊");
}
static {
    System.out.println("靜態匿名代碼塊");
}
public Student(){
    System.out.println("構造器");
}

? 靜態匿名代碼塊只會執行一次，在new 對象時匿名代碼塊會執行;

抽象類

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

abstract 關鍵字用于定義抽象類

public abstract class Action{					// 定義抽象類。抽象方法必須存在抽象類中
    public abstract void doSometing();			// abstract 定義方法后，此方法必須由子類重寫后才可使用
}

1. 不能new 抽象類，只能靠子類去實現它：約束
2. 抽象類中可以寫普通方法
3. 抽象方法必須在抽象類中

接口

普通類：只有具體實現

抽象類： 具體實現和規范（抽象方法）都有 !

接口：只有規范！自己無法寫方法

接口關鍵字定義不再時class 而是interface

接口中所有的定義其實都是抽象的 public abstract

? 接口可繼承多個，而類只能單繼承

public interface UserService{			// 創建接口且指定接口類
    void add(String name);				// 創建接口，
    void del(String name);
    public abstract void query(String name); //  接口中默認都存在public abstract,可省略
    void update(String name);
}

// 子類重寫接口方法
public class UserServiceImpl implements UserService{}	// 子類繼承接口

作用：
    1. 約束
    2. 定義一些方法，讓不同的人實現  10 ---> 1   # 多個接口由一個子類多繼承重寫實現其功能
    3. public abstract			# void add(); 接口類中默認已經存在public abstract 關鍵字 
    4. public static final		# 接口中定義常量變量（不常用） 
    5. 接口不能被實例化。 接口中沒有構造方法	# 接口于抽象類相似，作為其的延申，abstract 只是定義方法，不會在此類中直接實現方法，需由子類實現
    6. implement 可以實現多繼承多個接口	# 子類繼承接口的關鍵字 implement
    7. 必須要重寫接口中的方法				# 子類一旦繼承就需要重寫接口中定義的方法
    總結 ： 接口屬于抽象類的延申，都是先對方法名進行定義，后由子類進行方法的重寫，唯一最大的區別在于：接口可以被多繼承，從而實現java 無法被多繼承;

N種內部類

內部類就是在一個類的內部再定義一個類

內部類可以獲得外部類的私有方法/屬性

一個Java類/文件 中可以由多個class 類，但只能有一個public class 類

Outer outer = new Outer();			// 正常實例化類
Outer.Inner inner = outer.new Inner();	// 通過實例化后的對象進行實例化內部類
inner.getId();						// 調用內部類方法


// 局部內部類
public void method(){				// 方法中定義類，僅存在于此方法中
    class Inner{				// 不推薦如此使用
        public void in(){}
    }
}