摘要：對于一個名為的外圍類和一個的內部類，在編譯成功后，會出現這樣兩個文件和。

@(Java知識點總結)[Java, Java面向對象]

[toc]

public

protected

default

private

abstract：抽象類不能實例化，專門用于繼承的類
final：最終類不能被繼承

駝峰標識- 每個單詞首字母大寫

Java中的繼承是單一繼承

繼承關系中，會調用父類的構造方法來構造子類對象

當父類存在無參構造器時，子類構造器中 Super 關鍵字，因為它會隱式的調用父類的無參構造器

public Son(){
    //Super();
}

當父類沒有無參構造器時，子類需要顯示的調用帶參構造器，否則編譯不通過。

public Son(參數類型 參數名){
    Super(參數名);
    this.參數名 = 參數名;
}

一個類可以實現多個接口來扮演多個角色
多個接口之間用逗號隔開

內部類定義：在一個類的內部在定義一個類

內部類可以用多個實例，每個實例都有自己的狀態信息，而且與其他外部對象的信息互相獨立

在單個外部類中，可以讓多個內部類已不同的方式實現同一個接口，或者繼承同一個類

創建內部類對象的時刻并不依賴于外部類對象的創建。

內部類并沒有令人迷惑的"is-a"關系，他就是一個獨立的實體

內部類提供更好的封裝，除了該外部類，其他類都不能訪問

內部類是個編譯時的概念，一旦編譯成功后，它就與外部類屬于兩個完全不同的類（當然他們之間還是有聯系的）。對于一個名為OuterClass的外圍類和一個InnerClass的內部類，在編譯成功后，會出現這樣兩個class文件：OuterClass.class和OuterClass$InnerClass.class。

成員內部類也是最普通的內部類，它是外部類的一個成員，所以他是可以無限制的訪問外圍類的所有成員屬性和方法，盡管是private 的，但是外圍類要訪問內部類的成員屬性和方法則需要通過內部類的實例去訪問

在成員內部類中要注意兩個點：

成員內部類中不能存在任何static的變量和方法

成員內部類是依附外部類的，所以只有先創建了外部類才能創建內部類

public class OuterClass {
private String name = "張三" ;

public void outPrint(){

System.out.println("我是外部類的方法");

}

// 內部類
public class InnerClass{ // 可以聲明成public或private

//private static int id;  //成員內部類中不能存在任何static的變量和方法；

public void innerPrint(){
 //可以直接使用外部類的屬性和方法
 System.out.println(name+"你好，我是內部類");
 outPrint();
}

}

public InnerClass getInnerClass(){

return new InnerClass();

}
public static void main(String[] args) {

//InnerClass innerClass = new InnerClass(); // 不能直接實例化內部類對象

//通過外部類調用內部類
InnerClass innerClass = new OuterClass().new InnerClass();

OuterClass.InnerClass innerClass2 = new OuterClass().new InnerClass();

//通過get方法來獲取內部類（推薦）
InnerClass innerClass3 = new OuterClass().getInnerClass();
innerClass3.innerPrint();

/*張三你好，我是內部類
我是外部類的方法*/

}

}

局部內部類是嵌套在方法和作用于域的，對于這個類的使用主要是應用與解決比較復雜的問題想創建一個類來輔助我們的解決方案，到那時又不希望這個類是公共可用的，所以就產生了局部內部類。

局部內部類和成員內部類一樣被編譯，只是它的作用域發生了改變，它只能在該方法和屬性中被使用，出了該方法和屬性就會失效

public class Outer {
  
  private String info = ",我是外部類的屬性";
  public void test(final String name){ // 方法中的參數要被內部類訪問，必需加上final修飾
    // 定義于方法內的類
    class Inner{
     public void print(){
       System.out.println(name+info); //使用外部類的屬性和方法中的參數
     }
    }
    new Inner().print();
  }
 
  public static void main(String[] args) {
    new Outer().test("張三");
    /*張三,我是外部類的屬性*/
  }
}

匿名內部類：創建的對象沒有名字

匿名內部類是不能加訪問修飾符

要使用匿名類，這個類是要先定義的

當所在的方法的形參需要被內部類里面使用時，該形參必須為final修飾

（內部類并不是直接調用方法傳進來的參數，而是內部類將傳進來的參數通過自己的構造器備份到自己的內部，外部類的方法修改）

public class Outer2 {
  
  public Inner2 getInner(final String name){
    return new Inner2(){
     private String info = "，我是內部類屬性";
 
     @Override
     public void print() {
       System.out.println(name+info);
     }
     
     public void test(){
       System.out.println("我是接口中未定義的方法");
     }
    };
  }
 
  public static void main(String[] args) {
    Inner2 inner2 =new Outer2().getInner("張三");
    inner2.print();
    //inner2.test();  //不能調用接口中未定義的方法
  }
}
 
interface Inner2{
  void print();
}

使用static修飾的內部類我們稱之為靜態內部類，不過我們更喜歡稱之為嵌套內部類

靜態內部類與非靜態內部類之間存在一個最大的區別，我們知道非靜態內部類在編譯完成之后會隱式地保存著一個一引用，該引用是指向創建它的外部類，但是靜態內部類卻沒有。沒有這個引用就意味著：

它的創建不需要依賴外部類

它不能使用任何外部類的非static成員變量和方法

public class Outer3 {
private String info1 = "我是外部類非靜態屬性";
private static String info2 = "我是外部類靜態屬性";
private String getInfo1(){

return "我是外部類非靜態方法";

}
private static String getInfo2(){

return "我是外部類靜態方法";

}

//靜態內部類
public static class Inner3{

public void print(){
 //System.out.println(info1);
 System.out.println(info2);
 System.out.println(getInfo2());
}

}

public static void main(String[] args) {

new Inner3().print();  //不依賴于外部類，可以直接new 對象
/*我是外部類靜態屬性
我是外部類靜態方法*/

}
}

public class Test extends Outer4.inner{
 
  //Test 類必須存在外部類作為形參的構造方法，否則編譯不通過
  Test(Outer4 out){
    out.super();
  }
}
 
class Outer4 {
  class inner{
    
  }
}

構造方法定義：

名字跟類名完全一致

沒有返回類型

支持重載

可以通過this調用當前類已有其他構造器

隱式構造器：如果一個類沒有寫任何構造器，編譯器就會生成默認無參構造器