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类在使用时：

实例化static类时，在new前面不需要用对象实例变量；

static类中不能访问其外部类的非static的字段和方法，即只能访问static成员；

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)

使用局部类

同局部变量一样，方法中的内部类

不能够用

public, private, protected, static

修饰，但可以被final或者abstract修饰。

可以访问其外部类的成员，因为一定意义下，其也属于局部类。

不能够访问该方法的局部变量，除非是final局部变量。因为局部变量是随时产生随时消失的，而加了final修饰，因其本质是不可变的，只读的，所以可以访问。

3、匿名类

匿名类（anonymous class）是一种特殊的内部类

其没有类名，在定义类的同时就生成该对象的一个实例

“一次性使用“的类

使用匿名类

不取名字，直接用其父类或接口的名字。

也就是说，该类是父类的子类，或者实现了一个接口，编译器生成XXXX$1之类的名字。

类定义的同时就创建实例，即类的定义前面有一个new

new className|interfaceName(){...}

不适用关键字

class

，也不使用

extends

即

implements

。

在构造对象时使用父类构造方法

不能够定义构造方法，因为其没有名字

如果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

匿名类的应用

用到界面的事件处理

注册一个时间监听器

如：

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

作为方法的参数

排序，给一个比较大小的接口

如：

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