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共享同一个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 }