java内部类种类解读

内部类(nested classes)   面向对象程序设计中，可以在一个类的内部定义另一个类。
表现形式为4种：  1、静态内部类
 2、成员内部类
 3、局部内部类
 4、匿名内部类 （重点）
内部类的优点：
内部类对象可以访问创建它的对象的实现，包括私有数据；
内部类不为同一包的其他类所见，具有很好的封装性；
使用内部类可以很方便的编写事件驱动程序；（例如android的图形界面编程采用事件驱动机制）
匿名内部类可以方便的定义运行时回调；
内部类可以方便的定义
内部类的共性：
内部类仍然是一个独立的类，在编译之后内部类会编译成独立的.class文件，外部类的类名和$符号
内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，不管权限修饰符
内部类声明成静态的，就不能随便的访问外部类的成员变凉了，外部类可通过类名. 访问内部类的静态成员

一、静态内部类
最简单的内部类形式、类定义时加上static关键字、不能和外部类有相同的名字
只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法
简单理解为可以想其他静态成员一样，没有外部类对象时，也能访问它
生成静态内 部类对象的方式为：
OutClass.InClass  in=new OutClass.InClass();
        例代码
class OuterClass{
static class InClass{
public void test(){
//静态内部类可以访问外部类的静态成员
//并且只能访问静态的
System.out.println("方法");
}
}
}
class Test {
public static void main(String[] args){
OutClass.InClass in=new OutClass.InClass();
in.test();
}
}
二、成员内部类
成员内部类和静态内部类类似非静态的成员变量和静态的成员变量
它可以访问它外部类的所有变量和方法
在外部类里面创建成员内部类的实例：
this.new Inclass();
　　 在外部类之外创建内部类的实例：
　　 (new Outclass()).new Inclass();
　　 在内部类里访问外部类的成员：
　　 Outclass.this.member
例代码 class Inner1{
private int b=1;
private int a=2;
// 定义一个成员内部类
public class Inner2{
private int a=3;
public void doSomething()
{
// 直接访问外部类对象
System.out.println(b);
System.out.println(a);// 直接访问a，则访问的是内部类里的a
// 如何访问到外部类里的a呢？
System.out.println( Inner1.this.a);
}
}
}
public class InnerClassTest
{
public static void main(String[] args)
{
// 创建成员内部类的对象
// 需要先创建外部类的实例
Inner1.Inner2 in = new Inner1().new Inner2();
inner.doSomething();
}
}三、局部内部类（也称为方法内部类）
类定义在方法中，比方法的范围还小，只能在方法中使用，内部类最少用的一种
跟局部变量一样，不能被public、protected、private和static修饰
只能访问方法中funal类型的局部变量
四、匿名内部类
当一个类只用到一次时使用匿名内部类，它在定义后立即使用
不使用关键字class, extends, implements, 没有构造方法。
匿名内部类不能是public,protected,private,static  不能定义任何静态成员、静态方法
匿名内部类隐式地继承了一个父类或者实现了一个接口。
匿名内部类使用得比较多，通常是作为一个方法参数。
1、继承式的匿名内部类

public class Car {
public void drive(){
System.out.println("a car!");
}
public static void main(String[] args) {
Car car = new Car(){
public void drive() {
System.out.println("b car!");
}
};
car.drive();
}
}

结果输出了：b car! Car引用变量不是引用Car对象，而是Car匿名子类的对象

2、接口式的匿名内部类。
interface Vehicle {
public void drive();
}
class Test{
public static void main(String[] args) {
Vehicle v = new Vehicle(){
public void drive(){
System.out.println(" a car!");
}
};
v.drive();
}
}
上面的代码很怪，好像是在实例化一个接口。事实并非如此，接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。

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