Java 嵌套类（Nested Class）：静态嵌套类，内部类，局部类，匿名类


将一个人比作类，人由大脑、肢体、器官等组成，而嵌套类相当于其中的某个器官，例如心脏：它也有自己的属性和行为（血液、跳动）。

嵌套类（Nested Class）的结构：

//外部类

class Out {

    private int age = 12;
    //嵌套类
    class In {
        public void print() {
            System.out.println(age);
        }
    }
}

 

public class Demo {

    public static void main(String[] args) {
        Out.In in = new Out().new In();
        in.print();

        //或者采用下种方式访问
        /*
        Out out = new Out();

        Out.In in = out.new In();

        in.print();
        */
    }
}

运行结果：12

嵌套类的好处：

1 在逻辑上分组只在一个地方使用的类

2 增加了封装性（encapsulation）

3 使代码可读性更强、更易维持

嵌套类分为：静态嵌套类（static nested class）和非静态嵌套类（non-static nested class），后者也称内部类（inner class）。

例1. 静态嵌套类

<span style="font-size:14px;">class Out {

    private static int age = 12;
    static class In {
        public void print() {
            System.out.println(age);
        }
    }
}

 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out.In();
        in.print();
    }

}</span>

运行结果： 12

说明：如果用static 将内部内静态化，那么内部类就只能访问外部类的静态成员变量，具有局限性。其次，因为内部类被静态化，因此Out.In可以当做一个整体看，可以直接new 出内部类的对象。

例2. 内部类

class Out {

    private int age = 12;
    class In {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Out.this.age);
        }
    }
}

 

public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out().new In();
        in.print();
    }
}

运行结果：

局部变量：14

内部类变量：13

外部类变量：12

可以发现，内部类在没有同名成员变量和局部变量的情况下，内部类会直接访问外部类的成员变量，而无需指定Out.this.属性名

否则，内部类中的局部变量会覆盖外部类的成员变量。

而访问内部类本身的成员变量可用this.属性名，访问外部类的成员变量需要使用Out.this.属性名。

另外还有两种特殊的内部类：局部类（local class）和匿名类（anonymous class）

局部类是定义在代码块中的类，通常是在一个方法内，称作方法内部类。

匿名类的申明与实例化是同时完成的，它与局部类很相似，除了没有名字之外。

例3. 局部类

class Out {

    private int age = 12;
    public void Print(final int x) {
        class In {
            public void inPrint() {
                System.out.println(x);
                System.out.println(age);
            }
        }

        new In().inPrint();
    }
}

 

public class Demo {

    public static void main(String[] args) {
        Out out = new Out();
        out.Print(3);
    }
}

运行结果：

3

12

在上面的代码中，将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法。

例4. 匿名类

public class OutClasses {
  
    interface HelloWorld {
        public void greetSomeone(String someone);
    }
  
    public void sayHello() {
        
        HelloWorld germanGreeting = new HelloWorld() {//这里申明了一个匿名类，它的实例是germanGreeting
            String name = "mundo";
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hallo, " + name);
            }
        };
        germanGreeting.greetSomeone("Sommer");
    }

    public static void main(String... args) {
        OutClasses myApp = new OutClasses();
        myApp.sayHello();
    }            
}

运行结果：Hallo，Sommer

匿名类是一个表达式（分号结尾），常见于GUI应用程序中。它的语法类似于调用构造器，区别在于该类的定义紧跟其后。没有class关键字，如何判断匿名类呢？

1)要有new 这个操作符，类似正常类实例化的表达式。

2)要实现一个接口或继承一个类，上面的例子是实现HelloWorld这个接口。

3)类体（body），可以在其中定义域、方法，甚至局部类，但是不能定义构造器，也不能有语句（statement）。

本文部分参考Nerxious的博客 http://www.cnblogs.com/nerxious/archive/2013/01/24/2875649.html