java學習第七天

內部類
       在類的內部也能夠定義另外一個類

------------------------------------------------------------
//類嵌套類,類中帶有類
//內部類跟方法同樣，可使用所有的訪問權限修飾符,用法是同樣的

接口 InterInner
public interface InterInner {
 public void method();
}

實現接口 InterInnerImpl

public class InterInnerImpl implements InterInner {

 @Override
 public void method() {
 }

}

 

普通類  Outer

public class Outer{
      private int intField;

       //第一種：成員內部類,跟成員屬性(方法同級),能夠類比成員屬性

       class Inner1{}     //Innerl、Inner二、Inner3都是成員內部類
      
       class Inner2{}

       class Inner3{}

      //編譯後的表現格式:Outer$2Inner4.class
      public void method1(){
         int a = 0;
          //第二種：局部內類
      //跟局部變量同級，用法類別局部變量，不能使用修飾符

        class Inner4{}
                      //Inner四、Inner5都是局部內 類
        class Inner5{}
}
       //第三種: 靜態內部類  能夠類比  靜態屬性
        static class Inner6{}

      //第四種: 匿名內部類
       //由於InterInner interinner = new InterInner() 編譯不能經過
      //抽象類 不能實例化
    //因此
      InterInner interinner = new InterInner(){

      @Override
       public void  method(){}  };

    public static void main(String[] args){
       //第一種:成員內部類  建立 對象的 格式
       Outer outer = new Outer();
       Outer.Inner inner1 = outer.new Inner();
       Outer.Inner2 inner2 = new Outer().new Inner2();

       //第二種：局部內部類
      //沒法經過普通new進行建立，能夠經過繼承/實現接口的方式進行

     //第三種：靜態內部類
      Outer.Inner5 inner5 = new Outer.Inner5();
    
     //第四種：匿名內部類

     InterInner interImp1 = new InterInnerImp1();
   
    //匿名內部類建立對象方式:等價於 InterInner interImp1 = new InterInnerImp1();

   //不同的地方是:沒有類名

   //一、繼承某一個類
   //二、實現某一個接口
    

}

}

----------------------------------------------------------------
普通類 InnerFather

public class InnerFather {

}

接口  InnerInterface

public interface InnerInterface {

}

 

普通類 MemberOuter

public class MemberOuter{
    private int privateField = 1;
    public static int staticField = 3;
    public int a = 1;

  //內部類跟普通類是同樣的，普通類能幹什麼，內部類就能夠幹什麼
  //好比：繼承  實現接口
  //能夠幫助外部類實現多繼承的功能
  //成員內部類運用場景：
  //一、經過內部類能夠實現類的多繼承
  //二、若是外部類是一個 邏輯很是複雜的一個類，須要操做不少屬性
  //或方法 這個時候，能夠對功能進行拆分讓某個或多個內部類，幫忙處理

   class Inner extend InnerFather implements InnerInterface{

      public Inner(){}

      public int a=2;

/*Outer 對象 --》Inner 對象 --》內部成員

  外部類 --》Inner 類 --》靜態成員
    Inner 類 靜態成員 --》常量

   由於訪問成員內部類中屬性 須要經過外部類的對象，進行內部類對象的建立
而後經過內部類的對象進行訪問。若是 在內部類中聲明 靜態屬性 那麼只能
經過內部類的 類名進行訪問 此時 若是內部類是成員內部類時 那麼外部類
不能經過 外部類名.內部類名 訪問內部類靜態成員屬性 因此 要麼把內部類變成
靜態內部類 要麼把 靜態成員 屬性變成 常量(常量表達式)

 

//成員內部類中 不能定義靜態的屬性
public static final int innerStaticField = 1; //常量表達式
public static final String stringInnerStaticField = "aaa";

//同名屬性的狀況下訪問
public void method(){
int a = 3;
//若是沒有特殊指定：this 或Outer.this
//那麼訪問順序跟子類屬性訪問規則一致
//先局部（內部類） -- 成員(內部類) -- 外部
//就近原則

System.out.println("a:" + a);
System.out.println("a:" + this.a);
//內部類訪問外部類屬性的方法Outer.this.屬性
System.out.println("a:" + MemberOuter.this.a);
}
 
//外部類訪問控制
public void method2(){
//能夠訪問外部類的私有屬性
System.out.println("outer 私有屬性" + privateField);
//能夠訪問外部類的靜態屬性

System.out.println("outer 私有屬性" + staticField);
}

//普通方法
public void method(){
Inner inner = new Inner();
inner.method();
}

public static void method2(){

//外部類靜態方法中不能使用成員內部類，若是要調用 就把成員內部類定義成
靜態
//能夠類比靜態方法調用非靜態屬性
//Inner inner = new Inner();
}

public static void main(String[] args){
MemberOuter.Inner inner = new MemberOuter().new Inner();
  //inner.method();
  //inner.method2();
  
  
  MemberOuter outer = new  MemberOuter();
  
  outer.method();
 }
 
}

-------------------------------------------------------------------public class StaticOuter {  private static int staticField = 1; public int intField = 2;  static class Inner{  public int innerField = 1;  public static int  innerStaticField = 2;  //能夠定義非靜態方法  //靜態內部類：  //非靜態方法，能夠訪問內部中靜態/非靜態成員，能夠訪問外部類的靜態成員，沒法訪問，外部類非靜態成員  //緣由：StaticOuter.Inner inner = new StaticOuter.Inner();  //建立靜態內部類對象時候，沒有建立外部的對象，  //此時，不是經過外部類對象訪問非靜態屬性，因此不能訪問  public void method(){   //非靜態方法中能夠訪問外部類靜態屬性，但不能非靜態屬性   //Cannot make a static reference to the non-static field intField   ///System.out.println("outer 非靜態屬性：" + intField);   System.out.println("outer 靜態屬性：" + staticField);      //能夠訪問內部類定義的靜態屬性 ，也能夠訪問非靜態屬性   System.out.println("inner 靜態屬性：" + innerStaticField);   System.out.println("inner 非靜態屬性：" + innerField);  }    //靜態方法  //靜態內部類：  //靜態方法只能訪問靜態屬性或方法，不能訪問非靜態方法或/屬性，無論是外部仍是內類  public static void  method2(){   //Cannot make a static reference to the non-static field intField   //System.out.println("outer 非靜態屬性：" + intField);   System.out.println("outer 靜態屬性：" + staticField);   //能夠訪問內部類定義的靜態屬性 ，也能夠訪問非靜態屬性   System.out.println("inner 靜態屬性：" + innerStaticField);   //Cannot make a static reference to the non-static field innerField   //System.out.println("inner 非靜態屬性：" + innerField);  } } public static void main(String[] args) {  //成員內部類  //MemberOuter.Inner inner = new MemberOuter().new Inner();  //靜態內部類  StaticOuter.Inner inner = new StaticOuter.Inner();  inner.method();     }}