1.內部類的主要特點

• 內部類可以很好的實現隱藏，使用private，protected關鍵字。而這些，外部類是不能使用的。
• 內部類可以直接訪問外部類的所有成員，包括私有的成員
• 外部類不能直接訪問內部類的成員，必須首先要建立內部類的物件才能訪問
• 內部類可以解決一些問題，比如間接地實現多繼承，可以避免修改介面而實現同一個類中兩種同名方法的呼叫（一般不這麼做）

2.成員內部類

特點：
- 可以看作是外部類的一個例項成員
- 可以使用所有的許可權修飾符：public，private，default，protected
- 訪問所在外部類的成員方法和屬性時，要使用”外部類名.this.成員方法”和“外部類名.this.成員屬性”

建立成員內部類：
- 外部類呼叫自己的內部類，可以直接用：內部類名 例項名=new 內部構造方法（引數）的形式
- 呼叫非自己的內部類要用：外部類名.內部類名 例項名=外部類例項名.new 內部類構造方法（引數）的形式，因此要建立一個內部類，先要建立一個外部類
- 編譯後會產生自己的class檔案，檔名：外部類$內部類.class

限制：

• 成員內部類不能與外部類重名
• 不能定義靜態屬性，方法和類（static final除外）因為一個成員內部類例項必然與一個外部類例項關聯，static成員完全可以移到外部類中去。

3.成員內部類的應用

成員內部類引用

public
 
 class MemberInnerClass{
     public static void main(String[] args){
     Outer1 outer=new Outer1();//先建立外部類
     Outer1.Inner1 inner=outer.new Inner();//在建立內部類
     inner.InnterShow()//呼叫內部類方法
}

class Outer1{
     private String name="Lily";
     private int age=22;
     public void outerShow(){
          System.out
 
.println(name);
          System.out.println(age)；
     //外部類不能直接訪問內部類的成員，必須首先要建立內部類的物件才能訪問
     Inner1 inner1=new Inner();
     System.out.println(inner1.age);
}
     }
     public class Inner1{
          private String name="Jasmine";
          private int age=26;
          public void InnterShow(){
              System.out.println(name);
              System.out.pringln(age);
              System.out.println(Outer1.this.name);//與建立內部類的方法呼應，這裡用this呼叫的外部類的成員
              outerShow();//非重名屬性和方法還可以直接從外部類呼叫
          }  
     }
}

內部類實現多繼承

通過內部類實現多繼承，在要繼承的子類內建立兩個內部類
再建立兩個與繼承父類的同名方法。方法裡面做一件事：建立內部類物件，並引用繼承類的方法
看起來c.showA()是呼叫了多繼承父類的方法，實際上，是c引用了內部類物件繼承的方法
public class MultiExtendsDemo {

     public static void main(String[] args) {
          C c=new C();//建立外部類的物件
          //C間接地繼承了A和B
          c.showA();
          c.showB();
     }
}
class A{
     public void showA(){
          System.out.println("A");
     }
}

class B{
     public void showB(){
          System.out.println("B");
     }
}
//在class C內部建立多個類，實現多繼承
class C{
     //內部類A1繼承A
     private class A1 extends A{
          public void showA(){
              super.showA();
          }
     }
     private class B1 extends B{
          public void showB(){
              super.showB();
          }
     }
     public void showA(){
          new A1().showA();
     }
     public void showB(){
          new B1().showB();
     }

}

避免修改介面實現同一個類中，兩個同名方法的呼叫

public class Demo2 {

     public static void main(String[] args) {
          Son son=new Son();
          son.show();//繼承父類的show方法
          son.show2();//子類物件Inner（）實現介面的show方法
     }
}
abstract class Parent{
     public abstract void show();

}
interface Ishow{
     public abstract void show();
}

//上述Parent抽象類和Ishow介面，
//二者裡面都有一個叫show()的抽象方法
//如何同時對這兩個show()方法做改寫
//並且不能修改方法名
class Son extends Parent{
     public void show(){
          System.out.println("抽象類中的show方法");
     }
     private class Inner implements Ishow{
          public void show(){
              System.out.println("介面中的show方法");
          }
     }
     public void show2(){
          new Inner().show();
     }
}