在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类
为什么使用内部类？
如果这个类没有定义在外部的必要，即使此类仅供外部类的方法来调用，而不会被其他外部类调用。
package com.atguigu.java; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; /** * 内部类: * 1. 在类的内部定义的类成为内部类 * 2. 内部类相当于类的一个成员, 可以修饰类的成员的 private, static, final, abstract 都可以修饰内部类 * 3. 声明、使用内部类的实例. * 3.1 非静态内部类的创建, 先创建外部类的实例, 再通过 外部类名.new 创建内部类的实例. * OuterClass oc = new OuterClass(); * OuterClass.InnerClass in = oc.new InnerClass(); * * 3.2 静态内部类的创建: 不再需要外部类的实例. * OuterClass.StaticInnerClass sic = new OuterClass.StaticInnerClass(); * * 4. 内部类引用外部类的成员: * * 5. ** 匿名内部类对象: 使用某一个接口通常是 先创建接口的实现类, 再创建其实现类的对象. * 还可以, 直接创建其实现类对象. * * InvocationHandler invocationHandler = new InvocationHandler() { * @Override * public Object invoke(Object proxy, Method method, Object[] args) * throws Throwable { * return null; * } * }; * * */ public class OuterClass { int age; static class StaticInnerClass{ void test(){ //System.out.println(age); } } static String name = "-1"; //内部类 class InnerClass{ String name = "0"; public void test(){ String name = "1"; System.out.println(name); //1 System.out.println(this.name); //0 System.out.println(OuterClass.this.name); //-1 } } }
package com.atguigu.java; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class TestInnerClass { public static void main(String[] args) { OuterClass.StaticInnerClass sic = new OuterClass.StaticInnerClass(); OuterClass oc = new OuterClass(); OuterClass.InnerClass in = oc.new InnerClass(); in.test(); Proxy.newProxyInstance(null, null, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub return null; } }); InvocationHandler invocationHandler = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return null; } }; } }
使用匿名内部类课使代码更加简洁、紧凑，模块化程度更高。内部类能够访问外部内的一切成员变量和方法，包括私有的，而实现接口或继承类做不到。
就是匿名内部类的两种实现方式：
第一种，继承一个类，重写其方法；
第二种，实现一个接口（可以是多个），实现其方法。下面通过代码来说明：
不使用内部类
abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat something"); } } public class Demo { public static void main(String[] args) { Person p = new Child(); p.eat(); } }
运行结果：eat something
可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用
但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？
这个时候就引入了匿名内部类
abstract class Person { public abstract 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(); } }
运行结果：eat something
可以看到，我们直接将抽象类Person中的方法在大括号中实现了
这样便可以省略一个类的书写
原文：http://www.cnblogs.com/tech-bird/p/3514753.html