外部类与内部类

众所周知，每个java文件必须有一个与这个java文件同名的外部类，这个外部类可以是public或default的。而除了这个同名外部类，还可以有与这个同名外部类平级的其他外部类，但它们必须是default的。

而内部类是指在外部类的内部再定义一个类。

内部类的分类

我们所说的内部类，官方的叫法是嵌套类(Nested Classes)。嵌套类包括静态内部类(Static Nested Classes)和内部类(Inner Classes)。而内部类分为成员内部类，局部内部类(Local Classes)和匿名内部类(Anonymous Classes)。

但按我的理解来看，应该这么画图：

而从使用方法来讲，则应该把静态内部类和成员内部类归在一起，因为这两种是可以通过outer.staticInner或者outer.memberInner这种.语法来使用类名的。与之相对，局部内部类和匿名内部类是无法通过.语法来使用类名，这是因为这二者的使用范围会被限定到某个作用域之内(即在某对{...}大括号之中)，也是因为这二者不是作为外部类的成员(既不是静态成员，也不是实例成员)。

非静态内部类的对象创建时，会依赖到外部类对象(持有外部类对象引用)。但具体的说，是指在non-static context这种上下文中。更具体的说，成员内部类一定会持有外部类对象引用，局部内部类(具名或匿名)却不一定。

内部类可以访问外部类的私有方法，和私有成员。

局部内部类不管是具名还是匿名的，其类定义前不可以加上static(究其原因是局部内部类不属于外部类的成员，只有成员才有静态和非静态之分)。同样，其成员和方法也不可以加上static。

局部内部类包括匿名内部类，即局部内部类中分别两种：具名的、匿名的。匿名的就叫匿名内部类了。

具名的局部内部类的类定义不可以加上访问权限限定词。public protected private都不可以。

局部内部类

局部内部类分为两种：1.通过继承抽象类或实现接口或普通类来定义新类(将用这种举例，因为这种更具有实用价值) 2.直接定义一个新类(虽然感觉这样做没什么用)。如果是匿名内部类则只有第1种。

首先给一个interface：

public interface Destination {

String readLabel();

}

局部内部类访问外部类成员(non-static context)

当局部内部类的类定义处于一个非静态上下文时，局部内部类可以访问外部类的私有成员(静态或非静态)或私有方法(静态或非静态)：(对于具名的还是匿名的都成立)

public class test3 {

private int num = 1;

private static int snum = 2;

private String returnString(){

return "outer string";

}

private static String sreturnString(){

return "static outer string";

}

public Destination destination() {//这里是非静态方法，属于非静态context

class PDestination implements Destination {

private String label;

//内部类访问外部类私有成员，这里改成snum也可以

private int i = num;

private PDestination() {

//内部类访问外部类私有方法，这里改成sreturnString也可以

label = returnString();

}

public String readLabel() { return label; }

}

return new PDestination();

}

public static void main(String[] args) {

test3 t = new test3();

Destination d = t.destination();

}

}

局部内部类访问外部类成员(static context)

public class test3 {

private int num = 1;

private static int snum = 2;

private String returnString(){

return "outer string";

}

private static String sreturnString(){

return "static outer string";

}

public static void testNamed(){//静态方法内，具名的局部内部类

class PDestination implements Destination {

private String label = "named inner";

public String readLabel() { return label; }

public void test(){

sreturnString();

//non-static method returnString() cant be refenrenced from a static context

//returnString();//无法通过编译

}

}

}

public static void testNoNamed() {//静态方法内，匿名内部类

Destination d = new Destination(){

private String label = "no named inner";

public String readLabel() { return label; }

public void test(){

sreturnString();

//non-static method returnString() cant be refenrenced from a static content

//returnString();//无法通过编译

}

};

}

public static Destination d = new Destination(){//作为静态成员，的匿名内部类

private String label = "no named inner";

public String readLabel() { return label; }

public void test(){

sreturnString();

//non-static method returnString() cant be refenrenced from a static content

//returnString();//无法通过编译

}

};

public static void main(String[] args) {

test3 t = new test3();

}

}

经过测试发现，当局部内部类(具名或匿名)的类定义属于static context时，是不可以访问外部类的非静态成员或方法。道理很简单，static context是类相关的，此时可能没有对象，当然不能访问非静态的东西，也就是说，这种情况下局部内部类对象没有持有外部类对象的引用。上面测试了三种static context的情况：

静态方法内，具名的局部内部类

静态方法内，匿名内部类

作为静态成员，的匿名内部类

外部类访问局部内部类成员

在局部内部类的作用域内(指包裹内部类的那个{...}内)，内部类之外，是可以随意访问内部类对象的私有成员的。(注意，构造器可以直接访问；但方法和成员则必须通过内部类对象的.语法来访问哦；但一旦出了作用域，除了接口规定好的方法外，其他的方法和成员都无法访问，因为编译器只认为对象是一个Destination对象)：(对于具名的还是匿名的都成立)

public class Parcel5 {

public Destination destination(String s) {

class PDestination implements Destination {

private String label;

private PDestination(String whereTo) {

label = whereTo;

}

public String readLabel() { return label; }

}

//访问了内部类私有的构造器

return new PDestination(s);

}

public String getLabel(String s) {

class PDestination implements Destination {

private String label;

private PDestination(String whereTo) {

label = whereTo;

}

public String readLabel() { return label; }

}

//访问了内部类对象的私有成员

return new PDestination(s).label;

}

public static void main(String[] args) {

Parcel5 p = new Parcel5();

Destination d = p.destination("Tasmania");

//System.out.println(d.label); cant resolve symbol label

//new PDestination("");

System.out.println(p.getLabel("private string"));

}

}

给内部类成员赋值

当然，上面例子也可以改成，方法参数直接给内部类成员赋值：

public class Parcel5 {

public Destination destination(String s) {

class PDestination implements Destination {

//private String label = s; //定义字段时同时初始化

//也可以把下面四行注释掉，上面这行注释取消掉

private String label;

PDestination(){

label = s;

}

public String readLabel() { return label; }

}

return new PDestination();

}

public static void main(String[] args) {

Parcel5 p = new Parcel5();

Destination d = p.destination("Tasmania");

}

}

局部内部类还可以访问局部变量，在jdk1.8以前这个局部变量必须加上final，由于本人jdk是1.8，新特性支持不需要加final了(注意形参也是局部变量，所以上面的例子也不需要加final)(虽然不用加final，但编译器会自动加上只是我们看不见，以保证变量初始化以后不会变，但是通常最好加上 final 作为一种暗示)。(对于具名的还是匿名的都成立)

public class Parcel5 {

public Destination destination(String s) {

int temp = 123;//局部变量

class PDestination implements Destination {

private String label = s;

private int num = temp;//访问局部变量

public String readLabel() {

return label;

}

}

return new PDestination();

}

public static void main(String[] args) {

Parcel5 p = new Parcel5();

Destination d = p.destination("Tasmania");

System.out.println(d.readLabel());

}

}

匿名内部类

使用匿名内部类的情况只能是：创建的匿名内部类继承某个类。

继承一个外部类，或静态内部类，或成员内部类，都可以。

继承一个抽象类abstract class。

实现一个接口interface。

然后通过new表达式返回的引用被自动向上转型为对其父类的引用。既然是父类引用指向子类对象，只不过这个子类有点特殊，它没有名字。所以其父类被当做“接口”使用：

如果是普通类，那么通过覆盖非静态方法，可以实现多态。

如果是抽象类，那么实现其抽象方法。

如果是接口，那么实现其所有方法。

当获得匿名内部类对象后，只能调用其父类已经定义好的方法，所以才说其父类被当做“接口”使用。

简单示例如下：

public interface Contents {

int value();

}

public class Parcel7 {

public Contents contents() {

return new Contents() { // 调用父类的默认构造器

private int i = 11;

public int value() { return i; }

}; // 需要分号

}

public static void main(String[] args) {

Parcel7 p = new Parcel7();

Contents c = p.contents();

}

}

在上面例子中调用了父类的默认构造器，如果父类的构造器是有参数的：

public class Wrapping {

private int i;

public Wrapping(int x) { i = x; }//父类的有参构造器

public int value() { return i; }

}

public class Parcel8 {

public Wrapping wrapping(int x) {

// Base constructor call:

return new Wrapping(x) { // 直接传递这个参数给父类的有参构造器

public int value() {

return super.value() * 47;//调用父类的value方法

}

};

}

public static void main(String[] args) {

Parcel8 p = new Parcel8();

Wrapping w = p.wrapping(10);

}

}

由于匿名内部类没有名字，自然也没有构造器了。但可以通过实例初始化块来起到构造器的作用：

public class Parcel10 {

public Destination destination(String dest, float price) {

return new Destination() {

private int cost;

// Instance initialization for each object 这里就是实例初始化块

{

cost = Math.round(price);

if(cost > 100)

System.out.println("Over budget!");

}

private String label = dest;

public String readLabel() { return label; }

};

}

public static void main(String[] args) {

Parcel10 p = new Parcel10();

Destination d = p.destination("Tasmania", 101.395F);

}

}

局部内部类、匿名内部类比较

匿名内部类没有名字，也就没有构造器，只有通过实例初始化块。

相比具名的局部内部类，匿名内部类有些受限，因为只能继承或实现一个类或接口。

当我们需要一个命名的构造器或者需要重载构造器(重载构造器自然需要名字)，需要使用具名的局部内部类。

当我们需要在作用域中一次定义，多次创建对象时，则需要使用具名的局部内部类。