Java- 内部类与匿名类

内部类、局部类与匿名类

• 内部类（inner class）是在其他类中的类
• 局部类（local class）是在方法中的类
• 匿名类（anonymous class）是一种特殊的内部类，其没有类名。

1、内部类

• 内部类的定义
  
  • 将类的定义classc XXX{...}置入一个类内部即可
  • 编译器生成XXX$XXX这样的.class文件
  • 内部类不能够与外部类同名
• 内部类的使用
  
  • 在封装它的类的内部使用内部类：与普通类的使用方式相同
  • 在其它地方使用：类名前要冠以外部类的名字；在用new创建内部类时，也要在new前面冠以对象变量：外部对象名.new 内部类名(param)

public class TestInnerClass2{    public static void main(String[] args) {        Parcel p = new Parcel();        // 在外部使用内部类         Parcel.Contents c = p.new Contents(22);        System.out.println(c.value());    }}class Parcel{    private Contents c;    class Contents {        private int i;        Contents(int i){ this.i = i; }        int value(){ return i; }    }}-----------OUTPUT-----------  22

在内部类中使用外部类的成员

• 内部类中可以直接访问外部类的字段及方法，即使是private也可以
• 如果内部类中有与外部类同名的字段和方法，则可以用outerClassName.this.field|method

public class TestInnerThis{    public static void main(String[] args) {        A a = new A();        A.B b = a.new B();        b.mb(33);    }}class A{    private int s = 11;    public class B{        private int s = 22;        // 内部类也可以使用public修饰        public void mb(int s){            System.out.println(s);//局部变量s            System.out.println(this.s);// 内部类对象的属性s            System.out.println(A.this.s);// 外部类对象属性s        }    }}-----------OUTPUT-----------  332211

内部类的修饰符

• 内部类与类中的字段、方法一样是外部类的成员，它的前面也可以有任意的访问控制符(public,protected,默认,private)和其他修饰符(final, abstract)，但外部类只能够使用public或者默认。

用static修饰内部类

• 用static修饰内部类，表明该内部类实际是一种外部类。
  
  • 因为它与外部类的实例对象无关
  • 所以认为static修饰的内部类是嵌套类(nested class)， 不是内部类(inner class)
• static类在使用时：
  
  1. 实例化static类时，在new前面不需要用对象实例变量；
  2. static类中不能访问其外部类的非static的字段和方法，即只能访问static成员；
  3. static方法中不能访问非static的域及方法，也不能不带前缀地new一个非static的内部类

class TestInnerStatic{    public static void main(String[] args)     {        // 非static类实例化时，需要在new前面用对象实例化变量        A.B a_b = new A().new B();  // ok        A a = new A();        A.B ab =  a.new B();        // 实例化static类时，在new前面不需要用对象实例变量        Outer.Inner oi = new Outer.Inner();        //Outer.Inner oi2 = Outer.new Inner();  //!!!error           //Outer.Inner oi3 = new Outer().new Inner(); //!!! error    }}class A    {    private int x;    void m(){        new B();    }    static void sm(){        //new B();  // error!!!!    }    class B    {        B(){ x=5; }    }}class Outer   {    static class Inner    {    }}

2、局部类

• 在一个方法中也可以定义类，这种类称为”方法中的内部类“，也叫局部类(local class)

使用局部类

1. 同局部变量一样，方法中的内部类
   
   • 不能够用public, private, protected, static修饰，但可以被final或者abstract修饰。
2. 可以访问其外部类的成员，因为一定意义下，其也属于局部类。
3. 不能够访问该方法的局部变量，除非是final局部变量。因为局部变量是随时产生随时消失的，而加了final修饰，因其本质是不可变的，只读的，所以可以访问。

3、匿名类

• 匿名类（anonymous class）是一种特殊的内部类
  
  • 其没有类名，在定义类的同时就生成该对象的一个实例
  • “一次性使用“的类

使用匿名类

1. 不取名字，直接用其父类或接口的名字。
   
   • 也就是说，该类是父类的子类，或者实现了一个接口，编译器生成XXXX$1之类的名字。
2. 类定义的同时就创建实例，即类的定义前面有一个new
   
   • new className|interfaceName(){...}
   • 不适用关键字class，也不使用extends即implements。
3. 在构造对象时使用父类构造方法
   
   • 不能够定义构造方法，因为其没有名字
   • 如果new对象时，要带参数，则使用父类的构造方法。

public class TestInnerInMethod{    public static void main(String[] args) {        Outer outer = new Outer();        String str = (outer.makeTheInner()).toString();        System.out.println(str);    }}class Outer{    private int size = 5;    public Object makeTheInner(){        final int finalLocalVal = 99;        // define inner class        return new Object(){            public String toString(){                return ("InnerSize: " + size +                    " finalLocalVal: " + finalLocalVal);            }        };    }}-----------OUTPUT-----------  InnerSize: 5 finalLocalVal: 99

匿名类的应用

1. 用到界面的事件处理
   
   • 注册一个时间监听器
   • 如：

    btnNew.addActionListener(new ActionListener(){        public void actonPerformed(ActonEven event){            ....        }    });

1. 作为方法的参数
   
   • 排序，给一个比较大小的接口
   • 如：

    Array<Book>.sort(bools, new Comparator<Book>(){        public int compare(Book b1, Book b2){            return b1.getPrice() - b2.getPrice();        }    })