Java：内部类

1、内部类的定义：

　　一个内部类可以定义在另一个类里，可以定义在函数里，甚至可以作为一个表达式的一部分。

2、内部类的分类：

Java中的内部类共分为四种：

　　成员内部类member inner class

　　局部内部类local inner class　

　　匿名内部类anonymous inner class

　　静态内部类static inner class

　　

2.1、成员内部类member inner class

成员内部类是最普通的内部类，它的定义为位于另一个类的内部

package inner;

public class Outer {// 外部类
String outerLabel = "outer";
private int i = 1;
static int j = 11;
public void printOuterLabel(){
System.out.println(outerLabel+"\t"+i+"\t"+j);
}
class Inner{// 内部类
String innerLabel = "inner";
public void printInnerLabel(){
System.out.println(outerLabel+"\t"+innerLabel+"\t"+i+"\t"+j);
}
}
// 外部类调用内部类的引用，需要通过new关键字新建对象
public void printInner(){
Inner inner = new Inner();
inner.printInnerLabel();
}
public static void main(String[] args){
Outer outer = new Outer();
outer.printOuterLabel();
outer.printInner();
}

}

输出

outer    1    11
outer    inner    1    11

说明：

1.内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。

2.内部类的对象只有在与其外部类的对象相关联的情况下才被创建

3.当内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是内部类的成员

当内部类需要访问外部类同名变量或者方法的时候，通过下面方法

外部类.this.成员变量
外部类.this.成员方法

package inner;

public class Outer {// 外部类
String Label = "outer";
private int i = 1;
static int j = 11;
public void printLabel(){
System.out.println(Label+"\t"+i+"\t"+j);
}
class Inner{// 内部类
String Label = "inner";
public void printLabel(){
// 内部类中调用外部类的同名变量、方法
System.out.println(Outer.this.Label+"\t"+Label+"\t"+i+"\t"+j);
Outer.this.printLabel();
}

}
// 外部类调用内部类的引用，需要通过new关键字新建对象
public void printInner(){
Inner inner = new Inner();
inner.printLabel(); // 内部类的方法
}
public static void main(String[] args){
Outer outer = new Outer();
outer.printLabel();
outer.printInner();
}

}

输出

outer    1    11
outer    inner    1    11
outer    1    11

在内部类需要生成外部类对象的引用，可以下面方法

外部类.this

这里在内部类获取了外部类的引用，就可以很方面的操作外部类

package inner;

public class Outer {// 外部类
String Label = "outer";
private int i = 1;
static int j = 11;
public void printLabel(){
System.out.println(Label+"\t"+i+"\t"+j);
}
class Inner{// 内部类
public Outer outer(){
return Outer.this;
}

}
// 外部类 返回内部类的引用
public Inner inner(){
return new Inner();
}
public static void main(String[] args){
Outer outer = new Outer();
Outer.Inner inner = outer.inner();
inner.outer().printLabel();
}

}

当其他对象要创建内部类的对象时候需要通过

new 外部类().new 内部类()

package inner;

public class Outer {// 外部类
String Label = "outer";
private int i = 1;
static int j = 11;
public void printLabel(){
System.out.println(Label+"\t"+i+"\t"+j);
}
class Inner{// 内部类
public Outer outer(){
return Outer.this;
}

}
// 外部类 返回内部类的引用
public Inner inner(){
return new Inner();
}
public static void main(String[] args){
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.outer().printLabel();
}

}

输出和上面一样

通过.new 访问内部类，而内部类又是返回外部类的对象，通过这个对象我们就可以很方面的操作外部类的对象，变量等。

2.2、局部内部类local inner class

在方法的作用域内创建的一个完整类，称为局部内部类

package inner;

public class Parcel2 {// 外部类
public Destination destination(String s){ // 方法内
class PDestination implements Destination{ // 方法内的内部类-->局部内部类
private String label;
private PDestination(String to){
this.label = to;
}
public String readLabel(){
return label;
}
}
return new PDestination(s);
}

public static void main(String[] args) {
Parcel2 p = new Parcel2();
Destination d = p.destination("label");
System.out.println(d.readLabel());
}

}

接口

package inner;

public interface Destination {
String readLabel();
}

输出

label

局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

局部内部类属于其所在的方法，不属于外部类

2.3、匿名内部类anonymous inner class

接口

package inner;

public interface Contents {
int value();
}

package inner;

public class Parcel7 {
public Contents contents(){ // contents 方法将返回值的生成与表示这个返回值的类的定义结合在一起
return new Contents(){
private int i = 10;
public int value(){
return i;
}
};
}
public static void main(String[] args){
Parcel7 p = new Parcel7();
Contents c = p.contents();
System.out.println(c.value());
}
}

建立匿名内部类的关键点是重写父类的一个或多个方法。

上面匿名内部类等价于：

package inner;

public class Parcel7b {
class MyContents implements Contents{
private int i = 10;
public int value(){
return i;
}
}
public Contents contents(){
return new MyContents();
}
public static void main(String[] args){
Parcel7b p = new Parcel7b();
Contents c = p.contents();
System.out.println(c.value());
}
}

上面就是成员内部类

2.4、静态内部类static inner class

当内部类是static时，就是静态内部类

注意：

（1）要创建静态内部类的对象，并不需要其外部类的对象

（2）不能从内部类的对象中访问非静态的外部类对象

package inner;

public class Outer {// 外部类
static String Label = "outer";
int size = 10;
static class Inner{ // static 修饰
public void print(){
System.out.println(Label);
}

}
public static void main(String[] args){

Outer.Inner inner = new Outer.Inner();
inner.print();
}

}

3、为什么需要内部类？

内部类继承自某个类或实现某个接口，内部类的代码操作创建的外部类的对象，所以可以认为内部类提供了某种进入外部类的窗口

每个内部类都能独立底基础自一个接口的实现，所有无论外部类是否已经继承了某个接口的实现，对于内部类都是没有影响的

内部类允许继承多个抽象类

参考：《算法导论》---自己写的很差