．有关内部类介绍说明
1)在个类中定义另外个类这个类就叫做内部类(inner ) 内部类定义和普通类定义没什么区别它可以直接访问和引用它外部类所有变量和思路方法(包括private)就像外部类中其他非成员功能样区别是外部类只能声明为public和default而内部类可以声明为private和protected

2)当我们建立个inner 时其对象就拥有了和外部类对象的间种关系这是通过个特殊this reference形成当内部类成员思路方法中访问某个变量/思路方法时如果在该思路方法和内部类中都没有定义过这个变量就会被传递给内部类中保存那个外部类对象引用(OuterClass.this)通过那个外部类对象引用去这个变量

2．内部类变量访问
2.1在中直接从外部类内部类思路方法
package org.zj.sample;
Outer {
private index = 100;
Inner {
private index = 50;
void pr {
index = 30;
.out.prln(index); // 30
.out.prln(this.index); // 50
.out.prln(Outer.this.index); // 100
}
}

void pr {
Inner inner = Inner;//得到内部类引用
inner.pr;
}
}

Test {
public void (String args) {
Outer outer = Outer;
outer.pr;
}
}

该举例列出了重名成员变量分布3种情况
访问内部类思路方法中变量:
.out.prln(index);

访问内部类中成员变量:
.out.prln(this.index);

访问所在外部类成员变量:
.out.prln(Outer.this.index);


2.2在中显式返回内部类引用
package org.zj.example;
Outer {
private index = 100; [Page]
Inner {
private index = 50;
void pr {
index = 30;
.out.prln(index); // 30
.out.prln(this.index); // 50
.out.prln(Outer.this.index); // 100
}
}

Inner getInner {
Inner;//返回个内部类引用
}
}

Test {
public void (String args) {
Outer outer = Outer;
Outer.Inner inner = outer.getInner;
inner.pr;
}
}


2.3当思路方法在Outer类内部
package org.zj.sample1;
Outer {
private index = 100;
Inner {
private index = 50;
void pr {
index = 30;
.out.prln(index); // 30
.out.prln(this.index); // 50
.out.prln(Outer.this.index); // 100
}





}

Inner getInner {
Inner;
}

public void (String args) { [Page]
Outer outer = Outer;
Inner inner = outer.getInner; // 注意此处变化
inner.pr;
}
}


2.4在思路方法中直接产生内部类对象
package org.zj.sample2;
Outer {
private index = 100;
Inner {
private index = 50;
void pr {
index = 30;
.out.prln(index); // 30
.out.prln(this.index); // 50
.out.prln(Outer.this.index); // 100
}
}
}

Test {
public void (String args) {
Outer outer = Outer;
Outer.Inner inner = outer. Inner; // 注意此处变化
inner.pr;
}
}


2.5在思路方法中定义内部类
在思路方法中定义内部类只能访问思路方法中final类型局部变量用final定义局部变量相当于是个常量它生命周期超出思路方法运行生命周期而且思路方法体中内部类不能有访问介绍说明符
package org.zj.sample;
InOut {
String str= String(\"Between\");
public void amethod(final aArgs){
Inner{
public Inner{
.out.prln(\"This is Inner.\");//此句可看出它和匿名内部类使用方法区别
}
public void sayHello{ [Page]
.out.prln(str);
.out.prln(aArgs);
}
}
Inner inner= Inner;//此句必须放在定义类Inner后面
inner.sayHello;
}

public void (String args){
InOut inOut= InOut;
inOut.amethod(33);
}
}

在思路方法体中使用内部类可以使用个已命名构造子或重载构造子而匿名内部类只能用于例子化

3．内部类继承
当个类继承自个内部类时缺省构造器不可用必须使用如下语法:
enclosingClassReference.super;(见下例绿色部分)
package org.zj.sample;
WithInner{
Inner{
public void sayHello{
.out.prln(\"Hello.\");
}
}
}
public InheritInner extends WithInner.Inner {
InheritInner(WithInner wi){
wi.super;
}
public void (String args) {
WithInner wi= WithInner;
InheritInner ii= InheritInner(wi);
ii.sayHello;





}
}


结果:
Hello.

4．匿名内部类
未使用匿名内部类情况:这里单独写了个内部类Inner
package org.zj.example;
abstract A{
abstract public void sayHello;
}

Outer {
public void (String args){
Inner extends A{
public void sayHello{ [Page]
.out.prln(\"Hello!\");
}
}
Outer.callInner( Inner);
}

public void callInner(A a){
a.sayHello;
}
}

使用匿名内部类情况:直接在 A中给出Inner定义
package org.zj.example;
abstract A{
abstract public void sayHello;
}

Outer {
public void (String args){
Outer.callInner( A{
public void sayHello{
.out.prln(\"Hello!\");
}
});
}

public void callInner(A a){
a.sayHello;
}
}


5．内部类2种特殊使用方法
个类从另个类派生出来又要实现个接口但在接口中定义思路方法和父类中定义思路方法意义区别则可以利用内部类来解决这个问题
package org.zj.sample;
erface Machine {
void run;
}

Person {
void run {
.out.prln(\"run\");
}
}

Robot extends Person {
private MachineHeart implements Machine {
public void run {
.out.prln(\"heart run\");
}
}

Machine getMachine {
MachineHeart;
} [Page]
}

Test {
public void (String args) {
Robot robot = Robot;
Machine m = robot.getMachine;
m.run;
robot.run;
}
}

在Robot类内部使用内部类MachineHeart来实现接口Machinerun思路方法同时Robot类又继承了父类Personrun思路方法如果不使用内部类MachineHeart而使Robot直接实现接口Machine则该如何父类run思路方法？

利用内部类可解决c中多重继承所解决问题
package org.zj.example;
A {
void fn1 {
.out.prln(\"It’s fn1.\");
}
}

abstract B {
abstract void fn2;
}

C extends A {
B getB {
B {
public void fn2 {
.out.prln(\"It’s fn2.\");
}
};
}
}

Test {
public void (String args) {

C c = C;
c.fn1;
c.getB.fn2;
}
}

类C既要继承类A又要继承类B则可将类B定义放入类C内部使的成为内部类

6．我们为什么使用内部类
这是对上章节两种使用方法整理总结可结合上章节两个例子分析
1) 当我们需要在某情形下实现个接口而在另情形下又不需要实现这个接口时我们可以使用内部类来解决这问题让内部类来实现这个接口
2) 内部类有效解决了多重继承问题