1、super();

//呼叫本類中的構造方法
this(實參列表);
//呼叫父類中的空引數構造方法
super();
//呼叫父類中的有引數構造方法
super(實參列表);

①構造方法預設第一行都是super();
②預設的隱式super()語句在父類中沒有對應的構造方法，必須在構造方法中通過this或者super明確要呼叫的構造方法。
③第一行寫了this呼叫了本類其他構造方法，super呼叫父類的語句就沒有了。

2.final（太監類）

可以修飾類，類的成員，以及區域性變數，不能修飾構造方法
特點：
①final修飾類不能被繼承，但是可以繼承其他類

class Yy {}
final
 
 class Fu extends Yy{} //可以繼承Yy類
class Zi extends Fu{} //不能繼承Fu類

②final修飾的方法不能被子類重寫,但父類中沒有被final修飾方法，子類重寫後可以加final

class Fu {    
    // final修飾的方法，不可以被覆蓋，但可以繼承使用
    public final void method1(){}
    public void method2(){}
}
class Zi extends Fu {
    //重寫method2方法
    public final void method2(){}
}
 

③final修飾的變數稱為常量，只能賦值一次

final int i = 20;
i = 30; //賦值報錯，final修飾的變數只能賦值一次

④引用型別的變數值為物件地址值不能更改，地址內的物件屬性值可以修改

final Person p = new Person();
Person p2 = new Person();
p = p2; //final修飾的變數p，所記錄的地址值不能改變
p.name = "小明";//可以更改p物件中name屬性值

⑤修飾成員變數，需要在建立物件前賦值

class Demo {
    //直接賦值
    final
 
 int m = 100;
    
    //final修飾的成員變數，需要在建立物件前賦值，否則報錯。
    final int n; 
    public Demo(){
        //可以在建立物件時所呼叫的構造方法中，為變數n賦值
        n = 2016;
    }
}

3.static 靜態修飾符
特點：
①被static修飾的成員變數屬於類

class Demo {
    public static int num = 100;
}

class Test {
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo();
        d1.num = 200;
        System.out.println(d1.num); //結果為200
        System.out.println(d2.num); //結果為200
    }
}

②被static修飾的成員可以通過類名直接訪問（建議這麼做 類名.靜態成員變數名；類名.靜態成員方法名(引數)）

class Demo {
    //靜態成員變數
    public static int num = 100;
    //靜態方法
    public static void method(){
        System.out.println("靜態方法");
    }
}
class Test {
    public static void main(String[] args) {
        System.out.println(Demo.num);
        Demo.method();
    }
}

注意事項：
①靜態內容優先於物件存在，只能訪問靜態，不能使用this和super。靜態修飾的內容存於靜態區。

class Demo {
    //成員變數
    public int num = 100;
    //靜態方法
    public static void method(){
        //this.num; 不能使用this/super。
        System.out.println(this.num);
    }
}

②同一個類中，靜態成員只能訪問靜態成員。

class Demo {
    //成員變數
    public int num = 100;
    //靜態成員變數
    public static int count = 200;
    //靜態方法
    public static void method(){
        //System.out.println(num); 靜態方法中，只能訪問靜態成員變數或靜態成員方法
        System.out.println(count);
    }
}

③main方法為靜態方法為程式執行入口，不屬於任何一個物件，可以定義在任意類中
④多型呼叫方法，編譯看等號左邊。靜態方法，執行父類中的靜態方法，非靜態方法，執行子類的重寫方法。成員變數，編譯執行全是父類

定義靜態常量：public static final 資料型別 變數名 = 值; 變數名用全部大寫，多個單詞使用下劃線連線
介面中的每個成員變數都預設使用public static final修飾，必須顯示賦值。可以直接用介面名訪問

interface Inter {
    public static final int COUNT = 100;
}
//訪問介面中的靜態變數
Inter.COUNT

4.匿名物件

建立物件時，只有建立物件的語句，例如：new Person();

new Person();

特點：
①建立匿名物件直接使用，沒有變數名

new Person().eat()  //eat方法被一個沒有名字的Person物件呼叫了。

②匿名物件在沒有指定其引用變數時，只能使用一次

new Person().eat(); //建立一個匿名物件，呼叫eat方法
new Person().eat(); //想再次呼叫eat方法，重新建立了一個匿名物件

③匿名物件可以作為方法接收的引數、方法返回值使用

class Demo {
    public static Person getPerson(){
        //普通方式
        //Person p = new Person();    
        //return p;
        
        //匿名物件作為方法返回值
        return new Person(); 
    }
    
    public static void method(Person p){}
}

class Test {
    public static void main(String[] args) {
        //呼叫getPerson方法，得到一個Person物件
        Person person = Demo.getPerson();
        
        //呼叫method方法
        Demo.method(person);
        //匿名物件作為方法接收的引數
        Demo.method(new Person());
    }
}

5.內部類
在內部類中可以直接訪問外部類的所有成員
①成員內部類（定義在外部類中的成員位置）：外部類名.內部類名 變數名 = new 外部類名().new 內部類名();

class Body {//外部類，身體
    private boolean life= true; //生命狀態
    public class Heart { //內部類，心臟
   　　public void jump() {
         System.out.println("心臟噗通噗通的跳")
            System.out.println("生命狀態" + life);
      }
   }
}

//訪問內部類
public static void main(String[] args) {
    //建立內部類物件
    Body.Heart bh = new Body().new Heart();
    //呼叫內部類中的方法
    bh.jump();
}

②區域性內部類（定義在外部類方法中的區域性位置）：在外部類方法中，建立內部類物件，進行訪問

class Party {//外部類，聚會
    public void puffBall(){// 吹氣球方法
        class Ball {// 內部類，氣球
              public void puff(){
     System.out.println("氣球膨脹了");
}
}
//建立內部類物件，呼叫puff方法
new Ball().puff();
}
}

//訪問內部類
public static void main(String[] args) {
    //建立外部類物件
    Party p = new Party();
    //呼叫外部類中的puffBall方法
    p.puffBall();
}