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");

}

});

}

}

静态嵌套类