1 package com.tarena.day13;
 2 
 3 import com.tarena.day13.Foo.Koo;
 4 /**
 5  * 靜態類內部語法演示
 6  */
 7 public class StaticInner {
 8  public static void main(String[] args) {
 9   Koo koo = new Koo();
10   System.out.println(koo.add());//4
11  }
12 
13 }
14 class Foo{
15  int a = 1;
16  static int b = 3;
17  /** 靜態內部類，作用域類似于靜態變量，屬于類的 */
18  static class Koo{
19   public int add(){
20    //a ,不能訪問a
21    return b+1;
22   }
23  }
24 }

 1 import com.tarena.day13.inn.Goo.Moo;
 2 
 3 public class InnerClassDemo {
 4  public static void main(String[] args) {
 5   //Moo moo = new Moo(); //編譯毛病，必須創建Goo的實例
 6   Goo goo = new Goo();
 7   Moo moo = goo.new Moo();//利用goo實例創建Moo實例
 8   Moo moo1 = goo.new Moo();
 9   //moo和moo1同享同1個goo實例的實例變量
10   System.out.println(moo.add());//2
11   System.out.println(moo1.add());//2
12   Goo goo1 = new Goo();
13   goo1.a = 8;
14   Moo m1 = goo1.new Moo();
15   Moo m2 = goo1.new Moo();
16   System.out.println(m1.add());//9
17   System.out.println(m2.add());//9
18   
19  }
20 }
21 class Goo{
22  int a = 1;
23  /**成員內部類*/
24  class Moo{
25   public int add(){
26    return a+1;
27   }
28  }
29 }

 1 package com.tarena.day13.inn;
 2 
 3 import java.util.Comparator;
 4 
 5 /**
 6  * 局部內部類
 7  */
 8 public class LocalInnerClassDemo {
 9  public static void main(String[] args) {
10   int a = 5;
11   final int b = 5;
12   //局部內部類，定義在方法內部，作用域類似于局部變量
13   //僅僅在方法內部可見
14   //在局部內部類中可以訪問方法中的局部final變量
15   class Foo{
16    public int add(){
17     return  b;//正確
18     //return a;//編譯毛病
19    }
20   }
21   
22   Foo foo = new Foo();
23   //臨時的自定義比較規則
24   class ByLength implements Comparator<String>{
25    public int compare(String o1,String o2){
26     return o1.length()-o2.length();
27    }
28   }
29  }
30 
31 }

 1 import java.util.Arrays;
 2 import java.util.Comparator;
 3 
 4 /**匿名內部類 語法*/
 5 public class AnnInnerClass {
 6 
 7  public static void main(String[] args) {
 8   // TODO Auto-generated method stub
 9   Yoo yoo = new Yoo();//創建Yoo的實例
10   Yoo y1 = new Yoo(){};
11   //new Yoo(){}創建匿名類實例
12   //匿名類new Yoo(){}是繼承Yoo類，并且同時創建了對象
13   //new Yoo(){}是Yoo的子類型，其中{}是類體（class Body）
14   //類體中可以定義任何類內的語法,如：屬性，方法，方法重載，方法覆蓋，等
15   //子類型沒著名字，所以叫匿名類!
16   Yoo y2 = new Yoo(){
17    public String toString(){//方法重寫（覆蓋）
18     return "y2"; //y2是子類的實例
19    }
20   };
21   System.out.println(y2);//"y2"，調用了匿名類對象toString()
22   //匿名內部類可以繼承/實現 于 類，抽象類，接口等
23   //依照繼承的語法，子類型必須實現所有的抽象方法
24   
25   //Xoo x = new Xoo(){};//編譯毛病，沒有實現方法
26   final int b = 5;
27   Xoo xoo = new Xoo(){ //是實現接口,并且創建匿名類實例，不是創建接口對象
28    public int add(int a){//實現接口中的抽象方法
29     return a+b; //要訪問局部變量b,只能訪問final變量
30    }
31   };
32   System.out.println(xoo.add(5));//10,調用對象的方法
33   //Comparator接口也能夠使用匿名類的方式
34   Comparator<String> byLength = new Comparator<String>(){
35    public int compare(String o1,String o2){
36     return o1.length()-o2.length();
37     
38    }
39   };
40   String[] names = {"Andy","Tom","Jerry"};
41   Arrays.sort(names,byLength);
42   System.out.println(Arrays.toString(names));
43   //也能夠這樣寫，工作中經常使用
44   Arrays.sort(names,new Comparator<String>(){
45    public int compare(String o1,String o2){
46     return o1.length()-o2.length();
47    }
48   });
49  }
50 
51 }

 1 class Bar{ 　　
 2     void doStuff(Foo f){
 3      } 　　
 4 } 　　
 5 interface Foo{ 　　
 6     void foo(); 　　
 7 } 　　
 8 class Test{ 　
 9 　static void go(){ 　
10     　Bar b = new Bar(); 　
11     　b.doStuff(new Foo(){ 　
12         　public void foo(){ 　
13             　System.out.println("foofy"); 　
14         　} 　　
15       }); 
16 　} 　　
17 }