Java 内部类

Java 内部类分为：成员内部类，静态嵌套类，方法内部类，匿名内部类。

（1）内部类仍然是一个独立的类，在编译之后会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。

（2）内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private。

（3）内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量。

成员内部类：

class A{

    class B{}

}

编译上述代码会产生两个文件：A.class和B.class

方法内部类

把类放在方法里

public class A{

    public int f()

    {

    private class B{

        int i=10;

    }

    return new B().i;

    }

    public static void main(String[] args)

{

    A a= new A（）；

    system.out.printfln(af());

}

}

匿名内部类--用于临时创建实例，且该实例不希望类的使用者关注

匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：

·只用到类的一个实例 。

·类在定义后马上用到。

·类非常小（SUN推荐是在4行代码以下）

·给类命名并不会导致你的代码更容易被理解。

在使用匿名内部类时，要记住以下几个原则：

·匿名内部类不能有构造方法。

·匿名内部类不能定义任何静态成员、静态方法。

·匿名内部类不能是public,protected,private,static。

·只能创建匿名内部类的一个实例。

·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

（1）继承式的匿名内部类

    abstract class person{

    public abstract void eat();

}

public class test{

    public static void main(String [] args)

{

    person p =new person(){

            public void eat(){

                system.out.printfln("吃");

    }；

    p.eat;

}

}

}

（2）接口式的匿名内部类

interface Person {
    public void eat();
}

public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println( "eat something" );
            }
        };
        p.eat();
    }
}

（3）参数式的匿名内部类

class Bar{

void doStuff(Foo f){

f.foo();

}

}

interface Foo{

void foo();

}

class Test{

static void go(){

Bar b = new Bar();

b.doStuff(new Foo(){

public void foo(){

System.out.println("foofy");

}

});

}

}

静态嵌套类