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-----------  
33
22
11

内部类的修饰符

• 内部类与类中的字段、方法一样是外部类的成员，它的前面也可以有任意的访问控制符(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();
        }
    })